Pushdown Automata Research Articles

Language Acceptors with a Pushdown: Characterizations and Complexity

We study one-way nondeterministic pushdown automata ([Formula: see text]), optionally with reversal-bounded counters. Finite-turn pushdown automata are pushdown automata with a bound on the number of switches between pushing and popping. We give new characterizations for finite-turn pushdown automata, and for finite-turn pushdown automata augmented with reversal-bounded counters. The first is in terms of multi-tape nondeterministic finite automata ([Formula: see text]), and the second is in terms of multi-tape [Formula: see text] with reversal-bounded counters. We then use the characterizations to determine the complexity of the languages defined by these automata. In particular, we show that languages accepted by finite-turn [Formula: see text] augmented with reversal-bounded counters are in [Formula: see text]. For the non-finite-turn case, the languages are in [Formula: see text] and in [Formula: see text]. We also look at the space complexity of languages accepted by two-way machines. In particular, we show that every language accepted by a two-way [Formula: see text] with reversal-bounded counters that makes a polynomial (resp., exponential) number of input head reversals is in [Formula: see text] (resp., [Formula: see text]). This remains true if the pushdown can flip its contents a bounded number of times.

Deterministic pushdown automata can compress some normal sequences

In this paper, we give a deterministic pushdown transducer and a normal sequence of digits compressed by it. This solves positively a question left open in a previous paper by V. Becher, P. A. Heiber and the first author.

Hidden Abstract Stack Markov Models with Learning Process

We present hidden abstract stack Markov models (HASMMs) with their learning process. The HASMMs we offer carry the more expressive nature of probabilistic context-free grammars (PCFGs) while allowing faster parameter fitting of hidden Markov models (HMMs). Both HMMs and PCFGs are widely utilized structured models, offering an effective formalism capable of describing diverse phenomena. PCFGs are better accommodated than HMMs such as for expressing natural language processing; however, HMMs outperform PCFGs for parameter fitting. We extend HMMs towards PCFGs for such applications, by associating each state of an HMM with an abstract stack, which can be thought of as the single-stack alphabet of pushdown automata (PDA). As a result, we leverage the expressive capabilities of PCFGs for such applications while mitigating the cubic complexity of parameter learning in the observation sequence length of PCFGs by adopting the bilinear complexity of HMMs.

Automata concepts over game design process

Discrete states linked together by events can describe a series of classical video game scenarios. Therefore, the formal concept of automata seems appropriate for describing such games. However, as simple finite automata need to keep track of past events, they are less appropriate for complex designs. By contrast, push-down automata featuring a stack present better capabilities in this context. This paper discusses an enhanced version of the classic PAC-MAN game with push-down automata. The modular design of this game allows the extraction of discrete states, and its minimalist concept enables various approaches and new versions without sacrificing its original essence. Using push-down automata expanded the game with new features, allowing an enhanced game experience. The automaton controls all aspects of the game, ensuring a consistent gameplay. The presented project demonstrates the capabilities of push-down automata in the gaming industry and their potential in future game development projects.

Undecidability of the universal support problem for weighted automata over zero-sum-free commutative semirings

We show that there is an effectively given zero-sum-free commutative semiring S, contained as the subsemiring of nonnegative elements in an effectively given commutative ordered ring, for which there are no procedures deciding, given a weighted finite automaton over S, whether its support is the language of all words or whether its support is infinite. In particular, by a result of D. Kirsten (2011), since S is zero-sum-free and commutative, the support is recognizable by a classical finite automaton, but such an automaton or even just a pushdown automaton for its support cannot be constructed effectively.

A Bit of Nondeterminism Makes Pushdown Automata Expressive and Succinct

We study the expressiveness and succinctness of history-deterministic pushdown automata (HD-PDA) over finite words, that is, pushdown automata whose nondeterminism can be resolved based on the run constructed so far, but independently of the remainder of the input word. These are also known as good-for-games pushdown automata. We prove that HD-PDA recognise more languages than deterministic PDA (DPDA) but not all context-free languages (CFL). This class is orthogonal to unambiguous CFL. We further show that HD-PDA can be exponentially more succinct than DPDA, while PDA can be double-exponentially more succinct than HD-PDA. We also study HDness in visibly pushdown automata (VPA), which enjoy better closure properties than PDA, and for which we show that deciding HDness is ExpTime-complete. HD-VPA can be exponentially more succinct than deterministic VPA, while VPA can be exponentially more succinct than HD-VPA. Both of these lower bounds are tight. We then compare HD-PDA with PDA for which composition with games is well-behaved, i.e. good-for-games automata. We show that these two notions coincide, but only if we consider potentially infinitely branching games. Finally, we study the complexity of resolving nondeterminism in HD-PDA. Every HDPDA has a positional resolver, a function that resolves nondeterminism and that is only dependant on the current configuration. Pushdown transducers are sufficient to implement the resolvers of HD-VPA, but not those of HD-PDA. HD-PDA with finite-state resolvers are determinisable.

