Showing papers on "Pushdown automaton published in 1999"

Improved Automata Generation for Linear Temporal Logic

Abstract: We improve the state-of-the-art algorithm for obtaining an automaton from a linear temporal logic formula. The automaton is intended to be used for model checking, as well as for satisfiability checking. Therefore, the algorithm is mainly concerned with keeping the automaton as small as possible. The experimental results show that our algorithm outperforms the previous one, with respect to both the size of the generated automata and computation time. The testing is performed following a newly developed methodology based on the use of randomly generated formulas.

Relating Probabilistic Grammars and Automata

Abstract: Both probabilistic context-free grammars (PCFGs) and shift-reduce probabilistic pushdown automata (PPDAs) have been used for language modeling and maximum likelihood parsing. We investigate the precise relationship between these two formalisms, showing that, while they define the same classes of probabilistic languages, they appear to impose different inductive biases.

A minimized automaton representation of reachable states

Abstract: We consider the problem of storing a set S⊂Σkas a deterministic finite automaton (DFA). We show that inserting a new string σ∈Σk or deleting a string from the set S represented as a minimized DFA can be done in expected time O(k|Σ|), while preserving the minimality of the DFA. The method can be applied to reduce the memory requirements of model checkers that are based on explicit state enumeration. As an example, we discuss an implementation of the method for the model checker Spin.

Using JFLAP to interact with theorems in automata theory

Abstract: An automata theory course can be taught in an interactive, hands-on manner using a computer. At Duke we have been using the software tool JFLAP to provide interaction and feedback in CPS 140, our automata theory course. JFLAP is a tool for designing and running nondeterministic versions of finite automata, pushdown automata, and Turing machines. Recently, we have enhanced JFLAP to allow one to study the proofs of several theorems that focus on conversions of languages, from one form to another, such as converting an NFA to a DFA and then to a minimum state DFA. In addition, our enhancements combined with other tools allow one to interactively study LL and LR parsing methods.

Minimal cover-automata for finite languages

Abstract: A cover-automaton A of a finite language L ⊆ Σ * is a finite automaton that accepts all words in L and possibly other words that are longer than any word in L. A minimal deterministic cover automaton of a finite language L usually has a smaller size than a minimal DFA that accept L. Thus, cover automata can be used to reduce the size of the representations of finite languages in practice. In this paper, we describe an efficient algorithm that, for a given DFA accepting a finite language, constructs a minimal deterministic finite cover- automaton of the language. We also give algorithms for the boolean operations on deterministic cover automata, i.e., on the finite languages they represent.

An Insertion into the Chomsky Hierarchy

Abstract: This review paper will report on some recent discoveries in the area of Formal Languages, chiefly by F. Otto, G. Buntrock and G. Niemann. These discoveries have pointed out certain break-throughs connected with the concept of growing context-sensitive languages, which originated in the 1980’s with a paper by E. Dahlhaus and M.K. Warmuth. One important result is that the deterministic growing context-sensitive languages turn out to be identical to an interesting family of formal languages definable in a certain way by confluent reduction systems.

Model checking of message flow diagrams

Abstract: Model checking for message sequence charts (MSCs), message sequence chart graphs and hierarchical message sequence chart graphs (HMSCs) is provided. To verify the behavior of a given MSC, MSC graph and HMSC, a specification automaton is constructed. This specification automaton specifies the undesirable executions of the model under analysis. From the model under analysis, linearizations are defined from the model and a finite test automaton is constructed from the linearizations. The test automaton and the specification automaton are combined and it is determined whether there is an execution in the intersection. Where no state in the specification automaton is reachable from the test automaton, the model is verified.

Grammars and automata to optimize chain logic queries

Abstract: The critical problem of finding efficient implementations for recursive queries with bound arguments offers many open challenges of practical and theoretical import. In particular, there is a need to find methods that are effective for the general case, such as non-linear programs, as well as for specialized cases, such as left-recursive linear programs. In this paper, we propose a novel approach that solves this problem for chain queries, i.e., for queries where bindings are propagated from arguments in the head to arguments in the tail of the rules, in a chain-like fashion. The method, called pushdown method, is based on the fact that a chain query can have associated a context-free language and a pushdown automaton recognizing this language can be emulated by rewriting the query as a particular factorized left-linear program. The proposed method generalizes and unifies previous techniques such as the 'counting' and 'right-, left-, mixed-linear' methods. It also succeeds in reducing many non-linear programs to query-equivalent linear ones.

Strengthened Results on Nonregular PDL

Abstract: We continue the ongoing investigation of decidability and undecidability of nonregular extensions of propositional dynamic logic (PDL), by proving two results. The first strengthens the undecidability result of Harel and Singerman regarding one-letter Fibonacci-like extensions, by showing undecidability for a more general class of exponentially growing sequences. The second strengthens the decidability result of Harel and Raz for languages accepted by simple-minded pushdown automata, by showing that the important thing for decidability is that the stack behavior depends only on the input symbol.

On the Power of Las Vegas II. Two-Way Finite Automata

