scholarly journals Quantum Pushdown Automata with Garbage Tape

2018 ◽  
Vol 29 (03) ◽  
pp. 425-446 ◽  
Author(s):  
Masaki Nakanishi
Keyword(s):  
Impossibility Result ◽  
Computational Power ◽  
Pushdown Automaton ◽  
Proposed Model ◽  
Quantum Models ◽  
Pushdown Automata

Several kinds of quantum pushdown automata models have been proposed, and their computational power has been investigated intensively. However, for some quantum pushdown automaton models, it is unknown whether quantum models are at least as powerful as their classical counterparts or not. This is due to the reversibility restriction. In this paper, we introduce a new quantum pushdown automaton model that has a garbage tape. This model can overcome the reversibility restriction by exploiting the garbage tape to store popped symbols. We show that the proposed model can simulate any quantum pushdown automaton with classical stack as well as any probabilistic pushdown automaton. We also show that our model can solve a certain promise problem exactly while deterministic pushdown automata cannot. These results imply that our model is strictly more powerful than its classical counterparts in the setting of exact, one-sided error and non-deterministic computation. Showing impossibility for a promise problem is a difficult task in general. However, by analyzing the behavior of a deterministic pushdown automaton carefully, we obtained the impossibility result. This is one of the main contributions of the paper.

scholarly journals Subtree matching by pushdown automata

2010 ◽  
Vol 7 (2) ◽  
pp. 331-357 ◽  
Author(s):  
Tomás Flouri ◽  
Jan Janousek ◽  
Bořivoj Melichar
Keyword(s):  
Programming Languages ◽  
Theorem Proving ◽  
Systematic Approach ◽  
Finite Automata ◽  
Term Rewriting ◽  
Mechanical Theorem Proving ◽  
Pushdown Automaton ◽  
String Pattern ◽  
Pushdown Automata ◽  
Mechanical Theorem

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.

CLOSURE PROPERTY OF SPACE-BOUNDED TWO-DIMENSIONAL ALTERNATING TURING MACHINES, PUSHDOWN AUTOMATA, AND COUNTER AUTOMATA

2001 ◽  
Vol 15 (07) ◽  
pp. 1143-1165 ◽  
Author(s):  
TOKIO OKAZAKI ◽  
KATSUSHI INOUE ◽  
AKIRA ITO ◽  
YUE WANG
Keyword(s):  
Turing Machine ◽  
Nondecreasing Function ◽  
Closure Property ◽  
Two Dimensional ◽  
Turing Machines ◽  
Pushdown Automaton ◽  
Alternating Turing Machines ◽  
Positive Integers ◽  
Pushdown Automata