A provably stable neural network Turing Machine with finite precision and time

We introduce a neural stack architecture with a differentiable parameterized stack operator approximating stack push and pop operations. We prove the stability of this stack architecture for arbitrarily many stack operations, showing that the state of the neural stack still closely resembles the state of a discrete stack. Using the neural stack with a recurrent neural network, we devise a neural network Pushdown Automaton (nnPDA). A new theoretical bound shows that an nnPDA can recognize any PDA using only finite precision state neurons in finite time. By using two neural stacks to construct a neural tape together with a recurrent neural network, we define a neural network Turing Machine (nnTM). Just like the neural stack, we show these architectures are also stable. Furthermore, we show the nnTM is Turing complete. It requires finite precision state neurons with an arbitrary number of stack neurons to recognize any TM in finite time, thus providing a new and much stronger computational upper bound for neural networks that are Turing complete.

Token Games and History-Deterministic Quantitative-Automata

A nondeterministic automaton is history-deterministic if its nondeterminism can be resolved by only considering the prefix of the word read so far. Due to their good compositional properties, history-deterministic automata are useful in solving games and synthesis problems. Deciding whether a given nondeterministic automaton is history-deterministic (the HDness problem) is generally a difficult task, which can involve an exponential procedure, or even be undecidable, as is the case for example with pushdown automata. Token games provide a PTime solution to the HDness problem of B\"uchi and coB\"uchi automata, and it is conjectured that 2-token games characterise HDness for all $\omega$-regular automata. We extend token games to the quantitative setting and analyse their potential to help deciding HDness of quantitative automata. In particular, we show that 1-token games characterise HDness for all quantitative (and Boolean) automata on finite words, as well as discounted-sum (DSum), Inf and Reachability automata on infinite words, and that 2-token games characterise HDness of LimInf and LimSup automata, as well as Sup automata on infinite words. Using these characterisations, we provide solutions to the HDness problem of Safety, Reachability, Inf and Sup automata on finite and infinite words in PTime, of DSum automata on finite and infinite words in NP$\cap$co-NP, of LimSup automata in quasipolynomial time, and of LimInf automata in exponential time, where the latter two are only polynomial for automata with a logarithmic number of weights.

Molecular system for an exponentially fast growing programmable synthetic polymer

In this paper, we demonstrate a molecular system for the first active self-assembly linear DNA polymer that exhibits programmable molecular exponential growth in real time, also the first to implement “internal” parallel insertion that does not rely on adding successive layers to “external” edges for growth. Approaches like this can produce enhanced exponential growth behavior that is less limited by volume and external surface interference, for an early step toward efficiently building two and three dimensional shapes in logarithmic time. We experimentally demonstrate the division of these polymers via the addition of a single DNA complex that competes with the insertion mechanism and results in the exponential growth of a population of polymers per unit time. In the supplementary material, we note that an “extension” beyond conventional Turing machine theory is needed to theoretically analyze exponential growth itself in programmable physical systems. Sequential physical Turing Machines that run a roughly constant number of Turing steps per unit time cannot achieve an exponential growth of structure per time. In contrast, the “active” self-assembly model in this paper, computationally equivalent to a Push-Down Automaton, is exponentially fast when implemented in molecules, but is taxonomically less powerful than a Turing machine. In this sense, a physical Push-Down Automaton can be more powerful than a sequential physical Turing Machine, even though the Turing Machine can compute any computable function. A need for an “extended” computational/physical theory arises, described in the supplementary material section S1.

Syntax checking either way

We consider parsers of deterministic context-free languages and study the sizes of their syntax checking components. More precisely, we allow the input processing from left to right or, alternatively, from right to left, whatever is best for the given language. As practical examples, we establish an infinite sequence of deterministic context-free languages Lk, for k≥1, such that there is an exponential size trade-off between a deterministic pushdown automaton that reads its input from right to left and another one that reads its input from left to right. Concerning the constructibility of such a parser out of a given deterministic context-free language, it is shown that it is undecidable whether the reversal of a given deterministic context-free language is again deterministic context free. Related to decidability questions, it turns out that the size trade-offs between deterministic pushdown automata that represent the reversals of their accepted languages and deterministic pushdown automata that represent their accepted languages are non-recursive. That is, one can choose an arbitrarily large recursive function ϱ, but the gain in economy of description eventually exceeds ϱ when changing from the former system to the latter. Furthermore, we study the expressive capacity of the family of languages whose reversals are deterministic context free. Finally, we turn to the family of deterministic context-free languages whose reversals are also deterministic context free and collect several of their closure properties.

