DOCSLIB.ORG

Automata Theory and Formal Languages

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Automata Theory and Formal Languages Alberto Pettorossi Automata Theory and Formal Languages ARACNE Contents Preface 7 Chapter 1. Formal Grammars and Languages 9 1.1. Free Monoids 9 1.2. Formal Grammars 10 1.3. The Chomsky Hierarchy 13 1.4. Chomsky Normal Form and Greibach Normal Form 19 1.5. Epsilon Productions 20 1.6. Derivations in Context-Free Grammars 24 1.7. Substitutions and Homomorphisms 27 Chapter 2. Finite Automata and Regular Grammars 29 2.1. Deterministic and Nondeterministic Finite Automata 29 2.2. Nondeterministic Finite Automata and S-extended Type 3 Grammars 33 2.3. Finite Automata and Transition Graphs 35 2.4. Left Linear and Right Linear Regular Grammars 39 2.5. Finite Automata and Regular Expressions 44 2.6. Arden Rule 56 2.7. Equations Between Regular Expressions 57 2.8. Minimization of Finite Automata 59 2.9. Pumping Lemma for Regular Languages 72 2.10. A Parser for Regular Languages 74 2.10.1. A Java Program for Parsing Regular Languages 82 2.11. Generalizations of Finite Automata 90 2.11.1. Moore Machines 91 2.11.2. Mealy Machines 91 2.11.3. Generalized Sequential Machines 92 2.12. Closure Properties of Regular Languages 94 2.13. Decidability Properties of Regular Languages 96 Chapter 3. Pushdown Automata and Context-Free Grammars 99 3.1. Pushdown Automata and Context-Free Languages 99 3.2. From PDA’s to Context-Free Grammars and Back: Some Examples 111 3.3. Deterministic PDA’s and Deterministic Context-Free Languages 117 3.4. Deterministic PDA’s and Grammars in Greibach Normal Form 121 3.5. Simplifications of Context-Free Grammars 123 3.5.1. Elimination of Nonterminal Symbols That Do Not Generate Words 123 3.5.2. Elimination of Symbols Unreachable from the Start Symbol 124 5 6 CONTENTS 3.5.3. Elimination of Epsilon Productions 125 3.5.4. Elimination of Unit Productions 126 3.5.5. Elimination of Left Recursion 129 3.6. Construction of the Chomsky Normal Form 131 3.7. Construction of the Greibach Normal Form 133 3.8. Theory of Language Equations 141 3.9. Summary on the Transformations of Context-Free Grammars 146 3.10. Self-Embedding Property of Context-Free Grammars 147 3.11. Pumping Lemma for Context-Free Languages 150 3.12. Ambiguity and Inherent Ambiguity 155 3.13. Closure Properties of Context-Free Languages 157 3.14. Basic Decidable Properties of Context-Free Languages 158 3.15. Parsers for Context-Free Languages 159 3.15.1. The Cocke-Younger-Kasami Parser 159 3.15.2. The Earley Parser 162 3.16. Parsing Classes of Deterministic Context-Free Languages 167 3.17. Closure Properties of Deterministic Context-Free Languages 169 3.18. Decidable Properties of Deterministic Context-Free Languages 170 Chapter 4. Linear Bounded Automata and Context-Sensitive Grammars 171 4.1. Recursiveness of Context-Sensitive Languages 179 Chapter 5. Turing Machines and Type 0 Grammars 183 5.1. Equivalence Between Turing Machines and Type 0 Languages 190 Chapter 6. Decidability and Undecidability in Context-FreeLanguages 195 6.1. Some Basic Decidability and Undecidabilty Results 199 6.1.1. Basic Undecidable Properties of Context-Free Languages 201 6.2. Decidability in Deterministic Context-Free Languages 204 6.3. Undecidability in Deterministic Context-Free Languages 205 6.4. Undecidable Properties of Linear Context-Free Languages 205 Chapter 7. Appendices 207 7.1. Iterated Counter Machines and Counter Machines 207 7.2. Stack Automata 215 7.3. Relationships Among Various Classes of Automata 217 7.4. Decidable Properties of Classes of Languages 221 7.5. Algebraic and Closure Properties of Classes of Languages 224 7.6. Abstract Families of Languages 225 7.7. From Finite Automata to Left Linear and Right Linear Grammars 230 7.8. Context-Free Grammars over Singleton Terminal Alphabets 232 7.9. The Bernstein Theorem 235 7.10. Existence of Functions That Are Not Computable 237 Index 247 Bibliography 255 Preface These lecture notes present some basic notions and results on Automata Theory, Formal Languages Theory, Computability Theory, and Parsing Theory. I prepared these notes for a course on Automata, Languages, and Translators which I am teaching at the University of Roma Tor Vergata. More material on these topics and on parsing techniques for context-free languages can be found in standard textbooks such as [1, 8, 9]. The reader is encouraged to look at those books. A theorem denoted by the triple k.m.n is in Chapter k and Section m, and within that section it is identified by the number n. Analogous numbering system is used for algorithms, corollaries, definitions, examples, exercises, figures, and remarks. We use ‘iff’ to mean ‘if and only if’. Many thanks to my colleagues of the Department of Informatics, Systems, and Production of the University of Roma Tor Vergata. I am also grateful to my stu- dents and co-workers and, in particular, to Lorenzo Clemente, Corrado Di Pietro, Fulvio Forni, Fabio Lecca, Maurizio Proietti, and Valerio Senni for their help and encouragement. Finally, I am grateful to Francesca Di Benedetto, Alessandro Colombo, Donato Corvaglia, Gioacchino Onorati, and Leonardo Rinaldi of the Aracne Publishing Com- pany for their kind cooperation. Roma, June 2008 In the second edition we have corrected a few mistakes and added Section 7.7 on the derivation of left linear and right linear regular grammars from finite automata and Section 7.8 on context-free grammars with singleton terminal alphabets. Roma, July 2009 In the third edition we have made a few minor improvements in various chapters. Roma, July 2011 Alberto Pettorossi Department of Informatics, Systems, and Production University of Roma Tor Vergata Via del Politecnico 1, I-00133 Roma, Italy [email protected] http://www.iasi.cnr.it/~adp 7 CHAPTER 1 Formal Grammars and Languages In this chapter we introduce some basic notions and some notations we will use in the book. The set of natural numbers 0, 1, 2,... is denoted by N. Given a set A, A denotes the{ cardinality} of A, and 2A denotes the powerset of A, that is, the set of| all| subsets of A. Instead of 2A, we will also write Powerset(A). We say that a set S is countable iff either S is finite or there exists a bijection between S and the set N of natural numbers. 1.1. Free Monoids Let us consider a countable set V , also called an alphabet. The elements of V are called symbols. The free monoid generated by the set V is the set, denoted V ∗, consisting of all finite sequences of symbols in V , that is, V ∗ = v ...v n 0 and for i =0,...,n, v V . { 1 n | ≥ i ∈ } The unary operation ∗ (pronounced ‘star’) is called Kleene star (or Kleene closure, or ∗ closure). Sequences of symbols are also called words or strings. The length of a sequence v1 ...vn is n. The sequence of length 0 is called the empty sequence or empty word and it is denoted by ε. The length of a sequence w is also denoted by w . | | ∗ Given two sequences w1 and w2 in V , their concatenation, denoted w1 w2 or ∗ simply w1w2, is the sequence in V defined by recursion on the length of w1 as follows: w1 w2 = w2 if w1 = ε = v1((v2 ...vn) w2) if w1 = v1v2 ...vn with n>0. We have that w1 w2 = w1 + w2 . The concatenation operation is associative and its neutral| element| is| the| empty| | sequence ε. Any set of sequences which is a subset of V ∗ is called a language (or a formal language) over the alphabet V . Given two languages A and B, their concatenation, denoted A B, is defined as follows: A B = w w w A and w B . { 1 2 | 1 ∈ 2 ∈ } Concatenation of languages is associative and its neutral element is the singleton ε . When B is a singleton, say w , the concatenation A B will also be written as A{ }w or simply Aw. Obviously,{ if A} = or A = then A B = . ∅ ∅ ∅ We have that: V ∗ = V 0 V 1 V 2 . V k . ., where for each k 0, V k is the set of all sequences of length∪ ∪k of symbols∪ ∪ of V∪, that is, ≥ 9 10 1. FORMAL GRAMMARS AND LANGUAGES V k = v ...v for i =0,...,k, v V . { 1 k | i ∈ } Obviously, V 0 = ε , V 1 = V , and for h, k 0, V h V k = V h+k = V k+h. By V + we denote V ∗ {ε }. The unary operation +≥(pronounced ‘plus’) is called positive closure or + closure−{ }. The set V 0 V 1 is also denoted by V 0,1. ∪ Given an element a in a set V , a∗ denotes the set of all finite sequence of zero or more a’s (thus, a∗ is an abbreviation for a ∗), a+ denotes the set of all finite sequence of one or more a’s (thus, a+ is an{ abbreviation} for a +), a 0,1 denotes the set ε, a (thus, a 0,1 is an abbreviation for a 0,1), and aω {denotes} the infinite sequence{ made} out of all a’s. { } Given a word w, for any k 0, the prefix of w of length k, denoted w k, is defined as follows: ≥ w = if w k then w else u, where w = u v and u =k. k | |≤ | | In particular, for any w, we have that: w 0 = ε and w |w| = w. Given a language L V ∗, we introduce the following notation: ⊆ (i) L0 = ε { } (ii) L1 = L (iii) Ln+1 = L Ln ∗ k (iv) L = k≥0 L + S k (v) L = k>0 L (vi) L 0,1 =SL0 L1 ∪ We also have that Ln+1 = Ln L and L+ = L∗ ε .
Load more

