Regular Expressions. Definitions Equivalence to Finite Automata

Similar documents
Regular Expressions and Language Properties

DFA to Regular Expressions

This Lecture will Cover...

Automata and Formal Languages - CM0081 Finite Automata and Regular Expressions

Closure Properties of Regular Languages. Union, Intersection, Difference, Concatenation, Kleene Closure, Reversal, Homomorphism, Inverse Homomorphism

Sri vidya college of engineering and technology

Regular Languages. Problem Characterize those Languages recognized by Finite Automata.

CS 154, Lecture 3: DFA NFA, Regular Expressions

Finite Automata and Formal Languages

Lecture 2: Regular Expression

T (s, xa) = T (T (s, x), a). The language recognized by M, denoted L(M), is the set of strings accepted by M. That is,

Properties of Regular Languages. BBM Automata Theory and Formal Languages 1

CS 455/555: Finite automata

Introduction to the Theory of Computation. Automata 1VO + 1PS. Lecturer: Dr. Ana Sokolova.

Finite Automata and Formal Languages TMV026/DIT321 LP4 2012

Lecture 3: Nondeterministic Finite Automata

3515ICT: Theory of Computation. Regular languages

CS 154. Finite Automata, Nondeterminism, Regular Expressions

Inf2A: Converting from NFAs to DFAs and Closure Properties

Introduction to the Theory of Computation. Automata 1VO + 1PS. Lecturer: Dr. Ana Sokolova.

September 11, Second Part of Regular Expressions Equivalence with Finite Aut

Before we show how languages can be proven not regular, first, how would we show a language is regular?

Automata and Formal Languages - CM0081 Algebraic Laws for Regular Expressions

Deterministic Finite Automaton (DFA)

CS 154, Lecture 2: Finite Automata, Closure Properties Nondeterminism,

Computational Models Lecture 2 1

FORMAL LANGUAGES, AUTOMATA AND COMPUTABILITY

CS21 Decidability and Tractability

CS 121, Section 2. Week of September 16, 2013

Equivalence of Regular Expressions and FSMs

Languages. A language is a set of strings. String: A sequence of letters. Examples: cat, dog, house, Defined over an alphabet:

UNIT-II. NONDETERMINISTIC FINITE AUTOMATA WITH ε TRANSITIONS: SIGNIFICANCE. Use of ε-transitions. s t a r t. ε r. e g u l a r

Nondeterministic Finite Automata. Nondeterminism Subset Construction

Non-Deterministic Finite Automata

CS311 Computational Structures Regular Languages and Regular Expressions. Lecture 4. Andrew P. Black Andrew Tolmach

Lexical Analysis. DFA Minimization & Equivalence to Regular Expressions

UNIT II REGULAR LANGUAGES

Closure under the Regular Operations

Theory of computation: initial remarks (Chapter 11)

Finite Automata. BİL405 - Automata Theory and Formal Languages 1

Automata & languages. A primer on the Theory of Computation. Laurent Vanbever. ETH Zürich (D-ITET) September,

Automata Theory. Lecture on Discussion Course of CS120. Runzhe SJTU ACM CLASS

Computational Models Lecture 2 1

Regular expressions and Kleene s theorem

Foundations of

Concatenation. The concatenation of two languages L 1 and L 2

Chapter 6. Properties of Regular Languages

Regular Expressions [1] Regular Expressions. Regular expressions can be seen as a system of notations for denoting ɛ-nfa

The Pumping Lemma and Closure Properties

Parsing Regular Expressions and Regular Grammars

Recitation 2 - Non Deterministic Finite Automata (NFA) and Regular OctoberExpressions

Theory of Computation (I) Yijia Chen Fudan University

CSE443 Compilers. Dr. Carl Alphonce 343 Davis Hall

Nondeterministic finite automata

Formal Languages. We ll use the English language as a running example.

Chapter Five: Nondeterministic Finite Automata

Equivalence of DFAs and NFAs

Lecture 4 Nondeterministic Finite Accepters

Computational Theory

Regular Expression Unit 1 chapter 3. Unit 1: Chapter 3

UNIT-III REGULAR LANGUAGES

V Honors Theory of Computation

Harvard CS 121 and CSCI E-207 Lecture 10: CFLs: PDAs, Closure Properties, and Non-CFLs

CS 154. Finite Automata vs Regular Expressions, Non-Regular Languages

Properties of Regular Languages (2015/10/15)

Nondeterministic Finite Automata

TAFL 1 (ECS-403) Unit- II. 2.1 Regular Expression: The Operators of Regular Expressions: Building Regular Expressions

What we have done so far

FORMAL LANGUAGES, AUTOMATA AND COMPUTABILITY

Closure Properties of Context-Free Languages. Foundations of Computer Science Theory

Harvard CS 121 and CSCI E-207 Lecture 4: NFAs vs. DFAs, Closure Properties

Regular Expressions (Pre Lecture)

CMPSCI 250: Introduction to Computation. Lecture #22: From λ-nfa s to NFA s to DFA s David Mix Barrington 22 April 2013

CMSC 330: Organization of Programming Languages. Theory of Regular Expressions Finite Automata

Regular expressions and Kleene s theorem

CMPSCI 250: Introduction to Computation. Lecture #29: Proving Regular Language Identities David Mix Barrington 6 April 2012