A Computational Analysis of Arabic Noun Morphology

This project looks at Arabic word generation from a computational angle. It focuses on the computational production and analysis of morphological Arabic nouns. The work begins with a stem-based descriptive analysis of Arabic noun morphology that fulfills both the computational formalization and the linguistic description. There includes a thorough discussion of both inflectional and derivational systems. The spelling of Arabic nouns is also covered, as well as morphotactics and morphophonemics. The work then offers a computer implementation of Arabic nouns built on a rule-based computational morphological methodology. The overall system is constructed using the NooJ toolkit, which supports both pushdown automata and finite-state automata (FSA) (PDA). Three elements make up the morphological generation and analysis system: a lexicon, morphotactics, and rules. The lexicon component catalogs lexical elements (indivisible words and affixes), the morphotactics component specifies ordering restrictions for morphemes, and the rules component converts lexical representations into surface representations and vice versa. Other rules, such as orthographic, morphophonemic, and morphological rules, are also stored as two-level rules. The core editable lexicon of lemmas used as input by the system is drawn from three sources: the Buckwalter Arabic morphological analyzer lexicon, the Arramooz machine-readable dictionary, and the Alghani Azzahir dictionary. A complete annotated vocabulary of inflected noun forms (combined into a single type of finite-state transducers (FSTs)) is the system's output. The lexicon that was developed is then put to use in morphological analysis. The study then offers the system's evaluation. Accuracy, precision, and recall are three widely used metrics to assess the system's performance. Two empirical experiments will be conducted as part of the evaluation task. The system analyzing Arabic words that have been discredited morphologically is evaluated in the first experiment. Accuracy, precision, and recall for the system when employing discredited Arabic words are (90.4%), (98.3%), and (88.9%), respectively. The technique is tested in a second experiment using undiacritical words. The achieved outcomes of this experiment were (94.7%) accuracy, (96.7%) precision, and (91.6% ) recall, respectively. Additionally, the measurement average for the two tests has been determined. The average performance values are respectively (92.55%), (97.5%), and (90.25) percent in terms of recall, precision, and accuracy. Overall, the results are encouraging and demonstrate the system's propensity for dealing with both diacritically and undiacritically written Arabic texts. This system can analyze Arabic text corpora in-depth and tag nouns according to their morphological characteristics. It breaks the word under analysis into three pieces (the stem, proclitics/prefixes, and suffixes/enclitics) and assigns each one a specific morphological feature tag or possibly many tags if the portion in question has numerous clitics or affixes. Many applications of natural language processing, including parsing, lemmatization, stemming, part-of-speech (POS) tagging, corpus annotations, word sense disambiguation, machine translation, information retrieval, text generation, spelling checkers, etc., depend on computational morphology. It is made up of morphological generation and analysis paradigms. According to a set of features, morphological generation attempts to construct every feasible derived and inflected form of a given lemma. On the other hand, morphological analysis is the process of dissecting a word into its component morphemes and giving each morpheme linguistic tags or qualities.

Automated Grading of Automata with ACL2s

Almost all Computer Science programs require students to take a course on the Theory of Computation (ToC) which covers various models of computation such as finite automata, push-down automata and Turing machines. ToC courses tend to give assignments that require paper-and-pencil solutions. Grading such assignments takes time, so students typically receive feedback for their solutions more than a week after they complete them. We present the Automatic Automata Checker (A2C), an open source library that enables one to construct executable automata using definitions that mimic those found in standard textbooks. Such constructions are easy to reason about using semantic equivalence checks, properties and test cases. Instructors can conveniently specify solutions in the form of their own constructions. A2C can check for semantic equivalence between student and instructor solutions and can immediately generate actionable feedback, which helps students better understand the material. A2C can be downloaded and used locally by students as well as integrated into Learning Management Systems (LMS) like Gradescope to automatically grade student submissions and generate feedback. A2C is based on the ACL2s interactive theorem prover, which provides advanced methods for stating, proving and disproving properties. Since feedback is automatic, A2C can be deployed at scale and integrated into massively open online courses.

Good-for-games $\omega$-Pushdown Automata

