Sweeping Input-Driven Pushdown Automata

Input-driven pushdown automata (IDPDA) are pushdown automata where the next action on the pushdown store (push, pop, nothing) is solely governed by the input symbol. Nowadays such devices are usually defined such that popping from the empty pushdown does not block the computation but continues it with empty pushdown. Here, we consider IDPDAs that have a more balanced behavior concerning pushing and popping. Digging input-driven pushdown automata (DIDPDA) are basically IDPDAs that, when forced to pop from the empty pushdown, dig a hole of the shape of the popped symbol in the bottom of the pushdown. Popping further symbols from a pushdown having a hole at the bottom deepens the current hole furthermore. The hole can only be filled up by pushing symbols previously popped. We study the impact of the new behavior of DIDPDAs on their power and compare their capacities with the capacities of ordinary IDPDAs and tinput-driven pushdown automata which are basically IDPDAs whose input may be preprocessed by length-preserving finite state transducers. It turns out that the capabilities are incomparable. We address the determinization of DIDPDAs and their descriptional complexity, closure properties, and decidability questions.

We determine the descriptional complexity (smallest number of states, up to constant factors) of recognizing languages {1^n} and {1^{t n} : t = 0, 1, 2, ...} with state-based finite machines of various kinds. This task is understood as counting to n and modulo n, respectively, and was previously studied for classes of finite-state automata by Kupferman, Ta-Shma, and Vardi (2001). We show that for Turing machines it requires log(n)/log(log(n)) states in the worst case, and individual values are related to Kolmogorov complexity of the binary encoding of n. For deterministic pushdown and counter automata, the complexity is log(n) and sqrt(n), respectively; for alternating counter automata, we show an upper bound of log(n). For visibly pushdown automata, i.e., if the stack movements are determined by input symbols, we consider languages {a^n b^n} and {a^{t n} b^{t n} : n t = 0, 1, 2, ...} and determine their complexity, of sqrt(n) and min(n_1 + n_2), respectively, with minimum over all factorizations n = n_1 n_2.

Input-driven multi-counter automata

Square time is optimal for simulation of one pushdown store or one queue by an oblivious one-head tape unit