Finite Automata Theory and Formal Languages TMV027/DIT321 LP4 2017

Let us first give some intuitive idea about a state of a system and state transitions before describing finite automata.

COMP4141 Theory of Computation

Finite Automata and Regular languages

HKN CS/ECE 374 Midterm 1 Review. Nathan Bleier and Mahir Morshed

How do regular expressions work? CMSC 330: Organization of Programming Languages

CS 530: Theory of Computation Based on Sipser (second edition): Notes on regular languages(version 1.1)

Automata and Formal Languages - CM0081 Non-Deterministic Finite Automata

Constructions on Finite Automata

Kleene Algebras and Algebraic Path Problems

Uses of finite automata

TDDD65 Introduction to the Theory of Computation

Computational Models: Class 3

Finite Automata Theory and Formal Languages TMV027/DIT321 LP4 2018

CS 154 Formal Languages and Computability Assignment #2 Solutions

Finite Automata and Regular Languages

Properties of Context-Free Languages. Closure Properties Decision Properties

Great Theoretical Ideas in Computer Science. Lecture 4: Deterministic Finite Automaton (DFA), Part 2

CS 301. Lecture 18 Decidable languages. Stephen Checkoway. April 2, 2018

Automata & languages. A primer on the Theory of Computation. Laurent Vanbever. ETH Zürich (D-ITET) September,

CSE 105 THEORY OF COMPUTATION

Clarifications from last time. This Lecture. Last Lecture. CMSC 330: Organization of Programming Languages. Finite Automata.

Formal Languages, Automata and Models of Computation

CS243, Logic and Computation Nondeterministic finite automata

Transcription:

Regular Expressions Definitions Equivalence to Finite Automata 1

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

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( ) =. 3

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

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 ε. 5

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

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

Equivalence of RE s and Automata For every RE R, L(R) is regular. Inductive argument For every regular language L, there is a regular expression R such that L(R) = L Show it through the finite automaton route 8

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

Form of ε-nfa s Constructed Start state: Only state with external predecessors No arcs from outside, no arcs leaving Final state: Only state with external successors 10

RE to ε-nfa: Basis Symbol a: ε: a ε : 11

RE to ε-nfa: Induction 1 Union ε For E 1 ε ε For E 2 ε For E 1 E 2 12

RE to ε-nfa: Induction 2 Concatenation ε For E 1 For E 2 For E 1 E 2 13

RE to ε-nfa: Induction 3 Closure ε ε For E ε ε For E* 14

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

k-paths A k-path is a path through the graph of the DFA that goes though no state numbered higher than k. Endpoints are not restricted; they can be any state. 16

Example: k-paths 1 1 2 0 0 0 1 1 3 0-paths from 2 to 3: RE for labels = 0. 1-paths from 2 to 3: RE for labels = 0+11. 2-paths from 2 to 3: RE for labels = (10)*0+1(01)*1 3-paths from 2 to 3: RE for labels =?? 17

k-path Induction Let R ijk be the regular expression for the set of labels of k-paths from state i to state j. Basis: k=0. R ij0 = sum of labels of arc from i to j. if no such arc. But add ε if i=j. 18

1 Example: Basis 1 2 0 0 0 1 1 3 R 120 = 0. R 110 = + ε = ε. 19

k-path Inductive Case A k-path from i to j either: 1. Never goes through state k, or 2. Goes through k one or more times. R ijk = R ij k-1 + R ik k-1 (R kk k-1 )* R kj k-1. Doesn t go through k Goes from i to k the first time Zero or more times from k to k Then, from k to j 20

Illustration of Induction i Paths not going through k k Path to k From k to k Several times j States < k From k to j 21

Final Step The RE with the same language as the DFA is the sum (union) of R ijn, where: 1. n is the number of states; i.e., paths are unconstrained. 2. i is the start state. 3. j is one of the final states. 22

1 R 233 =? R 232 =? R 332 =? R 233 =? Example 1 2 0 0 0 1 1 3 23

Summary Each of the three types of automata (DFA, NFA, ε-nfa) we discussed, and regular expressions as well, define exactly the same set of languages: the regular languages. 24

Algebraic Laws for RE s Union and concatenation behave sort of like addition and multiplication. + is commutative and associative; concatenation is associative. Concatenation distributes over +. Exception: Concatenation is not commutative. 25

Algebraic Laws for REs For regular expressions L,M,N L + M = M + L L (M N) = (LM) N L (M + N) = LM + LN (M + N) L = ML + NL L + L = L (L * ) * = L * * = ε * = ε 26

Identities and Annihilators is the identity for +. R + = R. ε is the identity for concatenation. εr = Rε = R. is the annihilator for concatenation. R = R =. 27

Closure Properties revisited Regular languages are closed under Union Intersection Complement Set Difference Concatenation Kleene Closure Reversal 28

Closure under reversal Let L be a regular language, expressed as a regular expression E. L(E) = L => L (E R ) = L R Let L be a language over Σ L R = {x Σ* such that x R L} Define inductively the reversal of a regular expression 29

Closure under reversal Define inductively the reversal of a regular expression Base case: ε, a Σ, : ε R, a R, R : ε, a, resp. Inductive step: Assume A R, A R are already defined (A + B) R = A R + B R (A B) R = B R A R (A*) R = (A R )* Claim: We have A and we have defined A R. Language defined by A R is the language for the reversal of A. 30