DOCSLIB.ORG

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

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
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. To improve the usage of constraints for which there exists no known constant-time algorithm for neighbour evaluation, we introduce a framework of using solution neighbourhoods, and give an efficient algorithm of constructing a solution neighbourhood for the regular constraint. In the systematic search approach to CP, we make the following two contributions: We show that there may be unwanted consequences when using a propagator that may underestimate a cost of a soft constraint, as the propagator may guide the search to incorrect (non-optimum) solutions to an over-constrained problem. We introduce and compare several propagators that compute correctly the cost of the edit-distance based soft- regular constraint. We show that the context-free grammar constraint is useful and introduce an improved propagator for it. Keywords: constraint programming, regular constraint, automaton constraint, context-free grammar constraint, solution neighbourhood, counter automaton Jun He, Uppsala University, Department of Information Technology, Computing Science, Box 337, SE-751 05 Uppsala, Sweden. © Jun He 2013 ISSN 1651-6214 ISBN 978-91-554-8617-4 urn:nbn:se:uu:diva-196347 (http://urn.kb.se/resolve?urn=urn:nbn:se:uu:diva-196347) To my family Acknowledgements First and foremost I would like to thank my supervisors Professor Pierre Flener and Associate Professor Justin Pearson for their invaluable support and super- vision during my PhD research. Thank you for providing me with the opportu- nity to work with you and for always giving me numerous encouragement and patient guidance, without which I could not have achieved the research goals. I also appreciate your tremendous effort to teach me how to write scientific papers and your comments on drafts of this thesis. I would like to thank Professor Weiming Zhang for involving me with the PhD programme of the National University of Defense Technology (NUDT) of China and for supporting me to apply for a PhD scholarship from the China Scholarship Council (CSC). Thanks also to Professor Xianqing Yi for his su- pervision during my master programme at NUDT. I am grateful to Dr Magnus Ågren, Dr Serdar Kadioglu,ˇ and Dr Toni Mancini for their help and useful discussions in some aspects of my research. Thanks to Dr George Katsirelos for some useful discussions on the CFG con- straint. Thanks to Assistant Professor Willem-Jan van Hoeve and Associate Professor Louis-Martin Rousseau for some useful discussions on the edit- distance based SOFTREGULAR constraint. Thanks to Associate Professor Xi- ang Fu, Dr Adam Kiezun,˙ and Dr Prateek Saxena for some useful discussions on SUSHI,HAMPI, and KALUZA respectively. I enjoyed working in the ASTRA group on constraint programming. I would like to thank Karl Sundequist for helping me to write the Swedish sum- mary of this thesis. Thanks to Farshid Hassani Bijarbooneh for some useful discussions on COMET and GECODE, and for kindly sharing with me an apart- ment and some delicious Persian food in 2010. Thanks to Loïc Blet for proof- reading one of my COMET programs. Thanks also to Dr Jean-Noël Monette, Joseph Scott, María Andreína Francisco Rodríguez, and Farshid Hassani Bi- jarbooneh for presenting some interesting papers and sharing some delicious cookies in the ASTRA journal club. Special thanks to CSC and NUDT for providing me with financial support during my PhD research. Thanks to Associate Professor Lars-Henrik Eriksson and the Computing Science Division (CSD) for kindly providing me with fi- nancial support after the expiration of my Chinese scholarship and for offering me an English course, and thanks to Maria Njoo for teaching me. Thanks to Ulrika Andersson and Anne-Marie Jalstrand at the IT department for their help and support. Thanks also to Mr Rui Fan and Mr Wei Wang at the Education Section of the Chinese Embassy in Sweden for their help and support. I would like to thank the Association for Constraint Programming (ACP) for giving me financial support to attend the ACP summer schools 2010 and 2011 and the CP 2009 conference. Thanks also to the ACM Special Interest Group on Applied Computing (SIGAPP) for giving me a student travel award to attend the ACM SAC 2012 conference. I would also like to thank Professor Wang Yi for his encouragement and help. Special thanks to Minpeng Zhu. Thank you for always being a good listener and joining me with lunch. Thanks to Nan Guan for always being a big brother with numerous encouragementand suggestion. I am grateful to the Chinese student community at house one of the IT department: Minpeng Zhu, Nan Guan, Cheng Xu, Ran Ji, Xiaoyue Pan, Ping Lu, and Yunyun Zhu. Thank you for inviting me to many interesting games and parties with delicious Chi- nese food. Thanks also to my NUDT colleagues: Jinping Yuan, Longming Dong, Lidong Cheng, Xin Lu, Chaofang Zhang, Haining Wang, and Fei Cai for their help and encouragement. Last, but not least, I would like to thank my parents, my wife, and my son for all their love and support. Without your encouragement and understanding, it would be impossible for me to finish this thesis. List of papers This thesis is based on the following papers, which are referred to in the text by their Roman numerals. I Jun He, Pierre Flener, and Justin Pearson. An automaton Constraint for Local Search. Fundamenta Informaticae, 107(2–3):223–248, 2011. An early version is published in Electronic Proceedings in Theoretical Computer Science, 5:13–25, 2009, and is then also published in Proceedings of RCRA’09, the 16th RCRA International Workshop on Experimental Evaluation of Algorithms for Solving Problems with Combinatorial Explosion. II Jun He, Pierre Flener, and Justin Pearson. Solution Neighbourhoods for Constraint-Directed Local Search. In: S. Bistarelli, E. Monfroy, and B. O’Sullivan (editors), Proceedings of SAC/CSP’12, the track on Constraint Solving and Programming of the 27th ACM Symposium on Applied Computing, pages 74–79. ACM Press, 2012. III Jun He, Pierre Flener, and Justin Pearson. Underestimating the Cost of a Soft Constraint is Dangerous: Revisiting the Edit-Distance Based Soft Regular Constraint. Accepted under minor revisions in Journal of Heuristics. IV Jun He, Pierre Flener, and Justin Pearson. Solving String Constraints: The Case for Constraint Programming. Submitted to a conference. Reprints were made with permission from the publishers. Papers I, II and IV are verbatim copies of the original papers but are reformatted to the one- column format of this thesis. Comments on my Participation Paper I: I am the principal author of this paper. I proposed the ideas, designed the algorithms, performed the experiments, and participated in writing the paper. My supervisors contributed to the discussions. Paper II: I am the principal author of this paper. I proposed the ideas, designed the algorithms, performed the experiments, and was the lead writer of the paper. My supervisors contributed to the discussions. Paper III: I am the principal author of this paper. I proposed the ideas, de- signed the algorithms, performed the experiments, and was the lead writer of the paper. My supervisors contributed to the discussions. Paper IV: I am the principal author of this paper. I proposed the ideas, de- signed the algorithms, performed the experiments, and was the lead writer of the paper. My supervisors contributed to the discussions and wrote the intro- duction and conclusion of the paper. Summary in Swedish Constraint Programming (CP, e.g., se [2]) är en hög nivå deklarativa paradigm som använder en uppsättning villkor för att modellera och lösa kombinatoriska problem. Om en CP språk saknar ett villkor som gör det möjligt att formulera en viss modell av ett kombinatoriskt problem, så har modelleraren traditionellt tre val enligt följande: 1. att byta till ett annat CP språk som har alla nödvändiga villkor; 2. att formulera en annan modell som inte kräver de saknade villkoren; 3. att implementera de saknade villkoren i det låg-nivå språk valt av CP språket. Det första alternativet är ofta omöjligt i praktiken, eftersom det inte nöd- vändigtvis finns någon CP språk som innehåller alla nödvändiga villkor; det andra alternativet kan vara svårt eller göra så att problemet löses ineffektivt.
Load more

Recommended publications
  • Synchronizing Deterministic Push-Down Automata Can
    Synchronizing Deterministic Push-Down Automata Can Be Really Hard Henning Fernau Universität Trier, Fachbereich IV, Informatikwissenschaften, 54296 Trier, Germany [email protected] Petra Wolf Universität Trier, Fachbereich IV, Informatikwissenschaften, 54296 Trier, Germany https://www.wolfp.net/ [email protected] Tomoyuki Yamakami University of Fukui, Faculty of Engineering, 3-9-1 Bunkyo, Fukui 910-8507, Japan [email protected] Abstract The question if a deterministic finite automaton admits a software reset in the form of a so- called synchronizing word can be answered in polynomial time. In this paper, we extend this algorithmic question to deterministic automata beyond finite automata. We prove that the question of synchronizability becomes undecidable even when looking at deterministic one-counter automata. This is also true for another classical mild extension of regularity, namely that of deterministic one-turn push-down automata. However, when we combine both restrictions, we arrive at scenarios with a PSPACE-complete (and hence decidable) synchronizability problem. Likewise, we arrive at a decidable synchronizability problem for (partially) blind deterministic counter automata. There are several interpretations of what synchronizability should mean for deterministic push- down automata. This is depending on the role of the stack: should it be empty on synchronization, should it be always the same or is it arbitrary? For the automata classes studied in this paper, the complexity or decidability status of the synchronizability
    [Show full text]
  • 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.
    [Show full text]
  • 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+
    [Show full text]
  • 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 ................................
    [Show full text]
  • How to Go Beyond Turing with P Automata: Time Travels, Regular Observer Ω-Languages, and Partial Adult Halting
    How to Go Beyond Turing with P Automata: Time Travels, Regular Observer !-Languages, and Partial Adult Halting Rudolf Freund1, Sergiu Ivanov2, and Ludwig Staiger3 1 Technische Universit¨atWien, Austria Email: [email protected] 2 Universit´eParis Est, France Email: [email protected] 3 Martin-Luther-Universit¨atHalle-Wittenberg, Germany Email: [email protected] Summary. In this paper we investigate several variants of P automata having infinite runs on finite inputs. By imposing specific conditions on the infinite evolution of the systems, it is easy to find ways for going beyond Turing if we are watching the behavior of the systems on infinite runs. As specific variants we introduce a new halting variant for P automata which we call partial adult halting with the meaning that a specific predefined part of the P automaton does not change any more from some moment on during the infinite run. In a more general way, we can assign !-languages as observer languages to the infinite runs of a P automaton. Specific variants of regular !-languages then, for example, characterize the red-green P automata. 1 Introduction Various possibilities how one can \go beyond Turing" are discussed in [11], for example, the definitions and results for red-green Turing machines can be found there. In [2] the notion of red-green automata for register machines with input strings given on an input tape (often also called counter automata) was introduced and the concept of red-green P automata for several specific models of membrane systems was explained. Via red-green counter automata, the results for acceptance and recognizability of finite strings by red-green Turing machines were carried over to red-green P automata.
    [Show full text]
  • 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].
    [Show full text]
  • 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.
    [Show full text]
  • 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.
    [Show full text]
  • 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.
    [Show full text]
  • 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
    [Show full text]
  • CIT 425- AUTOMATA THEORY, COMPUTABILITY and FORMAL LANGUAGES LECTURE NOTE by DR. OYELAMI M. O. Introduction • This Course Cons
    CIT 425- AUTOMATA THEORY, COMPUTABILITY AND FORMAL LANGUAGES LECTURE NOTE BY DR. OYELAMI M. O. Status: Core Description: Words and String. Concatenation, word Length; Language Definition. Regular Expression, Regular Language, Recursive Languages; Finite State Automata (FSA), State Diagrams; Pumping Lemma, Grammars, Applications in Computer Science and Engineering, Compiler Specification and Design, Text Editor and Implementation, Very Large Scale Integrated (VLSI) Circuit Specification and Design, Natural Language Processing (NLP) and Embedded Systems. Introduction This course constitutes the theoretical foundation of computer science. Loosely speaking we can think of automata, grammars, and computability as the study of what can be done by computers in principle, while complexity addresses what can be done in practice. This course has applications in the following areas: o Digital design, o Programming languages o Compilers construction Languages Dictionaries define the term informally as a system suitable for the expression of certain ideas, facts, or concepts, including a set of symbols and rules for their manipulation. While this gives us an intuitive idea of what a language is, it is not sufficient as a definition for the study of formal languages. We need a precise definition for the term. A formal language is an abstraction of the general characteristics of programming languages. Languages can be specified in various ways. One way is to list all the words in the language. Another is to give some criteria that a word must satisfy to be in the language. Another important way is to specify a language through the use of some terminologies: 1 Alphabet: A finite, nonempty set Σ of symbols.
    [Show full text]
  • 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 2010 A. M. Pitts First Edition 1998. Revised 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010. Contents Learning Guide ii 1 Regular Expressions 1 1.1 Alphabets, strings, and languages . ...... 1 1.2 Patternmatching ................................ 4 1.3 Some questions about languages . ... 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 Finite automata from regular expressions . ........ 23 3.2 Decidabilityofmatching . 28 3.3 Exercises .................................... 30 4 Regular Languages, II 31 4.1 Regular expressions from finite automata . ..... 31 4.2 Anexample ................................... 32 4.3 Complement and intersection of regular languages . ......... 34 4.4 Exercises .................................... 36 5 The Pumping Lemma 39 5.1 ProvingthePumpingLemma. 40 5.2 UsingthePumpingLemma.. .... .... ..... .... .... .... 41 5.3 Decidability of language equivalence . ....... 44 5.4 Exercises .................................... 45 6 Grammars 47 6.1 Context-freegrammars . 47 6.2 Backus-NaurForm ..............................
    [Show full text]