Properties of Regular Languages: Costas Busch - LSU 1

Properties of
Regular Languages
Costas Busch - LSU 1

For regular languages L1 and L2
we will prove that:
Union: L1  L2
Concatenation: L1L2
Star: L* Are regular
1
Languages
Reversal: LR
1
Complement: L1
Intersection: L1  L2
We say Regular languages are closed under
Union: L1  L2
Concatenation: L1L2
*
Star: L1
Reversal: LR
1
Complement: L1
Intersection: L1  L2
A useful transformation: use one accept state
NFA
a
b 2 accept states
a
b
Equivalent
a
NFA 1 accept state
a b
b 

In General
NFA
Equivalent NFA
 Single
 accepting

state
Extreme case
NFA without accepting state
Add an accepting state

without transitions

Take two languages
Regular language L1 Regular language L2
L M1   L1 L M 2   L2
NFA M1 NFA M2
Single accepting state Single accepting state

Example
M1
n0
a
n
L1  {a b} b
M2
a
L2   ba b

Union
NFA for L1  L2
M1
 M2
w  L1  L2 w  L1 or w  L2
Example
n
NFA for L1  L2  {a b}  {ba}
n
L1  {a b}
a
b

 L2  {ba}
b a
Concatenation
NFA for L1L2
change to
regular state
M1 M2

w  L1 L2 w  w1w2 : w1  L1 and w2  L2

Example
n n
NFA for L1L2  {a b}{ba}  {a bba}
n
L1  {a b}
a L2  {ba}
b  b a

Star Operation
NFA for L*
M
 change to
regular state
L( M )  L
w  w1w2  wk : wi  L
w L *
or w  
Example
*
NFA for L  {a b}
1
n *
n
L1  {a b}
a
 b

Reverse
R
NFA for L
M M
L( M )  L L( M )  LR
1. Reverse all transitions
2. Make the initial state accept state

and the accept state initial state
Example
M1
a
n
L1  {a b} b
M 1
a
L  {ba }
R
1
n
b

Complement
M M
L( M )  L L( M )  L
1. Take the DFA that accepts L
2. Make accept states regular

and vice-versa
Example
M1
a a, b
L1  {a b}
n b a, b
M 1
a a, b
L1  {a, b}  {a b}
* n
b a, b

NFAs cannot be used for complement
Make accept states regular
and vice-versa
NFA M NFA M 
L( M )  {} L( M )  { }  L( M )
L( M )    {a, b}
* * it is not the
complement

Same example with DFAs
Make accept states regular
and vice-versa
DFA M DFA M 
a, b a, b
L( M )  {} L( M )  {a, b}*  L( M )
L( M )    {a, b}
* * it is the
complement

Intersection
L1 regular
we show L1  L2
L2 regular regular

DeMorgan’s Law: L1  L2  L1  L2
L1 , L2 regular, regular
L1 , L2 regular, regular
L1  L2 regular
L1  L2 regular
L1  L2 regular
Example
n
L1  {a b} regular
L1  L2  {ab}
L2  {ab, ba} regular regular

Another Proof for Intersection Closure
Machine M1 Machine M2
DFA for L1 DFA for L2
Construct a new DFA M that accepts L1  L2
M simulates in parallel M1 and M 2

States in M
qi , p j
State in M1 State in M2

DFA M1 DFA M2
q1 a q2 p1 a p2
transition transition
DFA M
q1, p1 a q2 , p2
New transition
DFA M1 DFA M2
q0 p0
initial state initial state
DFA M
q0 , p0
New initial state
DFA M1 DFA M2
qi pj pk
accept state accept states
DFA M
qi , p j qi , pk
New accept states
Both constituents must be accepting states

Example:
n0 m0
L1  {a b} n m
L2  {ab }
M1 M2
a b
q0 b q1 p0 a p1
a, b b a
q2 p2
a, b a, b
DFA M for intersection
L( M )  {a nb}  {ab m }  {ab}

a, b
q0 , p0 a q0 , p1 b q1, p1 a q2 , p2
b a b a
q1, p2 b q0 , p2 q2 , p1
a b
a, b
Construction procedure for intersection
1. Build Initial State
2. For each new state and for each symbol

add transition to either an existing state
or create a new state and point to it
3. Repeat step 2 until no new states

are added
4. Designate accept states

Automaton for intersection
L  {a nb}  {ab m }  {ab}
q0 , p0
initial state

L  {a nb}  {ab m }  {ab}
q0 , p0 a q0 , p1
add transition and new state
M1 M2
for symbol a
q0 a q0 p0 a p1
q0 , p0 a q0 , p1

L  {a nb}  {ab m }  {ab}
q0 , p0 a q0 , p1
b M1 M2
q0 b q1 p0 b p2
q1, p2
add transition and new state M

for symbol b q0 , p0 b q1 , p2

L  {a nb}  {ab m }  {ab}
Repeat until no new states can be added a, b
q0 , p0 a q0 , p1 b q1, p1 a q2 , p2
b a b a
q1, p2 b q0 , p2 q2 , p1
a b
a, b

L  {a nb}  {ab m }  {ab}

q1 accept state for M 1
a, b
p1 accept state for M 2 add Accept state
q0 , p0 a q0 , p1 b q1, p1 a q2 , p2
b a b a
q1, p2 b q0 , p2 q2 , p1
a b
a, b

Intersection DFA M:
simulates in parallel M1 and M 2
accepts string w if and only if:

M1 accepts string w
and M 2 accepts string w
L ( M )  L ( M1 )  L ( M 2 )

Properties of Regular Languages: Costas Busch - LSU 1

Uploaded by

Document Information

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

Properties of Regular Languages: Costas Busch - LSU 1

Uploaded by

Copyright:

Available Formats

Properties of

Costas Busch - LSU 1

NFA without accepting state

Add an accepting state

Costas Busch - LSU 6

Regular language L1 Regular language L2

Single accepting state Single accepting state

Costas Busch - LSU 7

Costas Busch - LSU 8

Costas Busch - LSU 11

Costas Busch - LSU 12

1. Reverse all transitions

2. Make the initial state accept state

Costas Busch - LSU 16

1. Take the DFA that accepts L

2. Make accept states regular

Costas Busch - LSU 18

Costas Busch - LSU 19

Costas Busch - LSU 20

Costas Busch - LSU 21

Costas Busch - LSU 23

Construct a new DFA M that accepts L1  L2

M simulates in parallel M1 and M 2

Costas Busch - LSU 25

accept state accept states

New accept states

Both constituents must be accepting states

L( M )  {a nb}  {ab m }  {ab}

1. Build Initial State

2. For each new state and for each symbol

3. Repeat step 2 until no new states

4. Designate accept states

L  {a nb}  {ab m }  {ab}

Costas Busch - LSU 32

L  {a nb}  {ab m }  {ab}

Costas Busch - LSU 33

L  {a nb}  {ab m }  {ab}

add transition and new state M

Costas Busch - LSU 34

L  {a nb}  {ab m }  {ab}

Repeat until no new states can be added a, b

Costas Busch - LSU 35

L  {a nb}  {ab m }  {ab}

Costas Busch - LSU 36

simulates in parallel M1 and M 2

accepts string w if and only if:

You might also like