We introduce good-for-games $\omega$-pushdown automata ($\omega$-GFG-PDA). These are automata whose nondeterminism can be resolved based on the input processed so far. Good-for-gameness enables automata to be composed with games, trees, and other automata, applications which otherwise require deterministic automata. Our main results are that $\omega$-GFG-PDA are more expressive than deterministic $\omega$- pushdown automata and that solving infinite games with winning conditions specified by $\omega$-GFG-PDA is EXPTIME-complete. Thus, we have identified a new class of $\omega$-contextfree winning conditions for which solving games is decidable. It follows that the universality problem for $\omega$-GFG-PDA is in EXPTIME as well. Moreover, we study closure properties of the class of languages recognized by $\omega$-GFG- PDA and decidability of good-for-gameness of $\omega$-pushdown automata and languages. Finally, we compare $\omega$-GFG-PDA to $\omega$-visibly PDA, study the resources necessary to resolve the nondeterminism in $\omega$-GFG-PDA, and prove that the parity index hierarchy for $\omega$-GFG-PDA is infinite. This is a corrected version of the paper arXiv:2001.04392v6 published originally on January 7, 2022.

Context-Bounded Verification of Context-Free Specifications

A fundamental problem in refinement verification is to check that the language of behaviors of an implementation is included in the language of the specification. We consider the refinement verification problem where the implementation is a multithreaded shared memory system modeled as a multistack pushdown automaton and the specification is an input-deterministic multistack pushdown language. Our main result shows that the context-bounded refinement problem, where we ask that all behaviors generated in runs of bounded number of context switches belong to a specification given by a Dyck language, is decidable and coNP-complete. The more general case of input-deterministic languages follows, with the same complexity. Context-bounding is essential since emptiness for multipushdown automata is already undecidable, and so is the refinement verification problem for the subclass of regular specifications. Input-deterministic languages capture many non-regular specifications of practical interest and our result opens the way for algorithmic analysis of these properties. The context-bounded refinement problem is coNP-hard already with deterministic regular specifications; our result demonstrates that the problem is not harder despite the stronger class of specifications. Our proof introduces several general techniques for formal languages and counter programs and shows that the search for counterexamples can be reduced in non-deterministic polynomial time to the satisfiability problem for existential Presburger arithmetic. These techniques are essential to ensure the coNP upper bound: existing techniques for regular specifications are not powerful enough for decidability, while simple reductions lead to problems that are either undecidable or have high complexities. As a special case, our decidability result gives an algorithmic verification technique to reason about reference counting and re-entrant locking in multithreaded programs.

Use of FOSS for Teaching the Parser Types to Improve Problem Solving Ability A Case Study on Analysis of Gender based Discrimination in Education

Compiler Design is one of the core courses of Computer Science and Engineering. Syntax Analyzer or Parser is important phase in designing the compiler. So while designing this phase of the compiler, students must have thorough knowledge about the types of parser such as LL(1), SLR, Canonical LR and LALR. In the parser phase, the parsing table is built for given Context Free Grammar (CFG). While implementing this parsing phase in laboratory session, two Free Open Source Software (FOSS) - JFLAP and Parsing Emulator, are considered to explain the types of parser and building the parsing table for the CFG using these parser types. JFLAP is software for experimenting with formal languages topics including nondeterministic finite automata, nondeterministic pushdown automata, multi-tape Turing machines, several types of grammars, parsing, and Lsystems. So this tool is considered for parsing phase of Compiler. JFLAP tool is used to explain the steps to be followed to solve the given problem using the parsing technique. Parsing simulator is a software which implements the parsing table for the Context Free Grammars in tool. This simulator is used to generate parsing table (LL1, SLR, LR, and LALR). Parsing Emulator tool is used for practicing the problem statement given in the tool. In current study, use of FOSS such as JFLAP and Parsing Emulator is considered for teaching parser types to improve problem solving ability. The Learning Objectives (LOs) of this study are: To build the parsing table for given CFG using LL(1) and SLR parser (LO1) and to parse the given string using LL(1) and SLR parser (LO2). The research questions for this study are – whether the use of FOSS improves the problem solving ability of the students? and whether gender bias is there in education? Two groups post-test method is considered to check the effectiveness of this use of FOSS in learning the parser types. Also the students’ perception about this method is also considered. The result shows that the students’ problem solving ability of experimental group is improved as compared to the control group irrespective of gender. Keywords- FOSS (Free Open Source Software) JFLAP, Parsing Emulator, Bloom’s Taxonomy, Post-test, t-Test.

Reversible Top-Down Syntax Analysis