This paper investigates closure property of the classes of sets accepted by space-bounded two-dimensional alternating Turing machines (2-atm's) and space-bounded two-dimensional alternating pushdown automata (2-apda's), and space-bounded two-dimensional alternating counter automata (2-aca's). Let L(m, n): N2 → N (N denotes the set of all positive integers) be a function with two variables m (= the number of rows of input tapes) and n (= the number of columns of input tapes). We show that (i) for any function f(m) = o( log m) (resp. f(m) = o( log m/ log log m)) and any monotonic nondecreasing function g(n) space-constructible by a two-dimensional Turing machine (2-Tm) (resp. two-dimensional pushdown automaton (2-pda)), the class of sets accepted by L(m,n) space-bounded 2-atm's (2-apda's) is not closed under row catenation, row + or projection, and (ii) for any function f(m) = o(m/ log ) (resp. for any function f(m) such that log f(m) = o( log m)) and any monotonic nondecreasing function g(n) space-constructible by a two-dimensional counter automaton (2-ca), the class of sets accepted by L(m, n) space-bounded 2-aca's is not closed under row catenation, row + or projection, where L(m, n) = f(m) + g(n) (resp. L(m, n) = f(m) × g(n)).

EFFICIENT DETECTORS AND CONSTRUCTORS FOR SIMPLE LANGUAGES

1991 ◽  
Vol 02 (03) ◽  
pp. 183-205 ◽  
Author(s):  
Dung T. Huynh
Keyword(s):  
Finite Automata ◽  
Boolean Circuits ◽  
Turing Machines ◽  
Constant Depth ◽  
Pushdown Automaton ◽  
Polynomial Size ◽  
Regular Sets ◽  
Context Free ◽  
Pushdown Automata ◽  
Nondeterministic Logspace

In this paper, we investigate the complexity of computing the detector, constructor and lexicographic constructor functions for a given language. The following classes of languages will be considered: (1) context-free languages, (2) regular sets, (3) languages accepted by one-way nondeterministic auxiliary pushdown automata, (4) languages accepted by one-way nondeterministic logspace-bounded Turing machines, (5) two-way deterministic pushdown automaton languages, (6) languages accepted by uniform families of constant-depth polynomial-size Boolean circuits, and (7) languages accepted by multihead finite automata. We show that for the classes (1)–(4), efficient detectors, constructors and lexicographic constructors exist, whereas for (5)– (7) polynomial-time computable detectors, constructors and lexicographic constructors exist iff there are no sparse sets in NP−P (or equivalently, E=NE). Our results provide sharp boundaries between classes of languages which have efficient detectors, constructors and classes of languages for which efficient detectors and constructors do not appear to exist.

scholarly journals DETERMINISTIC PUSHDOWN AUTOMATA AND UNARY LANGUAGES

2009 ◽  
Vol 20 (04) ◽  
pp. 629-645 ◽  
Author(s):  
GIOVANNI PIGHIZZINI
Keyword(s):  
Finite Automata ◽  
Point Of View ◽  
Deterministic Finite Automaton ◽  
Pushdown Automaton ◽  
Nondeterministic Automaton ◽  
Letter Alphabet ◽  
Finite State ◽  
Unary Languages ◽  
Context Free ◽  
Pushdown Automata

The simulation of deterministic pushdown automata defined over a one-letter alphabet by finite state automata is investigated from a descriptional complexity point of view. We show that each unary deterministic pushdown automaton of size s can be simulated by a deterministic finite automaton with a number of states that is exponential in s. We prove that this simulation is tight. Furthermore, its cost cannot be reduced even if it is performed by a two-way nondeterministic automaton. We also prove that there are unary languages for which deterministic pushdown automata cannot be exponentially more succinct than finite automata. In order to state this result, we investigate the conversion of deterministic pushdown automata into context-free grammars. We prove that in the unary case the number of variables in the resulting grammar is strictly smaller than the number of variables needed in the case of nonunary alphabets.

scholarly journals On the computational power of pushdown automata

1970 ◽  
Vol 4 (2) ◽  
pp. 129-136 ◽  
Author(s):  
A.V. Aho ◽  
J.D. Ullman ◽  
J.E. Hopcroft
Keyword(s):  
Computational Power ◽  
Pushdown Automata

PARALLEL COMMUNICATING PUSHDOWN AUTOMATA SYSTEMS

2000 ◽  
Vol 11 (04) ◽  
pp. 631-650 ◽  
Author(s):  
ERZSÉBET CSUHAJ-VARJÚ ◽  
CARLOS MARTÍN-VIDE ◽  
VICTOR MITRANA ◽  
GYÖRGY VASZIL
Keyword(s):  
System Theory ◽  
Communication Strategy ◽  
Computational Power ◽  
Open Problems ◽  
Number Of Components ◽  
Grammar System ◽  
Bounded Number ◽  
Recursively Enumerable ◽  
Pushdown Automata ◽  
Recursively Enumerable Languages

We consider automata systems consisting of several pushdown automata working in parallel and communicating the contents of their stacks by request, using a communication strategy borrowed from grammar system theory. We investigate the computational power of these mechanisms. We prove that non-centralized parallel communicating pushdown automata systems with a bounded number of components, where each automaton is allowed to issue a query, are able to recognize all recursively enumerable languages. We also present homomorphical characterizations of the class of recursively enumerable languages for the centralized variants, where only a distinguished automaton issues queries. Moreover, we show that these centralized variants are at least as powerful as one-way multihead pushdown automata. Finally, some open problems and further directions of research are discussed.

Boosting Reversible Pushdown and Queue Machines by Preprocessing

2020 ◽  
pp. 1-29
Author(s):  
Holger Bock Axelsen ◽  
Martin Kutrib ◽  
Andreas Malcher ◽  
Matthias Wendlandt
Keyword(s):  
Real Time ◽  
Finite Automata ◽  
Point Of View ◽  
Regular Languages ◽  
Theoretical Point ◽  
Computational Power ◽  
Finite State ◽  
Finite State Transducer ◽  
Context Free ◽  
Pushdown Automata

It is well known that reversible finite automata do not accept all regular languages, that reversible pushdown automata do not accept all deterministic context-free languages, and that reversible queue automata are less powerful than deterministic real-time queue automata. It is of significant interest from both a practical and theoretical point of view to close these gaps. We here extend these reversible models by a preprocessing unit which is basically a reversible injective and length-preserving finite state transducer. It turns out that preprocessing the input using such weak devices increases the computational power of reversible deterministic finite automata to the acceptance of all regular languages, whereas for reversible pushdown automata the accepted family of languages lies strictly in between the reversible deterministic context-free languages and the real-time deterministic context-free languages. For reversible queue automata the preprocessing of the input leads to machines that are stronger than real-time reversible queue automata, but less powerful than real-time deterministic (irreversible) queue automata. Moreover, it is shown that the computational power of all three types of machines is not changed by allowing the preprocessing finite state transducer to work irreversibly. Finally, we examine the closure properties of the family of languages accepted by such machines.

scholarly journals Indexing ordered trees for (nonlinear) tree pattern matching by pushdown automata

2012 ◽  
Vol 9 (3) ◽  
pp. 1125-1153
Author(s):  
J. Travnícek ◽  
J. Janousek ◽  
B. Melichar
Keyword(s):  
Pattern Matching ◽  
Data Structures ◽  
Input Pattern ◽  
Pushdown Automaton ◽  
Ordered Trees ◽  
Tree Pattern ◽  
Tree Patterns ◽  
Tree Pattern Matching ◽  
Ordered Tree ◽  
Pushdown Automata

Trees are one of the fundamental data structures used in Computer Science. We present a new kind of acyclic pushdown automata, the tree pattern pushdown automaton and the nonlinear tree pattern pushdown automaton, constructed for an ordered tree. These automata accept all tree patterns and nonlinear tree patterns, respectively, which match the tree and represent a full index of the tree for such patterns. Given a tree with n nodes, the numbers of these distinct tree patterns and nonlinear tree patterns can be at most 2n?1 +n and at most (2+v)n?1+2, respectively, where v is the maximal number of nonlinear variables allowed in nonlinear tree patterns. The total sizes of nondeterministic versions of the two pushdown automata are O(n) and O(n2), respectively. We discuss the time complexities and show timings of our implementations using the bit-parallelism technique. The timings show that for a given tree the running time is linear to the size of the input pattern.

scholarly journals A Note on Linear Time Simulation of Deterministic Two-Way Pushdown Automata

1977 ◽  
Vol 6 (75) ◽  
Author(s):  
Neil D. Jones
Keyword(s):  
Pattern Matching ◽  
Data Structures ◽  
Linear Time ◽  
Random Access ◽  
Simulation Algorithm ◽  
Pushdown Automaton ◽  
Matching Problems ◽  
Time Result ◽  
Time Simulation ◽  
Pushdown Automata

<p>Cook has shown that any deterministic two-way pushdown automaton could be simulated by a uniform-cost random access machine in time O(n) for inputs of length n. The result was of interest because such a machine is a natural model for a variety of backtracking algorithms, particularly as used in pattern matching problems. The linear time result was surprising because of the fact that such machines may run as many as 2n steps before halting; similar problems with 'combinatorial explosions' are well known to occur in applications of backtracking. Cook's result inspired the development of a number of efficient pattern matching algorithms.</p><p>However, it is impractical to use Cook's algorithm directly to do pattern matching, since it involves a large constant time factor and much storage. The purpose of this note is to present an alternate, simpler simulation algorithm which involves consideration only of the configurations actually reached by the automaton. It can be expected to run faster and use less storage (depending on the data structures used), thus bringing Cook's result a step closer to practical utility.</p>

Sign in / Sign up

Export Citation Format

Share Document