DOCSLIB.ORG

Properties of LL-Regular Languages

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

Purdue University Purdue e-Pubs Department of Computer Science Technical Reports Department of Computer Science 1977 Properties of LL-Regular Languages David A. Poplawski Report Number: 77-241 Poplawski, David A., "Properties of LL-Regular Languages" (1977). Department of Computer Science Technical Reports. Paper 177. https://docs.lib.purdue.edu/cstech/177 This document has been made available through Purdue e-Pubs, a service of the Purdue University Libraries. Please contact [email protected] for additional information. PROPERTIES OF LL-REGULAR LANGUAGES David A. Poplawski Computer Science Department Purdue University W. Lafayette, Ind 47907 CSD TR-241 PROPERTIES OF LL-REGULAR LRNGURGES David R. Pop: aujski Rugust 1, 1377' HSSTRROT: The requirements for a context-free grammar to be !_!_- regular are relaxed, producing a larger ciasa of grammars than the original definition. Relationships between LL-regular prannMars and 1 .arrzuaees and other classes of t'ramma^s and languages are investigated, decidability questions are considered and linear time parsing algorithm is described. INTRODUCTION Until recently, efficient deterministic top-down parsing of context- free languages ^as limited to the class of LL(k) languages [8,8], and some variants [1,7,9]. In addition the claso of l.L(f) languages [3] was introduced, but due to the arbitrary nature of the function f, efficient parsing was ofter, irripossi!:^ e. Efficient top-::'oiyn parsing has bean achieved by restricting f to the class of functions computab1, e by generalized sequential machines [5], thereby defining the class of LL-reg'j"iar languages. This paper extends the class of grammars which define LL-regular languages and in addition provides some neu; results not covered in [5], including a two pass parsing algorithm similar to the parsing algorithm for LR-regular languages [2]. 2. LL-REGULAR GRrlMilPRS AND LANGUAGES We wi11 use the foilowing notation throughout this paper: P context-free grammar G wi1! be represented by a four-tuple (N.TpP^), where 1M is the finite set of non-terminal •symbols, T is the finite set of terminal symbols, P is the set of productions of the form where A € N and $ € (I\!l»T)*, AND S is the start symbol. We will occasionally identify a production in P by a unique number j by writing • Let ex,, aa i (NuT)*. We will write o^Ra-, if there is 5 production ? P in the grammar G (omitting the subscript G when it is obvious from the context). If'tXj j ? e T* then we ujrite oc,Rcr.s =» cc^iXg. ~i** then we write a,rla'. cr.^ct"- snd are the transitive completions of l & rm 1 t p m 1 arid respectively, and are the reflexive, transitive completions of and => respectively. If p = p 1 P2 • • • Pr, a sequence o f production identifiers, then a: £ represents a leftmost derivation from a to p using in sequence the productions p,,p£,...If n is an integer, then we write a P if there exists a sequence of productions p = Pi?2---Pn such that a j3. The set L(G) = {x ( T* | S 4 x) is the language generated by the context- free grammar G. Unless otherwise indicated, upper case 1etters S, fl, B lux 1 be symbols in X, upper case letter X wi 1 1 be a symbol in (NuT), lower case letters a, b, c, d, e wi11 be symbols in T, lower case letters w, x, y, z will be strings of symbols in T*, and greek letters will be strings of symbols in (NuT)*. If a e (NuT)*, then is the reverse of a. FIRSTk(x) = x if the length of x is less than or equal to k and FIRST^(x) = y where the length of y equals k and there is a z e T* such that x = yz. Let 77 = (Rj,...,Rn) be a collection of regular sets over T. If the R; are oairwise disjoint and the union of all R; in 7i is equal to T*, then n is called a regular partition of T*. For strings x,y t T*, if x € Rj and y R^ for some i, then we will write xsy (mod n). R deterministic finite automata N will be represented by the five-tuple (Q,T, S , q0, F) , where Q is the set of states, T is the input alphabet, S is a mapping from QxT Q, q0 € Q is the initial state, and FcQ is the set of .final states. DEFINITION 2.1: Let G= (N.T.P.S] be a cfg. Let n = (Rj Rn) be a regular partition of T*. G is said to be strong LL-regular far n if, given any two leftmost derivations: S u^Ra, is* "Mpa, ^ u),x S w2fi«2 ujaVtta # uiay such that x=y (mod n), then it follows that 0 = Y. This definition is equivalent to the definition of. an LL- regular grammar given in [5]. Since it is simi1ar in form to the definition of strong LL(U) grammars [8], grammars satisfying it will be called strong LL-regular grammars. Corresponding to the definition of LT_ (k) grammars [6] are the LL-regular grammars. DEFINITION 2.2: Let G = (N.T.P.S) be a cfg. Let n - (R,,...,Rn) be a regular partition of T*. G is said to be LL-regular for n (written LL(tt)) if, given any two leftmost derivations: S wP.cc utfa wx 5 # wRoc ^ ujYcx # uiy such that x=y (mod , then it follows that fi = y. DEFINITION 2,3: R language L over alphabet T is said to be LL-regu'ar if there exists a grammar G and a regular partition ?i of T* such that G is LL (tt) and L = L(G) . 3. GRRMMRR PROPERTIES RND RELATIONSHIPS The following set of propositions establish the relationship of the class of LL-regular grammars to other grammar classes. The class of LL-regular grammars fall between the LL(l<) and the LR-reguiar [2] class of grammars, and are incomparable with the class of LR(k) grammars. PROPOSITION 3.1: Every strong LL-regular grammar is LL- regular. PROOF: Follows immediately from the definitions, since the strong LL-regiilar definition is a special case of the LL-regular definition. PROPOSITION 3.2: There is an LL-regul^r grammar that is not strong LL-reguiar. PROOF: Let G = ({S,R},{b,c,d,e} ,P,S), ahere P {S^Ab,S^Rc,R->d,R-e}, and let n ({db,ec}, feb,de},T*-(db, ec.eb.dc}). G is not strong LL-regi:iar for tt since the two derivations S # fib db $ db S IT Rc I m ec ITn ec have dbsec (mod n) but d^e. Since there are only four derivations posible in G, we have S Rb & db # db 5 # Rb & ^ & eb but db^eb (mod n) and S # Rc dc # dc S # fic ec # ec but dc^ec (mod tO and therefore G is LL-reguJ ar for n. PROPOSITION 3.3: Let G = (N,T,P,S) be a grammar that is LL (k) for some integer k>1 . Then G is LL(ti) for n= (w, , w2, . , u, T* f u2T*, . .) , where w,,^,... are all the strings over T* of length less than k and U|,u2>... are all the strings over T* of length exactly k. PROOF: Assume G is LL(I<). Consider the two derivations 5 =5? # ujx S # ujRa =* wVa ^ wy and suppose x=y (mod n) . If x,y = uj^ then FIRSTk(x) = FIRSTk(y). If x,y € UlT*, then FIRSTk(x) = FIRSTk(y) also. Since G is LL(!<) iue conclude that £ = 7. Therefore G is LL(rt). 6 PROPOSITION . >i: The grammar G = (N,T,P,S), where N = {S, R, B) , T = fa,b,c,d,e}, and P = (S-?Ra, S^Bb, R">cfid, R~>e, S^cBd, B^e} is LLCtO for the regular J partition n = (cT*a, eT*a, cT*b, eT*b, T*- (c^'e)T* (avb)) , but is not LR(k) for any integer k. PROOF: That G is not LR(k) for any k can be shown by considering the following derivations: S c-Wa =? c" ed" a S e"Bd"b => c" ed" b for n>0. For any fixed integer, k there is always an n>k n n such that FIRSTk (ed a) - FIRSTk (ed" b) . But c RdT a * cMBd"a so G is not LR(k) for any integer k. To show that G is LLW it is sufficient to show that the contrapositive of the definition is satisfied, that is, instead of showing that x=y (mod tt) implies that a = , show that o: ^ implies that xjsy (mod 71). To this end, consider the following three places where the definition may be not satisfied: Case 1 - using productions S-»Ra and S-Bb. S # S Ra # cTedTa S # S Bb # c" edn b n>0 In this case, Ra * Bb, ' and for all n, cnedna^cr'ed"b (mod n) . Case 2 - using productions R-^cRd and fl-»e. S J^ crnRdma =$> crncRddma cmcnedndma 7 S c^rPa cr,V-dma ^ crnedma m>0,n>1 In this case, cRd * e, and for al 1 n and m, cn ed'"1 cma£edrna (mod tt) . Case 3 - using productions B^cBd and B-*e. ' m m n n m S ^it i c'Wb IFI c cBdd b t=mk c 'c ed"d b S # crnBdrob omedmb cmedmb m>D,n>1 In this case, cBd ^ e, and for all n and m, cnedrtcmb£edmb (mod n).
Recommended publications
  • Theory of Computer Science

    Theory of Computer Science

    Theory of Computer Science MODULE-1 Alphabet A finite set of symbols is denoted by ∑. Language A language is defined as a set of strings of symbols over an alphabet. Language of a Machine Set of all accepted strings of a machine is called language of a machine. Grammar Grammar is the set of rules that generates language. CHOMSKY HIERARCHY OF LANGUAGES Type 0-Language:-Unrestricted Language, Accepter:-Turing Machine, Generetor:-Unrestricted Grammar Type 1- Language:-Context Sensitive Language, Accepter:- Linear Bounded Automata, Generetor:-Context Sensitive Grammar Type 2- Language:-Context Free Language, Accepter:-Push Down Automata, Generetor:- Context Free Grammar Type 3- Language:-Regular Language, Accepter:- Finite Automata, Generetor:-Regular Grammar Finite Automata Finite Automata is generally of two types :(i)Deterministic Finite Automata (DFA)(ii)Non Deterministic Finite Automata(NFA) DFA DFA is represented formally by a 5-tuple (Q,Σ,δ,q0,F), where: Q is a finite set of states. Σ is a finite set of symbols, called the alphabet of the automaton. δ is the transition function, that is, δ: Q × Σ → Q. q0 is the start state, that is, the state of the automaton before any input has been processed, where q0 Q. F is a set of states of Q (i.e. F Q) called accept states or Final States 1. Construct a DFA that accepts set of all strings over ∑={0,1}, ending with 00 ? 1 0 A B S State/Input 0 1 1 A B A 0 B C A 1 * C C A C 0 2. Construct a DFA that accepts set of all strings over ∑={0,1}, not containing 101 as a substring ? 0 1 1 A B State/Input 0 1 S *A A B 0 *B C B 0 0,1 *C A R C R R R R 1 NFA NFA is represented formally by a 5-tuple (Q,Σ,δ,q0,F), where: Q is a finite set of states.
  • Cs 61A/Cs 98-52

    Cs 61A/Cs 98-52

    CS 61A/CS 98-52 Mehrdad Niknami University of California, Berkeley Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 1 / 23 Something like this? (Is this good?) def find(string, pattern): n= len(string) m= len(pattern) for i in range(n-m+ 1): is_match= True for j in range(m): if pattern[j] != string[i+ j] is_match= False break if is_match: return i What if you were looking for a pattern? Like an email address? Motivation How would you find a substring inside a string? Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 2 / 23 def find(string, pattern): n= len(string) m= len(pattern) for i in range(n-m+ 1): is_match= True for j in range(m): if pattern[j] != string[i+ j] is_match= False break if is_match: return i What if you were looking for a pattern? Like an email address? Motivation How would you find a substring inside a string? Something like this? (Is this good?) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 2 / 23 What if you were looking for a pattern? Like an email address? Motivation How would you find a substring inside a string? Something like this? (Is this good?) def find(string, pattern): n= len(string) m= len(pattern) for i in range(n-m+ 1): is_match= True for j in range(m): if pattern[j] != string[i+ j] is_match= False break if is_match: return i Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 2 / 23 Motivation How would you find a substring inside a string? Something like this? (Is this good?) def find(string, pattern): n= len(string) m= len(pattern) for i in range(n-m+ 1): is_match= True for j in range(m): if pattern[j] != string[i+
  • Regular Languages and Finite Automata for Part IA of the Computer Science Tripos

    Regular Languages and Finite Automata for Part IA of the Computer Science Tripos

    N Lecture Notes on Regular Languages and Finite Automata for Part IA of the Computer Science Tripos Prof. Andrew M. Pitts Cambridge University Computer Laboratory c 2012 A. M. Pitts Contents Learning Guide ii 1 Regular Expressions 1 1.1 Alphabets,strings,andlanguages . .......... 1 1.2 Patternmatching................................. .... 4 1.3 Somequestionsaboutlanguages . ....... 6 1.4 Exercises....................................... .. 8 2 Finite State Machines 11 2.1 Finiteautomata .................................. ... 11 2.2 Determinism, non-determinism, and ε-transitions. .. .. .. .. .. .. .. .. .. 14 2.3 Asubsetconstruction . .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..... 17 2.4 Summary ........................................ 20 2.5 Exercises....................................... .. 20 3 Regular Languages, I 23 3.1 Finiteautomatafromregularexpressions . ............ 23 3.2 Decidabilityofmatching . ...... 28 3.3 Exercises....................................... .. 30 4 Regular Languages, II 31 4.1 Regularexpressionsfromfiniteautomata . ........... 31 4.2 Anexample ....................................... 32 4.3 Complementand intersectionof regularlanguages . .............. 34 4.4 Exercises....................................... .. 36 5 The Pumping Lemma 39 5.1 ProvingthePumpingLemma . .... 40 5.2 UsingthePumpingLemma . ... 41 5.3 Decidabilityoflanguageequivalence . ........... 44 5.4 Exercises....................................... .. 45 6 Grammars 47 6.1 Context-freegrammars . ..... 47 6.2 Backus-NaurForm ................................
  • Parsing Based on N-Path Tree-Controlled Grammars

    Parsing Based on N-Path Tree-Controlled Grammars

    Theoretical and Applied Informatics ISSN 1896–5334 Vol.23 (2011), no. 3-4 pp. 213–228 DOI: 10.2478/v10179-011-0015-7 Parsing Based on n-Path Tree-Controlled Grammars MARTIN Cˇ ERMÁK,JIR͡ KOUTNÝ,ALEXANDER MEDUNA Formal Model Research Group Department of Information Systems Faculty of Information Technology Brno University of Technology Božetechovaˇ 2, 612 66 Brno, Czech Republic icermak, ikoutny, meduna@fit.vutbr.cz Received 15 November 2011, Revised 1 December 2011, Accepted 4 December 2011 Abstract: This paper discusses recently introduced kind of linguistically motivated restriction placed on tree-controlled grammars—context-free grammars with some root-to-leaf paths in their derivation trees restricted by a control language. We deal with restrictions placed on n ¸ 1 paths controlled by a deter- ministic context–free language, and we recall several basic properties of such a rewriting system. Then, we study the possibilities of corresponding parsing methods working in polynomial time and demonstrate that some non-context-free languages can be generated by this regulated rewriting model. Furthermore, we illustrate the syntax analysis of LL grammars with controlled paths. Finally, we briefly discuss how to base parsing methods on bottom-up syntax–analysis. Keywords: regulated rewriting, derivation tree, tree-controlled grammars, path-controlled grammars, parsing, n-path tree-controlled grammars 1. Introduction The investigation of context-free grammars with restricted derivation trees repre- sents an important trend in today’s formal language theory (see [3], [6], [10], [11], [12], [13] and [15]). In essence, these grammars generate their languages just like ordinary context-free grammars do, but their derivation trees have to satisfy some simple pre- scribed conditions.
  • Neural Edit Operations for Biological Sequences

    Neural Edit Operations for Biological Sequences

    Neural Edit Operations for Biological Sequences Satoshi Koide Keisuke Kawano Toyota Central R&D Labs. Toyota Central R&D Labs. [email protected] [email protected] Takuro Kutsuna Toyota Central R&D Labs. [email protected] Abstract The evolution of biological sequences, such as proteins or DNAs, is driven by the three basic edit operations: substitution, insertion, and deletion. Motivated by the recent progress of neural network models for biological tasks, we implement two neural network architectures that can treat such edit operations. The first proposal is the edit invariant neural networks, based on differentiable Needleman-Wunsch algorithms. The second is the use of deep CNNs with concatenations. Our analysis shows that CNNs can recognize regular expressions without Kleene star, and that deeper CNNs can recognize more complex regular expressions including the insertion/deletion of characters. The experimental results for the protein secondary structure prediction task suggest the importance of insertion/deletion. The test accuracy on the widely-used CB513 dataset is 71.5%, which is 1.2-points better than the current best result on non-ensemble models. 1 Introduction Neural networks are now used in many applications, not limited to classical fields such as image processing, speech recognition, and natural language processing. Bioinformatics is becoming an important application field of neural networks. These biological applications are often implemented as a supervised learning model that takes a biological string (such as DNA or protein) as an input, and outputs the corresponding label(s), such as a protein secondary structure [13, 14, 15, 18, 19, 23, 24, 26], protein contact maps [4, 8], and genome accessibility [12].
  • High-Performance Context-Free Parser for Polymorphic Malware Detection

    High-Performance Context-Free Parser for Polymorphic Malware Detection

    High-Performance Context-Free Parser for Polymorphic Malware Detection Young H. Cho and William H. Mangione-Smith The University of California, Los Angeles, CA 91311 {young, billms}@ee.ucla.edu http://cares.icsl.ucla.edu Abstract. Due to increasing economic damage from computer network intrusions, many routers have built-in firewalls that can classify packets based on header information. Such classification engine can be effective in stopping attacks that target protocol specific vulnerabilities. However, they are not able to detect worms that are encapsulated in the packet payload. One method used to detect such application-level attack is deep packet inspection. Unlike the most firewalls, a system with a deep packet inspection engine can search for one or more specific patterns in all parts of the packets. Although deep packet inspection increases the packet filtering effectiveness and accuracy, most of the current implementations do not extend beyond recognizing a set of predefined regular expressions. In this paper, we present an advanced inspection engine architecture that is capable of recognizing language structures described by context-free grammars. We begin by modifying a known regular expression engine to function as the lexical analyzer. Then we build an efficient multi-threaded parsing co-processor that processes the tokens from the lexical analyzer according to the grammar. 1 Introduction One effective method for detecting network attacks is called deep packet inspec- tion. Unlike the traditional firewall methods, deep packet inspection is designed to search and detect the entire packet for known attack signatures. However, due to high processing requirement, implementing such a detector using a general purpose processor is costly for 1+ gigabit network.
  • Context-Free Grammars

    Context-Free Grammars

    Chapter 3 Context-Free Grammars By Dr Zalmiyah Zakaria •Context-Free Grammars and Languages •Regular Grammars Formal Definition of Context-Free Grammars (CFG) A CFG can be formally defined by a quadruple of (V, , P, S) where: – V is a finite set of variables (non-terminal) – (the alphabet) is a finite set of terminal symbols , where V = – P is a finite set of rules (production rules) written as: A for A V, (v )*. – S is the start symbol, S V 2 Formal Definition of CFG • We can give a formal description to a particular CFG by specifying each of its four components, for example, G = ({S, A}, {0, 1}, P, S) where P consists of three rules: S → 0S1 S → A A → Sept2011 Theory of Computer Science 3 Context-Free Grammars • Terminal symbols – elements of the alphabet • Variables or non-terminals – additional symbols used in production rules • Variable S (start symbol) initiates the process of generating acceptable strings. 4 Terminal or Variable ? • S → (S) | S + S | S × S | A • A → 1 | 2 | 3 • The terminal symbols are { (, ), +, ×, 1, 2, 3} • The variable symbols are S and A Sept2011 Theory of Computer Science 5 Context-Free Grammars • A rule is an element of the set V (V )*. • An A rule: [A, w] or A w • A null rule or lambda rule: A 6 Context-Free Grammars • Grammars are used to generate strings of a language. • An A rule can be applied to the variable A whenever and wherever it occurs. • No limitation on applicability of a rule – it is context free 8 Context-Free Grammars • CFG have no restrictions on the right-hand side of production rules.
  • Theory of Computation

    Theory of Computation

    Theory of Computation Alexandre Duret-Lutz [email protected] September 10, 2010 ADL Theory of Computation 1 / 121 References Introduction to the Theory of Computation (Michael Sipser, 2005). Lecture notes from Pierre Wolper's course at http://www.montefiore.ulg.ac.be/~pw/cours/calc.html (The page is in French, but the lecture notes labelled chapitre 1 to chapitre 8 are in English). Elements of Automata Theory (Jacques Sakarovitch, 2009). Compilers: Principles, Techniques, and Tools (A. Aho, R. Sethi, J. Ullman, 2006). ADL Theory of Computation 2 / 121 Introduction What would be your reaction if someone came at you to explain he has invented a perpetual motion machine (i.e. a device that can sustain continuous motion without losing energy or matter)? You would probably laugh. Without looking at the machine, you know outright that such the device cannot sustain perpetual motion. Indeed the laws of thermodynamics demonstrate that perpetual motion devices cannot be created. We know beforehand, from scientic knowledge, that building such a machine is impossible. The ultimate goal of this course is to develop similar knowledge for computer programs. ADL Theory of Computation 3 / 121 Theory of Computation Theory of computation studies whether and how eciently problems can be solved using a program on a model of computation (abstractions of a computer). Computability theory deals with the whether, i.e., is a problem solvable for a given model. For instance a strong result we will learn is that the halting problem is not solvable by a Turing machine. Complexity theory deals with the how eciently.
  • Compiler Design

    Compiler Design

    CCOOMMPPIILLEERR DDEESSIIGGNN -- PPAARRSSEERR http://www.tutorialspoint.com/compiler_design/compiler_design_parser.htm Copyright © tutorialspoint.com In the previous chapter, we understood the basic concepts involved in parsing. In this chapter, we will learn the various types of parser construction methods available. Parsing can be defined as top-down or bottom-up based on how the parse-tree is constructed. Top-Down Parsing We have learnt in the last chapter that the top-down parsing technique parses the input, and starts constructing a parse tree from the root node gradually moving down to the leaf nodes. The types of top-down parsing are depicted below: Recursive Descent Parsing Recursive descent is a top-down parsing technique that constructs the parse tree from the top and the input is read from left to right. It uses procedures for every terminal and non-terminal entity. This parsing technique recursively parses the input to make a parse tree, which may or may not require back-tracking. But the grammar associated with it ifnotleftfactored cannot avoid back- tracking. A form of recursive-descent parsing that does not require any back-tracking is known as predictive parsing. This parsing technique is regarded recursive as it uses context-free grammar which is recursive in nature. Back-tracking Top- down parsers start from the root node startsymbol and match the input string against the production rules to replace them ifmatched. To understand this, take the following example of CFG: S → rXd | rZd X → oa | ea Z → ai For an input string: read, a top-down parser, will behave like this: It will start with S from the production rules and will match its yield to the left-most letter of the input, i.e.
  • A Representation-Based Approach to Connect Regular Grammar and Deep Learning

    A Representation-Based Approach to Connect Regular Grammar and Deep Learning

    The Pennsylvania State University The Graduate School A REPRESENTATION-BASED APPROACH TO CONNECT REGULAR GRAMMAR AND DEEP LEARNING A Dissertation in Information Sciences and Technology by Kaixuan Zhang ©2021 Kaixuan Zhang Submitted in Partial Fulfillment of the Requirements for the Degree of Doctor of Philosophy August 2021 The dissertation of Kaixuan Zhang was reviewed and approved by the following: C. Lee Giles Professor of College of Information Sciences and Technology Dissertation Adviser Chair of Committee Kenneth Huang Assistant Professor of College of Information Sciences and Technology Shomir Wilson Assistant Professor of College of Information Sciences and Technology Daniel Kifer Associate Professor of Department of Computer Science and Engineering Mary Beth Rosson Professor of Information Sciences and Technology Director of Graduate Programs, College of Information Sciences and Technology ii Abstract Formal language theory has brought amazing breakthroughs in many traditional areas, in- cluding control systems, compiler design, and model verification, and continues promoting these research directions. As recent years have witnessed that deep learning research brings the long-buried power of neural networks to the surface and has brought amazing break- throughs, it is crucial to revisit formal language theory from a new perspective. Specifically, investigation of the theoretical foundation, rather than a practical application of the con- necting point obviously warrants attention. On the other hand, as the spread of deep neural networks (DNN) continues to reach multifarious branches of research, it has been found that the mystery of these powerful models is equally impressive as their capability in learning tasks. Recent work has demonstrated the vulnerability of DNN classifiers constructed for many different learning tasks, which opens the discussion of adversarial machine learning and explainable artificial intelligence.
  • 6.035 Lecture 2, Specifying Languages with Regular Expressions and Context-Free Grammars

    6.035 Lecture 2, Specifying Languages with Regular Expressions and Context-Free Grammars

    MIT 6.035 Specifying Languages with Regular Expressions and Context-Free Grammars Martin Rinard Laboratory for Computer Science Massachusetts Institute of Technology Language Definition Problem • How to precisely define language • Layered struc ture of langua ge defifinitiition • Start with a set of letters in language • Lexical structurestructure - identifies “words ” in language (each word is a sequence of letters) • Syntactic sstructuretructure - identifies “sentences ” in language (each sentence is a sequence of words) • Semantics - meaning of program (specifies what result should be for each input) • Today’s topic: lexical and syntactic structures Specifying Formal Languages • Huge Triumph of Computer Science • Beautiful Theoretical Results • Practical Techniques and Applications • Two Dual Notions • Generative approach ((grammar or regular expression) • Recognition approach (automaton) • Lots of theorems about convertingconverting oonene approach automatically to another Specifying Lexical Structure Using Regular ExpressionsExpressions • Have some alphabet ∑ = set of letters • R egular expressions are bu ilt from: • ε -empty string • AAnyn yl lettere tte rf fromr oma alphabetlp ha be t ∑ •r1r2 – regular expression r1 followed by r2 (sequence) •r1| r2 – either regular expression r1 or r2 (choice) • r* - iterated sequence and choice ε | r | rr | … • Parentheses to indicate grouping/precedence Concept of Regular Expression Generating a StringString Rewrite regular expression until have only a sequence of letters (string) left Genera
  • Constraints for Membership in Formal Languages Under Systematic Search and Stochastic Local Search

    Constraints for Membership in Formal Languages Under Systematic Search and Stochastic Local Search

    Digital Comprehensive Summaries of Uppsala Dissertations from the Faculty of Science and Technology 1027 Constraints for Membership in Formal Languages under Systematic Search and Stochastic Local Search JUN HE ACTA UNIVERSITATIS UPSALIENSIS ISSN 1651-6214 ISBN 978-91-554-8617-4 UPPSALA urn:nbn:se:uu:diva-196347 2013 Dissertation presented at Uppsala University to be publicly examined in Room 2446, Polacksbacken, Lägerhyddsvägen 2D, Uppsala, Friday, April 26, 2013 at 13:00 for the degree of Doctor of Philosophy. The examination will be conducted in English. Abstract He, J. 2013. Constraints for Membership in Formal Languages under Systematic Search and Stochastic Local Search. Acta Universitatis Upsaliensis. Digital Comprehensive Summaries of Uppsala Dissertations from the Faculty of Science and Technology 1027. 74 pp. Uppsala. ISBN 978-91-554-8617-4. This thesis focuses on constraints for membership in formal languages under both the systematic search and stochastic local search approaches to constraint programming (CP). Such constraints are very useful in CP for the following three reasons: They provide a powerful tool for user- level extensibility of CP languages. They are very useful for modelling complex work shift regulation constraints, which exist in many shift scheduling problems. In the analysis, testing, and verification of string-manipulating programs, string constraints often arise. We show in this thesis that CP solvers with constraints for membership in formal languages are much more suitable than existing solvers used in tools that have to solve string constraints. In the stochastic local search approach to CP, we make the following two contributions: We introduce a stochastic method of maintaining violations for the regular constraint and extend our method to the automaton constraint with counters.