Top-down syntax analysis can be based on [Formula: see text] grammars. The canonical acceptors for [Formula: see text] languages are deterministic stateless pushdown automata with input lookahead of size [Formula: see text]. We investigate the computational capacity of reversible computations of such automata. A pushdown automaton with lookahead [Formula: see text] is said to be reversible if its predecessor configurations can uniquely be computed by a pushdown automaton with backward input lookahead (lookback) of size [Formula: see text]. It is shown that we cannot trade a lookahead for states or vice versa. The impact of having states or a lookahead depends on the language. While reversible pushdown automata with states accept all regular languages, we are going to prove that there are regular languages that cannot be accepted reversibly without states, even in case of an arbitrarily large lookahead. This completes the comparison of reversible with ordinary pushdown automata in our setting. Moreover, it turns out that there are problems which can be solved by reversible deterministic stateless pushdown automata with lookahead of size [Formula: see text], but not by any reversible deterministic stateless pushdown automaton with lookahead of size [Formula: see text]. So, an infinite and tight hierarchy of language families dependent on the size of the lookahead is shown. Finally, we prove that the language families accepted by reversible deterministic stateless pushdown automata with lookahead of size [Formula: see text] are not closed under standard operations. For example, we show that the families are anti-AFLs which are not closed under intersection.

Deciding path size of nondeterministic (and input-driven) pushdown automata

The degree of ambiguity (respectively, the path size) of a nondeterministic automaton, on a given input, measures the number of accepting computations (respectively, the number of all computations). It is known that deciding the finiteness of the degree of ambiguity of a nondeterministic pushdown automaton is undecidable. Also, it is undecidable for a given k≥3 to decide whether the path size of a nondeterministic pushdown automaton is bounded by k.As the main result, we show that deciding the finiteness of the path size of a nondeterministic pushdown automaton can be done in polynomial time. Also, we show that the k-path problem for nondeterministic input-driven pushdown automata (respectively, for nondeterministic finite automata) is complete for exponential time (respectively, complete for polynomial space).

A pumping lemma for regular closure of prefix-free languages

Let Σ be an infinite set of distinct symbols. Let PFL⊆Power(Σ⁎) be the set of all prefix-free languages. For N⊆Power(Σ⁎), let ΓREG(N) be the regular closure of N, i.e., let ΓREG(N) be the smallest set such that N⊆ΓREG(N) and L1∪L2, L1L2, L1⁎∈ΓREG(N) for any L1,L2∈ΓREG(N). In this paper, we provide a pumping lemma for ΓREG(PFL). This lemma enables us to prove that some languages do not belong to ΓREG(PFL). It is notable that we immediately obtain a pumping lemma for ΓREG(DCFL) as a corollary, due to the known fact that ΓREG(DCFL)=ΓREG(DCFL∩PFL), where we define DCFL as DCFL:=∪Σ0DCFL(Σ0) with the union taken over all non-empty finite set Σ0⊆Σ, and DCFL(Σ0) is the family of all L⊆Σ0⁎ such that L is accepted by a deterministic pushdown automaton over Σ0 by final state.

Pushdown automata and constant height: decidability and bounds

It cannot be decided whether a pushdown automaton accepts using a pushdown height, which does not depend on the input length, i.e., when it accepts using constant height. Furthermore, when a pushdown automaton accepts in constant height, the height can be arbitrarily large with respect to the size of the description of the machine, namely it does not exist any recursive function in the size of the description of the machine bounding the height of the pushdown. In contrast, in the restricted case of pushdown automata over a one-letter input alphabet, i.e., unary pushdown automata, the situation is different. First, acceptance in constant height is decidable. Moreover, in the case of acceptance in constant height, the height is at most exponential with respect to the size of the description of the pushdown automaton. We also prove a matching lower bound. Finally, if a unary pushdown automaton uses nonconstant height to accept, then the height should grow at least as the logarithm of the input length. This bound is optimal.

Learning Bounded Context-Free-Grammar via LSTM and the Transformer: Difference and the Explanations

Long Short-Term Memory (LSTM) and Transformers are two popular neural architectures used for natural language processing tasks. Theoretical results show that both are Turing-complete and can represent any context-free language (CFL).In practice, it is often observed that Transformer models have better representation power than LSTM. But the reason is barely understood. We study such practical differences between LSTM and Transformer and propose an explanation based on their latent space decomposition patterns. To achieve this goal, we introduce an oracle training paradigm, which forces the decomposition of the latent representation of LSTMand the Transformer and supervises with the transitions of the Pushdown Automaton (PDA) of the corresponding CFL. With the forced decomposition, we show that the performance upper bounds of LSTM and Transformer in learning CFL are close: both of them can simulate a stack and perform stack operation along with state transitions. However, the absence of forced decomposition leads to the failure of LSTM models to capture the stack and stack operations, while having a marginal impact on the Transformer model. Lastly, we connect the experiment on the prototypical PDA to a real-world parsing task to re-verify the conclusions