Recommended publications
  • Nooj Computational Devices Max Silberztein
    NooJ Computational Devices Max Silberztein To cite this version: Max Silberztein. NooJ Computational Devices. Formalising Natural Languages With NooJ, Jun 2012, Paris, France. hal-02435921 HAL Id: hal-02435921 https://hal.archives-ouvertes.fr/hal-02435921 Submitted on 11 Jan 2020 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. NOOJ COMPUTATIONAL DEVICES MAX SILBERZTEIN Introduction NooJ’s linguistic development environment provides tools for linguists to construct linguistic resources that formalize 7 types of linguistic phenomena: typography, orthography, inflectional and derivational morphology, local and structural syntax, and semantics. NooJ also provides a set of parsers that can process any linguistic resource for these 7 types, and apply it to any corpus of texts in order to extract examples, annotate matching sequences, perform statistical analyses, etc.1 NooJ’s approach to Linguistics is peculiar in the world of Computational Linguistics: instead of constructing a large single grammar to describe a particular natural language (e.g. “a grammar of English”), NooJ users typically construct, edit, test and maintain a large number of local (small) grammars; for instance, there is a grammar that describes how to conjugate the verb to be, another grammar that describes how to state a date in English, another grammar that describes the heads of Noun Phrases, etc.
    [Show full text]
  • Formal Languages and Automata Theory Géza Horváth, Benedek Nagy Szerzői Jog © 2014 Géza Horváth, Benedek Nagy, University of Debrecen
    Formal Languages and Automata Theory Géza Horváth, Benedek Nagy Created by XMLmind XSL-FO Converter. Formal Languages and Automata Theory Géza Horváth, Benedek Nagy Szerzői jog © 2014 Géza Horváth, Benedek Nagy, University of Debrecen Created by XMLmind XSL-FO Converter. Tartalom Formal Languages and Automata Theory .......................................................................................... vi Introduction ...................................................................................................................................... vii 1. Elements of Formal Languages ...................................................................................................... 1 1. 1.1. Basic Terms .................................................................................................................... 1 2. 1.2. Formal Systems .............................................................................................................. 2 3. 1.3. Generative Grammars .................................................................................................... 5 4. 1.4. Chomsky Hierarchy ....................................................................................................... 6 2. Regular Languages and Finite Automata ...................................................................................... 12 1. 2.1. Regular Grammars ....................................................................................................... 12 2. 2.2. Regular Expressions ....................................................................................................
    [Show full text]
  • Computability and Complexity
    Computability and Complexity Lecture Notes Winter Semester 2016/2017 Wolfgang Schreiner Research Institute for Symbolic Computation (RISC) Johannes Kepler University, Linz, Austria [email protected] July 18, 2016 Contents List of Definitions5 List of Theorems7 List of Theses9 List of Figures9 Notions, Notations, Translations 12 1. Introduction 18 I. Computability 23 2. Finite State Machines and Regular Languages 24 2.1. Deterministic Finite State Machines...................... 25 2.2. Nondeterministic Finite State Machines.................... 30 2.3. Minimization of Finite State Machines..................... 38 2.4. Regular Languages and Finite State Machines................. 43 2.5. The Expressiveness of Regular Languages................... 58 3. Turing Complete Computational Models 63 3.1. Turing Machines................................ 63 3.1.1. Basics.................................. 63 3.1.2. Recognizing Languages........................ 68 3.1.3. Generating Languages......................... 72 3.1.4. Computing Functions.......................... 74 3.1.5. The Church-Turing Thesis....................... 79 Contents 3 3.2. Turing Complete Computational Models.................... 80 3.2.1. Random Access Machines....................... 80 3.2.2. Loop and While Programs....................... 84 3.2.3. Primitive Recursive and µ-recursive Functions............ 95 3.2.4. Further Models............................. 106 3.3. The Chomsky Hierarchy............................ 111 3.4. Real Computers................................
    [Show full text]
  • Grammars (Cfls & Cfgs) Reading: Chapter 5
    Context-Free Languages & Grammars (CFLs & CFGs) Reading: Chapter 5 1 Not all languages are regular So what happens to the languages which are not regular? Can we still come up with a language recognizer? i.e., something that will accept (or reject) strings that belong (or do not belong) to the language? 2 Context-Free Languages A language class larger than the class of regular languages Supports natural, recursive notation called “context- free grammar” Applications: Context- Parse trees, compilers Regular free XML (FA/RE) (PDA/CFG) 3 An Example A palindrome is a word that reads identical from both ends E.g., madam, redivider, malayalam, 010010010 Let L = { w | w is a binary palindrome} Is L regular? No. Proof: N N (assuming N to be the p/l constant) Let w=0 10 k By Pumping lemma, w can be rewritten as xyz, such that xy z is also L (for any k≥0) But |xy|≤N and y≠ + ==> y=0 k ==> xy z will NOT be in L for k=0 ==> Contradiction 4 But the language of palindromes… is a CFL, because it supports recursive substitution (in the form of a CFG) This is because we can construct a “grammar” like this: Same as: 1. A ==> A => 0A0 | 1A1 | 0 | 1 | Terminal 2. A ==> 0 3. A ==> 1 Variable or non-terminal Productions 4. A ==> 0A0 5. A ==> 1A1 How does this grammar work? 5 How does the CFG for palindromes work? An input string belongs to the language (i.e., accepted) iff it can be generated by the CFG G: Example: w=01110 A => 0A0 | 1A1 | 0 | 1 | G can generate w as follows: Generating a string from a grammar: 1.
    [Show full text]
  • A Grammar-Based Approach to Class Diagram Validation Faizan Javed Marjan Mernik Barrett R
    A Grammar-Based Approach to Class Diagram Validation Faizan Javed Marjan Mernik Barrett R. Bryant, Jeff Gray Department of Computer and Faculty of Electrical Engineering and Department of Computer and Information Sciences Computer Science Information Sciences University of Alabama at Birmingham University of Maribor University of Alabama at Birmingham 1300 University Boulevard Smetanova 17 1300 University Boulevard Birmingham, AL 35294-1170, USA 2000 Maribor, Slovenia Birmingham, AL 35294-1170, USA [email protected] [email protected] {bryant, gray}@cis.uab.edu ABSTRACT between classes to perform the use cases can be modeled by UML The UML has grown in popularity as the standard modeling dynamic diagrams, such as sequence diagrams or activity language for describing software applications. However, UML diagrams. lacks the formalism of a rigid semantics, which can lead to Static validation can be used to check whether a model conforms ambiguities in understanding the specifications. We propose a to a valid syntax. Techniques supporting static validation can also grammar-based approach to validating class diagrams and check whether a model includes some related snapshots (i.e., illustrate this technique using a simple case-study. Our technique system states consisting of objects possessing attribute values and involves converting UML representations into an equivalent links) desired by the end-user, but perhaps missing from the grammar form, and then using existing language transformation current model. We believe that the latter problem can occur as a and development tools to assist in the validation process. A string system becomes more intricate; in this situation, it can become comparison metric is also used which provides feedback, allowing hard for a developer to detect whether a state envisaged by the the user to modify the original class diagram according to the user is included in the model.
    [Show full text]
  • Formal Language and Automata Theory (CS21004)
    Context Free Grammar Normal Forms Derivations and Ambiguities Pumping lemma for CFLs PDA Parsing CFL Properties Formal Language and Automata Theory (CS21004) Soumyajit Dey CSE, IIT Kharagpur Context Free Formal Language and Automata Theory Grammar (CS21004) Normal Forms Derivations and Ambiguities Pumping lemma Soumyajit Dey for CFLs CSE, IIT Kharagpur PDA Parsing CFL Properties DPDA, DCFL Membership CSL Soumyajit Dey CSE, IIT Kharagpur Formal Language and Automata Theory (CS21004) Context Free Grammar Normal Forms Derivations and Ambiguities Pumping lemma for CFLs PDA Parsing CFL Properties Formal Language and Automata Announcements Theory (CS21004) Soumyajit Dey CSE, IIT Kharagpur Context Free Grammar Normal Forms Derivations and The slide is just a short summary Ambiguities Follow the discussion and the boardwork Pumping lemma for CFLs Solve problems (apart from those we dish out in class) PDA Parsing CFL Properties DPDA, DCFL Membership CSL Soumyajit Dey CSE, IIT Kharagpur Formal Language and Automata Theory (CS21004) Context Free Grammar Normal Forms Derivations and Ambiguities Pumping lemma for CFLs PDA Parsing CFL Properties Formal Language and Automata Table of Contents Theory (CS21004) Soumyajit Dey 1 Context Free Grammar CSE, IIT Kharagpur 2 Normal Forms Context Free Grammar 3 Derivations and Ambiguities Normal Forms 4 Derivations and Pumping lemma for CFLs Ambiguities 5 Pumping lemma PDA for CFLs 6 Parsing PDA Parsing 7 CFL Properties CFL Properties DPDA, DCFL 8 DPDA, DCFL Membership 9 Membership CSL 10 CSL Soumyajit Dey CSE,
    [Show full text]
  • Regular Expressions with a Brief Intro to FSM
    Regular Expressions with a brief intro to FSM 15-123 Systems Skills in C and Unix Case for regular expressions • Many web applications require pattern matching – look for <a href> tag for links – Token search • A regular expression – A pattern that defines a class of strings – Special syntax used to represent the class • Eg; *.c - any pattern that ends with .c Formal Languages • Formal language consists of – An alphabet – Formal grammar • Formal grammar defines – Strings that belong to language • Formal languages with formal semantics generates rules for semantic specifications of programming languages Automaton • An automaton ( or automata in plural) is a machine that can recognize valid strings generated by a formal language . • A finite automata is a mathematical model of a finite state machine (FSM), an abstract model under which all modern computers are built. Automaton • A FSM is a machine that consists of a set of finite states and a transition table. • The FSM can be in any one of the states and can transit from one state to another based on a series of rules given by a transition function. Example What does this machine represents? Describe the kind of strings it will accept. Exercise • Draw a FSM that accepts any string with even number of A’s. Assume the alphabet is {A,B} Build a FSM • Stream: “I love cats and more cats and big cats ” • Pattern: “cat” Regular Expressions Regex versus FSM • A regular expressions and FSM’s are equivalent concepts. • Regular expression is a pattern that can be recognized by a FSM. • Regex is an example of how good theory leads to good programs Regular Expression • regex defines a class of patterns – Patterns that ends with a “*” • Regex utilities in unix – grep , awk , sed • Applications – Pattern matching (DNA) – Web searches Regex Engine • A software that can process a string to find regex matches.
    [Show full text]
  • Recursively Enumerable and Recursive Languages
    Review • Languages and Grammars – Alphabets, strings, languages • Regular Languages – Deterministic Finite and Nondeterministic Automata – Equivalence of NFA and DFA Regular Expressions CS 301 - Lecture 23 – Regular Grammars – Properties of Regular Languages – Languages that are not regular and the pumping lemma Recursive and Recursively • Context Free Languages – Context Free Grammars – Derivations: leftmost, rightmost and derivation trees Enumerable Languages – Parsing and ambiguity – Simplifications and Normal Forms – Nondeterministic Pushdown Automata – Pushdown Automata and Context Free Grammars Fall 2008 – Deterministic Pushdown Automata – Pumping Lemma for context free grammars – Properties of Context Free Grammars • Turing Machines – Definition, Accepting Languages, and Computing Functions – Combining Turing Machines and Turing’s Thesis – Turing Machine Variations – Universal Turing Machine and Linear Bounded Automata – Today: Recursive and Recursively Enumerable Languages Definition: A language is recursively enumerable Recursively Enumerable if some Turing machine accepts it and Recursive Languages 1 Let L be a recursively enumerable language Definition: A language is recursive and M the Turing Machine that accepts it if some Turing machine accepts it and halts on any input string For string w : if w∈ L then M halts in a final state In other words: if w∉ L then M halts in a non-final state A language is recursive if there is or loops forever a membership algorithm for it Let L be a recursive language and M the Turing Machine
    [Show full text]
  • INF2080 Context-Sensitive Langugaes
    INF2080 Context-Sensitive Langugaes Daniel Lupp Universitetet i Oslo 15th February 2017 Department of University of Informatics Oslo INF2080 Lecture :: 15th February 1 / 20 Context-Free Grammar Definition (Context-Free Grammar) A context-free grammar is a 4-tuple (V ; Σ; R; S) where 1 V is a finite set of variables 2 Σ is a finite set disjoint from V of terminals 3 R is a finite set of rules, each consisting of a variable and of a string of variables and terminals 4 and S is the start variable Rules are of the form A ! B1B2B3 ::: Bm, where A 2 V and each Bi 2 V [ Σ. INF2080 Lecture :: 15th February 2 / 20 consider the following toy programming language, where you can “declare” and “assign” a variable a value. S ! declare v; S j assign v : x; S this is context-free... but what if we only want to allow assignment after declaration and an infinite amount of variable names? ! context-sensitive! Why Context-Sensitive? Many building blocks of programming languages are context-free, but not all! INF2080 Lecture :: 15th February 3 / 20 this is context-free... but what if we only want to allow assignment after declaration and an infinite amount of variable names? ! context-sensitive! Why Context-Sensitive? Many building blocks of programming languages are context-free, but not all! consider the following toy programming language, where you can “declare” and “assign” a variable a value. S ! declare v; S j assign v : x; S INF2080 Lecture :: 15th February 3 / 20 but what if we only want to allow assignment after declaration and an infinite amount of variable names? ! context-sensitive! Why Context-Sensitive? Many building blocks of programming languages are context-free, but not all! consider the following toy programming language, where you can “declare” and “assign” a variable a value.
    [Show full text]
  • Generating Context-Free Grammars Using Classical Planning
    Proceedings of the Twenty-Sixth International Joint Conference on Artificial Intelligence (IJCAI-17) Generating Context-Free Grammars using Classical Planning Javier Segovia-Aguas1, Sergio Jimenez´ 2, Anders Jonsson 1 1 Universitat Pompeu Fabra, Barcelona, Spain 2 University of Melbourne, Parkville, Australia [email protected], [email protected], [email protected] Abstract S ! aSa S This paper presents a novel approach for generating S ! bSb /|\ Context-Free Grammars (CFGs) from small sets of S ! a S a /|\ input strings (a single input string in some cases). a S a Our approach is to compile this task into a classical /|\ planning problem whose solutions are sequences b S b of actions that build and validate a CFG compli- | ant with the input strings. In addition, we show that our compilation is suitable for implementing the two canonical tasks for CFGs, string produc- (a) (b) tion and string recognition. Figure 1: (a) Example of a context-free grammar; (b) the corre- sponding parse tree for the string aabbaa. 1 Introduction A formal grammar is a set of symbols and rules that describe symbols in the grammar and (2), a bounded maximum size of how to form the strings of certain formal language. Usually the rules in the grammar (i.e. a maximum number of symbols two tasks are defined over formal grammars: in the right-hand side of the grammar rules). Our approach is compiling this inductive learning task into • Production : Given a formal grammar, generate strings a classical planning task whose solutions are sequences of ac- that belong to the language represented by the grammar.
    [Show full text]
  • Section 12.3 Context-Free Parsing We Know (Via a Theorem) That the Context-Free Languages Are Exactly Those Languages That Are Accepted by Pdas
    Section 12.3 Context-Free Parsing We know (via a theorem) that the context-free languages are exactly those languages that are accepted by PDAs. When a context-free language can be recognized by a deterministic final-state PDA, it is called a deterministic context-free language. An LL(k) grammar has the property that a parser can be constructed to scan an input string from left to right and build a leftmost derivation by examining next k input symbols to determine the unique production for each derivation step. If a language has an LL(k) grammar, it is called an LL(k) language. LL(k) languages are deterministic context-free languages, but there are deterministic context-free languages that are not LL(k). (See text for an example on page 789.) Example. Consider the language {anb | n ∈ N}. (1) It has the LL(1) grammar S → aS | b. A parser can examine one input letter to decide whether to use S → aS or S → b for the next derivation step. (2) It has the LL(2) grammar S → aaS | ab | b. A parser can examine two input letters to determine whether to use S → aaS or S → ab for the next derivation step. Notice that the grammar is not LL(1). (3) Quiz. Find an LL(3) grammar that is not LL(2). Solution. S → aaaS | aab | ab | b. 1 Example/Quiz. Why is the following grammar S → AB n n + k for {a b | n, k ∈ N} an-LL(1) grammar? A → aAb | Λ B → bB | Λ. Answer: Any derivation starts with S ⇒ AB.
    [Show full text]
  • Formal Grammar Specifications of User Interface Processes
    FORMAL GRAMMAR SPECIFICATIONS OF USER INTERFACE PROCESSES by MICHAEL WAYNE BATES ~ Bachelor of Science in Arts and Sciences Oklahoma State University Stillwater, Oklahoma 1982 Submitted to the Faculty of the Graduate College of the Oklahoma State University iri partial fulfillment of the requirements for the Degree of MASTER OF SCIENCE July, 1984 I TheSIS \<-)~~I R 32c-lf CO'f· FORMAL GRAMMAR SPECIFICATIONS USER INTER,FACE PROCESSES Thesis Approved: 'Dean of the Gra uate College ii tta9zJ1 1' PREFACE The benefits and drawbacks of using a formal grammar model to specify a user interface has been the primary focus of this study. In particular, the regular grammar and context-free grammar models have been examined for their relative strengths and weaknesses. The earliest motivation for this study was provided by Dr. James R. VanDoren at TMS Inc. This thesis grew out of a discussion about the difficulties of designing an interface that TMS was working on. I would like to express my gratitude to my major ad­ visor, Dr. Mike Folk for his guidance and invaluable help during this study. I would also like to thank Dr. G. E. Hedrick and Dr. J. P. Chandler for serving on my graduate committee. A special thanks goes to my wife, Susan, for her pa­ tience and understanding throughout my graduate studies. iii TABLE OF CONTENTS Chapter Page I. INTRODUCTION . II. AN OVERVIEW OF FORMAL LANGUAGE THEORY 6 Introduction 6 Grammars . • . • • r • • 7 Recognizers . 1 1 Summary . • • . 1 6 III. USING FOR~AL GRAMMARS TO SPECIFY USER INTER- FACES . • . • • . 18 Introduction . 18 Definition of a User Interface 1 9 Benefits of a Formal Model 21 Drawbacks of a Formal Model .
    [Show full text]