Finite Automata and Non-self-Embedding Grammars

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).

From the Publisher: This text makes in-depth explorations of a broad range of theoretical topics in computer science. It plunges into the applications of the abstract concepts in order to confront and address the skepticism of readers, and instill in them an appreciation for the usefulness of theory. A two-part presentation integrates logic and formal language—both with applications. Chapter topics cover mathematical preliminaries, propositional logic, proving things: why and how, predicate logic, proving with predicates, program verification, logic programming, language models for computer science, language models, finite automata and their languages, regular expressions, Lex: a tool for building lexical scanners, context-free grammars, pushdown automata and parsing, and turing machines. For future computer scientists.

In the compiler literature, parsing algorithms for context-free grammars are presented using string rewriting systems or abstract machines such as pushdown automata. Unfortunately, the resulting descriptions can be baroque, and even a basic understanding of some parsing algorithms, such as Earley’s algorithm for general context-free grammars, can be elusive. In this paper, we present a graphical representation of context-free grammars called the Grammar Flow Graph (GFG) that permits parsing problems to be phrased as path problems in graphs; intuitively, the GFG plays the same role for context-free grammars that nondeterministic finite-state automata play for regular grammars. We show that the GFG permits an elementary treatment of Earley’s algorithm that is much easier to understand than previous descriptions of this algorithm. In addition, look-ahead computation can be expressed as a simple inter-procedural dataflow analysis problem, providing an unexpected link between front-end and back-end technologies in compilers. These results suggest that the GFG can be a new foundation for the study of context-free grammars.

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.

Two schemes for the specification of translations on a context-free grammar are proposed. The first scheme, called a generalized syntax directed translation (GSDT), consists of a context free grammar with a set of semantic rules associated with each production of the grammar. In a GSDT an input word is parsed according to the underlying context free grammar, and at each node of the tree, a finite number of translation strings are computed in terms of the translation strings defined at the descendants of that node. The functional relationship between the length of input and length of output for translations defined by GSDT's is investigated. The second method for the specification of translations is in terms of tree automata - finite automata with output, operating on derivation trees of a context free grammar. It is shown that tree automata provide an exact characterization for those GSDT's with a linear relationship between input and output length.

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.

In this paper we present the new version of a tool to assist in teaching formal languages and automata theory. In the previous version the tool provided algorithms for regular expressions, finite automata and context free grammars. The new version can simulate as well push-down automata and Turing machines.

Learning TOC – begins is a web application which is useful for Learning TOC (Theory of Computation). It covers hypothesis of the basic points with cases and it likewise has Exercise segment in which client can check different speculations for all intents and purposes. It likewise creates drawing of different cases. So the client can learn it adequately and additionally quick. Client can build FA of the string without anyone else and print or fare it for his task work. It has the office of Test to check his score and readiness work. So it is extremely valuable for client as exam arrangement. This Web Application is valuable for the educators and understudies and additionally different clients which are has a place with the Computer Science field. The fundamental reason for this web application is to pick up everything outwardly and graphically. It covers the listed topics given below- Regular Expression, Finite Automata, Context Free Grammar, Push Down Automata, Turing Machine, Exercise of the topics, Mock test.

Finite devices accepting infinite strings are the topic of several papers (see the recent surveys [4], [8] or [10], [11]). Most of these papers deal with finite automata. Thus finite automata as devices accepting infinite strings are wellunderstood. The situation is a little bit more involved if one considers more complicated accepting devices like, e.g., pushdown automata or Turing machines.

We investigate the grammatical complexity of finite languages w.r.t. context-free grammars and variants thereof. For fixed alphabets, it is shown that both the minimal number of productions and the minimal size of a context-free grammar generating a finite language cannot be approximated within a factor of \(o(p^{1/6})\) and \(o(s^{1/7})\), respectively, unless Open image in new window . Here, p is the number of productions and s the size of the given grammar. Similar inapproximability results also hold for linear context-free and right-linear (or regular) grammars. As a byproduct, we show that the language of all cubes of a given length requires an exponential number of context-free productions and we also investigate upper and lower bounds on the complexity of the operations union and concatenation for finite languages.

We define classical language equations and relate them to nondeterministic finite automata. Then, we give two quite different solution approaches, both constructive. One is based on syntactic properties of the equations and essentially yields regular expressions as solutions. The other is by construction of nondeterministic finite automata. Advantages and disadvantages of both approaches are discussed; the second method (construction of a nondeterministic finite automaton) prepares us for the construction of a different kind of finite automaton (namely boolean) in the next chapter. The first method (construction of a regular expression) motivates a discussion of the substitution property, a property that holds for our solutions if OP does not contain the complementation or the intersection operator. We conclude this chapter by commenting on context-free grammars and the equations they engender.

We consider the producer/consumer Petri net and the context-free formal language that it generates. Nonregularity of the language is proved, the corresponding pushdown automaton and context-free grammar are obtained. The connection with the Dyck formal language is pointed out.

The problem of RNA secondary structure design (also called inverse folding) is the following: given a target secondary structure, one aims to create a sequence that folds into, or is compatible with, a given structure. In several practical applications in biology, additional constraints must be taken into account, such as the presence/absence of regulatory motifs, either at a specific location or anywhere in the sequence. In this study, we investigate the design of RNA sequences from their targeted secondary structure, given these additional sequence constraints. To this purpose, we develop a general framework based on concepts of language theory, namely context-free grammars and finite automata. We efficiently combine a comprehensive set of constraints into a unifying context-free grammar of moderate size. From there, we use generic generic algorithms to perform a (weighted) random generation, or an exhaustive enumeration, of candidate sequences. The resulting method, whose complexity scales linearly with the length of the RNA, was implemented as a standalone program. The resulting software was embedded into a publicly available dedicated web server. The applicability demonstrated of the method on a concrete case study dedicated to Exon Splicing Enhancers, in which our approach was successfully used in the design of \emph{in vitro} experiments.

This manuscript contains the experimental realization of one instance of each automata in the theory of computation using chemistry and not using biochemistry. All automata are implemented in a 1-pot reactor. The Finite Automaton (FA) is represented by a precipitation reaction, the 1-stack Push Down Automaton (PDA) by a pH reaction network and the Turing machine (TM) by the Belousov-Zhabotinsky chemical reaction. The computation (consisting on recognizing if chemically transcribed abstract sequences belong to appropriate languages in the Chomsky hierarchy) is carried out by a chemical reaction recognizing the molecules and their order. Once the sequence is introduced in the reactor (very much as mRNA is introduced in the ribosome) the reaction does all the recognition without any need for external not strictly chemical help from reaction/diffusion set-ups or chemical gates. The result of the computation has a straightforward thermodynamic/information theory interpretation. These results are of interest for soft-robotics, chemically self-assembled systems, chemical neural networks, artificial intelligence and of course chemical computing (i. e., computing done by chemistry at molecular scales which translates to larger scales by the power of Avogadro's number) as well as natural computing and analog/digital computing.

We present a collection of new and enhanced tools for experimenting with concepts in formal languages and automata theory. New tools, written in Java, include JFLAP for creating and simulating finite automata, pushdown automata and Turing machines; Pâté for parsing restricted and unrestricted grammars and transforming context-free grammars to Chomsky Normal Form; and PumpLemma for proving specific languages are not regular. Enhancements to previous tools LLparse and LRparse, instructional tools for parsing LL(1) and LR(1) grammars, include parsing LL(2) grammars, displaying parse trees, and parsing any context-free grammar with conflict resolution.