Petri Net Languages and Infinite Subsets of [formula omitted

On the computational power of random strings

We present a formal model for stratificational linguistics, and examine its properties such as generative power, complexity of recognition and descriptional complexity. By relating stratificational grammars to control grammars and Szilard languages, we obtain a table of language families generated by stratificational grammars under several restrictions of linguistic interest. In the process, we show that context-sensitive control grammars with leftmost derivations are no more powerful than context-free ones, and, using this, resolve two open problems of Ginsburg and Spanier. Throughout the paper, formal results are interpreted in terms of their significance for linguistic theory and practice.

We introduce the concept of one-time nondeterminism as a new kind of limited nondeterminism for finite state machines and pushdown automata. Roughly speaking, one-time nondeterminism means that at the outset the computation is nondeterministic, but whenever it performs a guess, this guess is fixed for the rest of the computation. We characterize the computational power of one-time nondeterministic finite automata (OTNFAs) and one-time nondeterministic pushdown devices. Moreover, we study the descriptional complexity of these machines. For instance, we show that for an [Formula: see text]-state OTNFA with a sole nondeterministic state, that is nondeterministic for only one input symbol, [Formula: see text] states are sufficient and necessary in the worst case for an equivalent deterministic finite automaton. In case of pushdown automata, the conversion of a nondeterministic to a one-time nondeterministic as well as the conversion of a one-time nondeterministic to a deterministic one turn out to be non-recursive, that is, the trade-offs in size cannot be bounded by any recursive function.

A deterministic pushdown automaton (dpda) is described as finite-turn if there is a bound on the number of times the direction of the stack movement can change in the set of all derivations from the starting configuration. The purpose of this paper is to show that there exists a procedure for deciding whether two such finite-turn machines recognize the same language. By virtue of a direct correspondence between a restricted class of one-turn dpda and deterministic two-tape acceptors (Valiant (1973)), our proof also provides a solution to the equivalence problem for the latter, alternative to that of Bird (1973). Since some of the ideas we introduce are not related exclusively to the finite-turn property, or even pushdown machines, it is hoped that our methods can be adapted for constructing equivalence tests for other classes of deterministic automata.Our main technique can be regarded as a generalization in several directions of one introduced by Rosenkrantz and Stearns (1970). They consider a class of pushdown automata for which a natural valuation can be placed on each stack segment, and deduce that for any input word, two equivalent machines in that class must have closely related stack movements. They show how, under such circumstances, for any two machines a single pushdown automaton can be constructed to simulate them both, and used to decide their equivalence. What we shall show is that even for a class with no such stack valuation known, and in which two equivalent machines can have totally dissimilar stack movements, pushdown automata, now nondeterministic, can be found to perform the required simulations.

On some decision questions concerning pushdown machines

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.

Semilinear sets are one of the most important concepts in theoretical computer science, as illustrated by the fact that the set of nonnegative integer solutions to any system of Diophantine equations is semilinear. Parikh's theorem enables us to represent any semilinear set as a pushdown automaton (PDA). We summarize recent results on the descriptional complexity of conversions among different representations of a semilinear set: as a vector set (conventional), a finite automaton (FA), a PDA, etc.. We also discuss semilinearity-preserving operations like union, intersection, and complement. We use Parikh's theorem to enlarge the class of finite-state machines that can represent semilinear sets. In particular, we give a simpler proof of a known result that characterizes semilinear sets in terms of machines with reversal-bounded counters. We then investigate the power of such a machine with only one counter in the context of a long-standing conjecture about repetition on words.

The main thesis of this chapter is that a dynamical viewpoint allows us to better understand some important foundational issues of computation theory. Effective procedures are traditionally studied from two different but complementary points of view. The first approach is concerned with individuating those numeric functions that are effectively calculable. This approach reached its systematization with the theory of the recursive functions (Gödel, Church Kleene).This theory is not directly concerned with computing devices or computations. Rather, the effective calculability of a recursive function is guaranteed by the algorithmic nature of its definition. In contrast, the second approach focuses on a family of abstract mechanisms, which are then typically used to compute or recognize numeric functions, sets of numbers, or numbers. These devices can be divided into two broad categories: automata or machines (Turing and Post), and systems of rules for symbol manipulation (Post). The mechanisms that have been studied include: a. Automata or Machines 1. gate-nets and McCulloch-Pitts nets 2. finite automata (Mealy and Moore machines) 3. push-down automata 4. stack automata 5. Turing machines 6. register machines 7. wang machines 8. cellular automata b. Systems of Rules 9. monogenic production systems in general 10. monogenic Post canonical systems 11. monogenic Post normal systems 12. tag systems. I call any device studied by computation theory a computational system. Computation theory is traditionally interested in studying the relations between each type of computational system and the others, and in establishing what class of numeric functions each type can compute. Accordingly one proves two kinds of theorem: (1) that systems of a given type emulate systems of another type (examples: Turing machines emulate register machines and cellular automata; cellular automata emulate Turing machines, etc.), and (2) that a certain type of system is complete relative to the class of the (partial) recursive functions or, in other words, that this type of system can compute all and only the (partial) recursive functions (examples of complete systems: Turing machines, register machines, cellular automata, tag systems, etc.). All different types of computational systems have much in common. Nevertheless, it is not at all clear exactly which properties these mechanisms share.

The idea of a finite automaton walking in a labyrinth goes back to Shannon /I/. In the last years this problem has been further investigated by D~pp /2/, M~ller /3/ and Budach /4/. DSpp posed the following question: Does there exist a finite initial automaton that finds a way out of every finite plane open labyrinth from any initial position and finally moves arbitrarily far away ? MGller and Budach gave negative answers to this question, where Budach used DSpp's original definitions, while MGller treated a graph-theoretical variant of D~pp's formulation. It is the aim of this note to show how some quite natural extensions of the computational power of the automaton (called mouse by Shannon) will affect the answer to this question. We allow the mouse to be either a finite automaton, a pushdown transducer, a linear bounded automaton, or a Turing machine. In the first to cases the answer to DSpp's question is negative, while an algorithmic solution for linear bounded automata exists, such that every open labyrinth may be mastered by such mice independent from the starting point. The negative answer in the case of pushdown transducers depends on the fact that there are labyrinths where pushdown transducers have the same computational power as finite automata (which may not master these labyrinths).

We investigate the efficiency of simulations of storages by several counters. A simulation of a pushdown store is described which is optimal in the sense that reducing the number of counters of a simulator leads to an increase in time complexity. The lower bound also establishes a tight counter hierarchy in exponential time. Then we turn to simulations of a set of counters by a different number of counters. We improve and generalize a known simulation in polynomial time. Greibach has shown that adding s + 1 counters increases the power of machines working in time ns. Using a new family of languages we show here a tight hierarchy result for machines with the same polynomial time-bound. We also prove hierarchies for machines with a fixed number of counters and with growing polynomial time-bounds. For machines with one counter and an additional "store zero" instruction we establish the equivalence of real-time and linear time. If at least two counters are available, the classes of languages accepted in real-time and linear time can be separated.