Lesson No.6 Naveen Z Quazilbash. Overview Attendance and lesson plan sharing Assignments Quiz (10 mins.). Some basic ideas about this course Regular Expressions.

Slides:



Advertisements
Similar presentations
CSC 361NFA vs. DFA1. CSC 361NFA vs. DFA2 NFAs vs. DFAs NFAs can be constructed from DFAs using transitions: Called NFA- Suppose M 1 accepts L 1, M 2 accepts.
Advertisements

Nondeterministic Finite Automata CS 130: Theory of Computation HMU textbook, Chapter 2 (Sec 2.3 & 2.5)
Regular Expressions and DFAs COP 3402 (Summer 2014)
1 Languages. 2 A language is a set of strings String: A sequence of letters Examples: “cat”, “dog”, “house”, … Defined over an alphabet: Languages.
1 Introduction to Computability Theory Lecture3: Regular Expressions Prof. Amos Israeli.
1 Introduction to Computability Theory Lecture4: Regular Expressions Prof. Amos Israeli.
1 Introduction to Computability Theory Lecture3: Regular Expressions Prof. Amos Israeli.
Costas Busch - RPI1 Single Final State for NFAs. Costas Busch - RPI2 Any NFA can be converted to an equivalent NFA with a single final state.
Courtesy Costas Busch - RPI1 Non Deterministic Automata.
Fall 2006Costas Busch - RPI1 Regular Expressions.
1 Regular Expressions. 2 Regular expressions describe regular languages Example: describes the language.
Lecture 3 Goals: Formal definition of NFA, acceptance of a string by an NFA, computation tree associated with a string. Algorithm to convert an NFA to.
CSC 3130: Automata theory and formal languages Andrej Bogdanov The Chinese University of Hong Kong Regular.
Fall 2004COMP 3351 Single Final State for NFA. Fall 2004COMP 3352 Any NFA can be converted to an equivalent NFA with a single final state.
1 Languages and Finite Automata or how to talk to machines...
1 Single Final State for NFAs and DFAs. 2 Observation Any Finite Automaton (NFA or DFA) can be converted to an equivalent NFA with a single final state.
Lecture 3 Goals: Formal definition of NFA, acceptance of a string by an NFA, computation tree associated with a string. Algorithm to convert an NFA to.
Fall 2006Costas Busch - RPI1 Non-Deterministic Finite Automata.
Definitions Equivalence to Finite Automata
Introduction to Finite Automata Adapted from the slides of Stanford CS154.
Costas Busch - LSU1 Non-Deterministic Finite Automata.
1 A Single Final State for Finite Accepters. 2 Observation Any Finite Accepter (NFA or DFA) can be converted to an equivalent NFA with a single final.
1 Regular Expressions Definitions Equivalence to Finite Automata.
Fall 2004COMP 3351 Regular Expressions. Fall 2004COMP 3352 Regular Expressions Regular expressions describe regular languages Example: describes the language.
Regular Expressions (RE) Empty set Φ A RE denotes the empty set Empty string λ A RE denotes the set {λ} Symbol a A RE denotes the set {a} Alternation M.
Regular Expressions. Notation to specify a language –Declarative –Sort of like a programming language. Fundamental in some languages like perl and applications.
1Computer Sciences Department. Book: INTRODUCTION TO THE THEORY OF COMPUTATION, SECOND EDITION, by: MICHAEL SIPSER Reference 3Computer Sciences Department.
Theory of Computation, Feodor F. Dragan, Kent State University 1 Regular expressions: definition An algebraic equivalent to finite automata. We can build.
Lecture 05: Theory of Automata:08 Kleene’s Theorem and NFA.
Regular Expressions Hopcroft, Motawi, Ullman, Chap 3.
Prof. Busch - LSU1 NFAs accept the Regular Languages.
CSCI 2670 Introduction to Theory of Computing September 1, 2005.
Lecture 5 Sept 06, 2012 Regular expressions – examples Converting DFA to regular expression. (same works for NFA to r.e. conversion.) Converting R.E. to.
Regular Expressions and Languages A regular expression is a notation to represent languages, i.e. a set of strings, where the set is either finite or contains.
CHAPTER 1 Regular Languages
CMSC 330: Organization of Programming Languages Theory of Regular Expressions Finite Automata.
CS 208: Computing Theory Assoc. Prof. Dr. Brahim Hnich Faculty of Computer Sciences Izmir University of Economics.
INHERENT LIMITATIONS OF COMPUTER PROGAMS CSci 4011.
Regular Expressions Costas Busch - LSU.
Chapter 3 Regular Expressions, Nondeterminism, and Kleene’s Theorem Copyright © 2011 The McGraw-Hill Companies, Inc. Permission required for reproduction.
1 Regular Expressions Definitions Equivalence to Finite Automata.
Overview of Previous Lesson(s) Over View  A token is a pair consisting of a token name and an optional attribute value.  A pattern is a description.
1 Language Recognition (11.4) Longin Jan Latecki Temple University Based on slides by Costas Busch from the courseCostas Busch
CS 154 Formal Languages and Computability February 11 Class Meeting Department of Computer Science San Jose State University Spring 2016 Instructor: Ron.
Conversions Regular Expression to FA FA to Regular Expression.
Regular Expressions CS 130: Theory of Computation HMU textbook, Chapter 3.
 2004 SDU Lecture4 Regular Expressions.  2004 SDU 2 Regular expressions A third way to view regular languages. Say that R is a regular expression if.
