Regular Expressions: Reading: Chapter 3

Regular Expressions
Reading: Chapter 3
Regular Expressions vs. Finite

Automata
Offers a declarative way to express the pattern of any

string we want to accept
E.g., 01*+ 10*
Automata => more machine-like

< input: string , output: [accept/reject] >
Regular expressions => more program syntax-like
Unix environments heavily use regular expressions
E.g., bash shell, grep, vi & other editors, sed
Perl scripting good for string processing

Lexical analyzers such as Lex or Flex
2
Regular Expressions
Regular
expressions
Finite Automata
(DFA, NFA, -NFA)
Syntactical
expressions
Automata/machines
Regular
Languages
Formal language
classes
3
Language Operators
Union of two languages:
L U M = all strings that are either in L or M

Note: A union of two languages produces a third
language
Concatenation of two languages:
L . M = all strings that are of the form xy

s.t., x L and y M
The dot operator is usually omitted
i.e., LM is same as L.M

4
i here refers to how many strings to concatenate from the parent

language L to produce strings in the language Li
Kleene Closure (the * operator)
Kleene Closure of a given language L:
L0= {}
L1= {w | for some w L}
L2= { w1w2 | w1 L, w2 L (duplicates allowed)}
Li= { w1w2wi | all ws chosen are L (duplicates allowed)}
(Note: the choice of each wi is independent)
L* = Ui0 Li (arbitrary number of concatenations)
Example:
Let L = { 1, 00}
L0= {}
L1= {1,00}
L2= {11,100,001,0000}
L3= {111,1100,1001,10000,000000,00001,00100,0011}
L* = L0 U L1 U L2 U
5
Kleene Closure (special notes)
L* is an infinite set iff |L|1 and L{}

If L={}, then L* = {} Why?
Why?
If L = , then L* = {}
* denotes the set of all words over an

alphabet
Therefore, an abbreviated way of saying

there is an arbitrary language L over an
alphabet is:
L *
Why?
Building Regular Expressions
Let E be a regular expression and the

language represented by E is L(E)
Then:
(E) = E
L(E + F) = L(E) U L(F)
L(E F) = L(E) L(F)
L(E*) = (L(E))*
Example: how to use these regular

expression properties and language
operators?
L = { w | w is a binary string which does not contain two consecutive 0s or

two consecutive 1s anywhere)
Goal: Build a regular expression for L

Four cases for w:
Case A:
Case B:
Case C:
Case D:
(01)*
(10)*
0(10)*
1(01)*
Since L is the union of all 4 cases:
Case A: w starts with 0 and |w| is even

Case B: w starts with 1 and |w| is even
Case C: w starts with 0 and |w| is odd
Case D: w starts with 1 and |w| is odd
Regular expression for the four cases:
E.g., w = 01010101 is in L, while w = 10010 is not in L
Reg Exp for L = (01)* + (10)* + 0(10)* + 1(01)*
If we introduce then the regular expression can be simplified to:
Reg Exp for L = ( +1)(01)*( +0)
Precedence of Operators
Highest to lowest
* operator (star)
(concatenation)
+ operator
Example:
01* + 1 = ( 0 . ((1)*) ) + 1
9
Finite Automata (FA) & Regular

Expressions (Reg Ex)
To show that they are interchangeable,

consider the following theorems:
Proofs
in the book
Theorem 1: For every DFA A there exists a regular

expression R such that L(R)=L(A)
Theorem 2: For every regular expression R there
exists an -NFA E such that L(E)=L(R)
-NFA
NFA
Kleene Theorem
Theorem 2
Reg Ex
DFA
Theorem 1
10
DFA
Theorem 1
Reg Ex
DFA to RE construction
Informally, trace all distinct paths (traversing cycles only once)
from the start state to each of the final states
and enumerate all the expressions along the way
Example:
1
q0
(1*) 0
1*
0,1
0
q1
q2
(0*) 1
(0 + 1)*
(0+1)*
00*
Q) What is the language?

1*00*1(0+1)*
11
Reg Ex
-NFA
Theorem 2
RE to -NFA construction
(0+1)*01(0+1)*
Example:
(0+1)*
01
(0+1)*
12
Algebraic Laws of Regular

Expressions
Commutative:
Associative:
(E+F)+G = E+(F+G)
(EF)G = E(FG)
Identity:
E+F = F+E
E+ = E
E=E=E
Annihilator:
E = E =
13
Algebraic Laws
Distributive:
E(F+G) = EF + EG
(F+G)E = FE+GE
Idempotent: E + E = E
Involving Kleene closures:
(E*)* = E*
* =
* =
E+ =EE*
E?
= +E
14
True or False?
Let R and S be two regular expressions. Then:
1.
((R*)*)* = R*
2.
(R+S)* = R* + S*
3.
(RS + R)* RS = (RR*S)*
15
Summary
Regular expressions
Equivalence to finite automata
DFA to regular expression conversion
Regular expression to -NFA conversion
Algebraic laws of regular expressions
Unix regular expressions and Lexical
Analyzer
16

Regular Expressions: Reading: Chapter 3

Uploaded by

Copyright:

Available Formats

Regular Expressions: Reading: Chapter 3

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Regular Expressions: Reading: Chapter 3

Uploaded by

Copyright:

Available Formats

Regular Expressions

Regular Expressions vs. Finite

Offers a declarative way to express the pattern of any

E.g., 01*+ 10*

Automata => more machine-like

Regular expressions => more program syntax-like

Unix environments heavily use regular expressions

E.g., bash shell, grep, vi & other editors, sed

Perl scripting good for string processing

Union of two languages:

L U M = all strings that are either in L or M

Concatenation of two languages:

L . M = all strings that are of the form xy

i.e., LM is same as L.M

i here refers to how many strings to concatenate from the parent

Kleene Closure (the * operator)

Kleene Closure of a given language L:

L1= {w | for some w L}

L2= { w1w2 | w1 L, w2 L (duplicates allowed)}

Li= { w1w2wi | all ws chosen are L (duplicates allowed)}

(Note: the choice of each wi is independent)

L* = Ui0 Li (arbitrary number of concatenations)

Kleene Closure (special notes)

L* is an infinite set iff |L|1 and L{}

* denotes the set of all words over an

Therefore, an abbreviated way of saying

Building Regular Expressions

Let E be a regular expression and the

Example: how to use these regular

L = { w | w is a binary string which does not contain two consecutive 0s or

Goal: Build a regular expression for L

Since L is the union of all 4 cases:

Case A: w starts with 0 and |w| is even

Regular expression for the four cases:

E.g., w = 01010101 is in L, while w = 10010 is not in L

Reg Exp for L = (01)* + (10)* + 0(10)* + 1(01)*

If we introduce then the regular expression can be simplified to:

Reg Exp for L = ( +1)(01)*( +0)

Finite Automata (FA) & Regular

To show that they are interchangeable,

Theorem 1: For every DFA A there exists a regular

Q) What is the language?

Algebraic Laws of Regular

(RS + R)* RS = (RR*S)*

You might also like

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

E.g., 01+ 10

(RS + R)* RS = (RRS)