Abstract: The investigation of the computational power of randomized computations is one of the central tasks of complexity and algorithm theory. This paper continues in the comparison of the computational power of Las Vegas computations with the computational power of deterministic and nondeterministic ones. While for one-way finite automata the power of different computational modes was successfully determined one does not have any nontrivial result relating the power of determinism, Las Vegas and nondeterminism for two-way finite automata. The three main results of this paper are the following ones. (i) If, for a regular language L, there exist small two-way nondeterministic finite automata for both L and LC, then there exists a small two-way Las Vegas finite automaton for L. (ii) There is a quadratic gap between nondeterminism and Las Vegas for two-way finite automata. (iii) For every k ∈ N, there is a regular language Sk such that Sk can be accepted by two-way Las Vegas finite automaton with O(k) states, but every two-way deterministic finite automaton recognizing Sk has at least Ω(k2= log2 k) states.

Counter Machines: Decision Problems and Applications

Abstract: We give a brief survey of the (un)decidable properties of multicounter machines. In particular, we present some of the strongest decidable results (concerning emptiness, containment, and equivalence) known to date regarding these machines. We also discuss some applications.

Characterizing the ability of parallel array generators on reversible partitioned cellular automata

Abstract: A PCAAG introduced by Morita and Ueno is a parallel array generator on a partitioned cellular automaton (PCA) that generates an array language (i.e. a set of symbol arrays). A "reversible" PCAAG (RPCAAG) is a backward deterministic PCAAG, and thus parsing of two-dimensional patterns can be performed without backtracking by an "inverse" system of the RPCAAG. Hence, a parallel pattern recognition mechanism on a deterministic cellular automaton can be directly obtained from a RPCAAG that generates the pattern set. In this paper, we investigate the generating ability of RPCAAGs and their subclass. It is shown that the ability of RPCAAGs is characterized by two-dimensional deterministic Turing machines, i.e. they are universal in their generating ability. We then investigate a monotonic RPCAAG (MRPCAAG), which is a special type of an RPCAAG that satisfies monotonic constraint. We show that the generating ability of MRPCAAGs is exactly characterized by two-dimensional deterministic linear-bounded automata.

A Generalization of Regular Expressions

Abstract: CF-expressions are defined which generalize the regular one. It is established that so called pseudo-coiterating CF-expressions characterize the regular sets. The results are used to de- velop some more characterizations of the regular sets: the pseudo-coiterating D-graphs and the pseudo-coiterating pushdown automata (PDAs). An algorithm is presented for deciding whether a device of three mentioned types is pseudo-coiterating or not. Apparently, the pseudo-coiterating PDAs form the most large of classes of PDAs the solvability of the question of belonging to which was proved and which are known as characterizations of the regular sets. In this development we attempt to express adequately the common essence of the follow- ing formal descriptions of the context-free (in shorthand form, CF) languages: D-graphs, PDAs, and CF-grammars. Defined here CF-expressions summarize the essence of the mentioned formalisms. Now it is possible the most accurate description of the primi- tives for pumping of CF-words. The stated here Growth Theorem for the CF-expressions indicates such a description. As a consequence, we define easily a subclass of the CF-expressions that characterizes the regular sets. This subclass is remarkable by its wideness that is compatible to the wideness of the CF-grammars without self-embedding symbols. Further, this result indicates the subclass of PDAs (the so-called pseudo-coiterating PDAs) that characterizes the regular sets. There exists an algorithm for deciding, once any PDA is given, whether it is pseudo-coiterating or not. Thus, the present paper contains the sufficient condition of CF-language regularity which can be checked.

An Algorithm to Verify Local Threshold Testability of Deterministic Finite Automata

Abstract: A locally threshold testable language L is a language with the property that for some nonnegative integers k and l, whether or not a word u is in the language L depends on (1) the prefix and suffix of the word u of length k-1 and (2) the set of intermediate substrings of length k of the word u where the sets of substrings occurring at least j times are the same, for j ? l. For given k and l the language is called l-threshold k-testable. A finite deterministic automaton is called l-threshold k-testable if the automaton accepts a l-threshold k-testable language.In this paper, the necessary and sufficient conditions for an automaton to be locally threshold testable are found. We introduce the first polynomial time algorithm to verify local threshold testability of the automaton based on this characterization.New version of polynomial time algorithm to verify the local testability will be presented too.

Prefix pushdown automata and their simplification

Abstract: A prefix pushdown automatonM, accepts a wordx, with respect to a languageZ, if and only if M makes a sequence of moves so it reads xy, for some y∊Z, and enters a final state. This paper demonstrates that for every recursively enumerable languageL, there exist a linear languageZ, and a prefix pushdown automatonM, so that L equals the prefix language that M accepts with respect to Z. Besides the acceptance by final state, this result is established in terms of acceptance by empty pushdown and acceptance by final state and empty pushdown. In addition, the present paper demonstrates this result for some simplified versions of prefix pushdown automata. Finally, it discusses the descriptional complexity of these automata