1 Introduction to the Theory of Computation Regular Expressions.
CSCI 2670 Introduction to Theory of Computing September 7, 2004.
CSCI 2670 Introduction to Theory of Computing September 11, 2007.
Complexity and Computability Theory I Lecture #5 Rina Zviel-Girshin Leah Epstein Winter
Deterministic Finite Automata Nondeterministic Finite Automata.
Finite automate.
Languages.
Non Deterministic Automata
Regular Expressions.
CSE 105 theory of computation
Formal Language & Automata Theory
Single Final State for NFA
Language Recognition (12.4)
Non-Deterministic Finite Automata
Non-Deterministic Finite Automata
Definitions Equivalence to Finite Automata
Definitions Equivalence to Finite Automata
CSCI 2670 Introduction to Theory of Computing
Subject Name: FORMAL LANGUAGES AND AUTOMATA THEORY
Language Recognition (12.4)
Definitions Equivalence to Finite Automata
Chapter 1 Regular Language
Presentation transcript:

Lesson No.6 Naveen Z Quazilbash

Overview Attendance and lesson plan sharing Assignments Quiz (10 mins.). Some basic ideas about this course Regular Expressions 10 mins. 5 mins. 45 mins.

Some Basic Concepts- revisited There are two main types of automata – Deterministic-Finite Automata: when there is an input symbol then after reading it, the automaton can jump only to one and only one another state. – Non-Deterministic Finite Automata: when there is an input symbol then after reading it, the automaton can jump to number of states. Three main classes of Automata are – Discrete – Continuous – Hybrid Some of the applications of automata are as in text processing, compilers, etc finite automata is used. In robotics automata is used widely as robots work itself when once they are set to start working. Theory of automata can be seen in many machines working around us in daily routine.

4 Regular Expressions Definitions Equivalence to Finite Automata

5 RE’s: Introduction Regular expressions are an algebraic way to describe languages. They describe exactly the regular languages. If E is a regular expression, then L(E) is the language it defines. We’ll describe RE’s and their languages recursively.

6 RE’s: Definition Basis 1: If a is any symbol, then a is a RE, and L(a) = {a}. – Note: {a} is the language containing one string, and that string is of length 1. Basis 2: ε is a RE, and L( ε ) = { ε }. Basis 3: ∅ is a RE, and L( ∅ ) = ∅.

7 RE’s: Definition – (2) Induction 1: If E 1 and E 2 are regular expressions, then E 1 +E 2 is a regular expression, and L(E 1 +E 2 ) = L(E 1 )  L(E 2 ). Induction 2: If E 1 and E 2 are regular expressions, then E 1 E 2 is a regular expression, and L(E 1 E 2 ) = L(E 1 )L(E 2 ). Concatenation : the set of strings wx such that w Is in L(E 1 ) and x is in L(E 2 ).

8 RE’s: Definition – (3) Induction 3: If E is a RE, then E* is a RE, and L(E*) = (L(E))*. Closure, or “Kleene closure” = set of strings w 1 w 2 …w n, for some n > 0, where each w i is in L(E). Note: when n=0, the string is ε.

9 Precedence of Operators Parentheses may be used wherever needed to influence the grouping of operators. Order of precedence is * (highest), then concatenation, then + (lowest).

10 Examples: RE’s L(01) = {01}. L(01+0) = {01, 0}. L(0(1+0)) = {01, 00}. – Note order of precedence of operators. L(0*) = { ε, 0, 00, 000,… }. L((0+10)*( ε +1)) = all strings of 0’s and 1’s without two consecutive 1’s.

11 Equivalence of RE’s and Automata We need to show that for every RE, there is an automaton that accepts the same language. – Pick the most powerful automaton type: the ε - NFA. And we need to show that for every automaton, there is a RE defining its language. – Pick the most restrictive type: the DFA.

12 Converting a RE to an ε -NFA Proof is an induction on the number of operators (+, concatenation, *) in the RE. We always construct an automaton of a special form (next slide).

13 Form of ε -NFA’s Constructed No arcs from outside, no arcs leaving Start state: Only state with external predecessors “Final” state: Only state with external successors

14 RE to ε -NFA: Basis Symbol a: ε : ∅ : a ε

15 RE to ε -NFA: Induction 1 – Union For E 1 For E 2 For E 1  E 2 ε εε ε

16 RE to ε -NFA: Induction 2 – Concatenation For E 1 For E 2 For E 1 E 2 ε

17 RE to ε -NFA: Induction 3 – Closure For E For E* ε ε εε

18 DFA-to-RE A strange sort of induction. States of the DFA are assumed to be 1,2,…,n. We construct RE’s for the labels of restricted sets of paths. – Basis: single arcs or no arc at all. – Induction: paths that are allowed to traverse next state in order.