Deterministic Finite Automata And Regular Languagesvganesh/TEACHING/S2014/ECE351/lectures/DFA... · Finite Automaton Output . Costa Busch - LSU 3 Transition Graph initial state accepting

1

Deterministic Finite Automata And

Regular Languages

Costa Busch - LSU 2

Deterministic Finite Automaton (DFA)

Input Tape

“Accept” or “Reject”

String

Finite Automaton

Output

Costa Busch - LSU 3

Transition Graph

initial state

accepting state

state transition

0q 1q 2q 3q 4qa b b a

5qa a bb

ba,

ba,

Costa Busch - LSU 4


5qa a bb

ba,

ba,

},{ ba=Σ

For every state, there is a transition for every symbol in the alphabet

Alphabet

Costa Busch - LSU 5

Initial Configuration

1q 2q 3q 4qa b b a

5qa a bb

ba,Input String

a b b a

ba,

0q

Initial state

Input Tape head

Costa Busch - LSU 6

Scanning the Input


5qa a bb

ba,

a b b a

ba,

Costa Busch - LSU 7


5qa a bb

ba,

a b b a

ba,

Costa Busch - LSU 8


5qa a bb

ba,

a b b a

ba,

Costa Busch - LSU 9

0q 1q 2q 3q 4qa b b a accept

5qa a bb

ba,

a b b a

ba,

Input finished

Last state determines the outcome

Costa Busch - LSU 10

1q 2q 3q 4qa b b a

5qa a bb

ba,

a b a

ba,

0q

A Rejection Case

Input String



5qa a bb

ba,

a b a

ba,



5qa a bb

ba,

a b a

ba,



5qa a bb

ba,

reject

a b a

ba,

Input finished

Last state determines the outcome


1q 2q 3q 4qa b b a

5qa a bb

ba,

ba,

0q

)(λ

Another Rejection Case

Tape is empty

reject

Input Finished (no symbol read)


Language Accepted: { }abbaL =


5qa a bb

ba,

ba,

This automaton accepts only one string


To accept a string: all the input string is scanned and the last state is accepting

To reject a string:

all the input string is scanned and the last state is non-accepting


Another Example


5qa a bb

ba,

ba,

{ }abbaabL ,,λ=

Accept state

Accept state

Accept state


)(λEmpty Tape


5qa a bb

ba,

ba,

accept

Input Finished


Another Example

a

b ba,

ba,

0q 1q 2q

Accept state

trap state


a

b ba,

ba,

0q 1q 2q

a baInput String


a

b ba,

ba,

0q 1q 2q

a ba


a

b ba,

ba,

0q 1q 2q

a ba


a

b ba,

ba,

0q 1q 2q

a ba

accept

Input finished


a

b ba,

ba,

0q 1q 2q

ab b

A rejection case

Input String


a

b ba,

ba,

0q 1q 2q

ab b


a

b ba,

ba,

0q 1q 2q

ab b


a

b ba,

ba,

0q 1q 2q

ab b

reject

Input finished


Language Accepted: }0:{ ≥= nbaL n

a

b ba,

ba,

0q 1q 2q


Another Example

0q 1q

1

1

}1{=ΣAlphabet:

Language Accepted:

even} is and :{ * xxxEVEN Σ∈=

},111111,1111,11,{ …λ=


Formal Definition Deterministic Finite Automaton (DFA)

( )FqQM ,,,, 0δΣ=

QΣ

δ

0q

F

: set of states

: input alphabet

: transition function

: initial state

: set of accepting states

Σ∉λ


Set of States

Q


5qa a bb

ba,{ }543210 ,,,,, qqqqqqQ =

ba,

Example


Input Alphabet

Σ


5qa a bb

ba,{ }ba,=Σ

ba,

:the input alphabet never contains λΣ∉λ

Example


Initial State

0q

1q 2q 3q 4qa b b a

5qa a bb

ba,

ba,

0q

Example


Set of Accepting States

QF ⊆

0q 1q 2q 3qa b b a

5qa a bb

ba,{ }4qF =

ba,

4q

Example


Transition Function

QQ →Σ×:δ

q q ʹ′x

qxq ʹ′=),(δ

Describes the result of a transition from state with symbol q x


2q 3q 4qa b b a

5qa a bb

ba,

ba,

0q 1q

( ) 10, qaq =δExample:


( ) 50, qbq =δ

1q 2q 3q 4qa b b a

5qa a bb

ba,

ba,

0q



5qa a bb

ba,

ba,

( ) 32, qbq =δ


δ a b0q1q2q3q4q5q

1q 5q5q 2q5q 3q4q 5q


5qa a bb

ba,

ba,5q5q5q5q

Transition Table for st

ates

symbols

δ


Extended Transition Function QQ →Σ× ** :δ

qwq ʹ′=),(*δ

Describes the resulting state after scanning string from state w q


( ) 20* , qabq =δ

3q 4qa b b a

5qa a bb

ba,

ba,

0q 1q 2q

Example:


( ) 50* , qabbbaaq =δ

1q 2q 3q 4qa b b a

5qa a bb

ba,

ba,

0q


( ) 41* , qbbaq =δ


5qa a bb

ba,

ba,


Special case:

( ) qq =λδ ,*

for any state q


( ) qwq ʹ′=,*δ

q qʹ′w

q qʹ′kw σσσ 21=

1σ 2σ kσ

states may be repeated

In general:

implies that there is a walk of transitions


Language accepted by DFA :

Language Accepted by DFA

it is denoted as and contains all the strings accepted by

( )MLM

M

( )MLWe also say that recognizes M


For a DFA Language accepted by :

( )FqQM ,,,, 0δΣ=

M( ) ( ){ }FwqwML ∈Σ∈= ,: 0

** δ

0q qʹ′w Fq ∈ʹ′


Language rejected by :

( ) ( ){ }FwqwML ∉Σ∈= ,: 0** δ

M

0q qʹ′w Fq ∉ʹ′


0q

More DFA Examples

ba,

},{ ba=Σ

*)( Σ=ML

0q

ba,

}{)( =MLEmpty language All strings


0q

ba,

},{ ba=Σ

0q ba,

}{)( λ=MLLanguage of the empty string


( )ML = { all strings with prefix } ab

a b

ba,

0q 1q 2q

accept

ba,3q

ab

},{ ba=Σ


( )ML = { all binary strings containing substring } 001

λ 0 00 001

1

0

1

10

0 1,0


( )ML = { all binary strings without substring } 001

λ 0 00 001

1

0

110

0 1,0


{ }{ }*,:)( bawawaML ∈=

a

b

ba,

a

bb

a

0q 2q 3q

4q


Regular Languages Definition: A language is regular if there is a DFA that accepts it ( )

The languages accepted by all DFAs form the family of regular languages

LM LML =)(


{ }abba { }abbaab,,λ}0:{ ≥nban

{ all strings in {a,b}* with prefix } ab{ all binary strings without substring } 001

Example regular languages:

There exist DFAs that accept these languages (see previous slides).

{ }{ }*,: bawawa ∈

even} is and }1{:{ * xxx ∈

}{ }{λ *},{ ba


There exist languages which are not Regular:

}0:{ ≥= nbaL nn

There are no DFAs that accept these languages

(we will prove this in a later class)

}n ,1z,1y,1x :{ mn

kmzyxADDITION k

=+

====+=

Properties of Regular Languages


1L 2L

21LLConcatenation:

*1LStar:

21 LL ∪Union:

Are regular Languages

For regular languages and we will prove that:

1L

21 LL ∩

Complement:

Intersection:

RL1Reversal:


We say: Regular languages are closed under

21LLConcatenation:

*1LStar:

21 LL ∪Union:

1L

21 LL ∩

Complement:

Intersection:

RL1Reversal:


ab

ba

NFA

Equivalent NFA

λλ

ab

ba

A useful transformation: use one accept state

2 accept states

1 accept state


NFA

Equivalent NFA

Single accepting state

λλλ

In General


NFA without accepting state

Add an accepting state without transitions

Extreme case


1LRegular language

( ) 11 LML =

1M


NFA 2M

2L


( ) 22 LML =

Regular language

NFA

Take two languages


}{1 baL n=a

b

1M

{ }baL =2ab2M

0≥n

Example


Union NFA for

1M

2M

21 LL ∪

λ

λ


ab

ab

λ

λ

}{1 baL n=

}{2 baL =

}{}{21 babaLL n ∪=∪NFA for

Example


Concatenation NFA for 21LL

1M 2Mλ


NFA for

ab ab

}{1 baL n=}{2 baL =

}{}}{{21 bbaababaLL nn ==

λ

Example


Star Operation NFA for *1L

1M

λ

λ

*1L∈λλ λ

1

21

Lwwwww

i

k

∈

=


NFA for *}{*1 baL n=

ab

}{1 baL n=

λ

λ

λ

λ

Example


Reverse RL1

1MNFA for

ʹ′1M

1. Reverse all transitions

2. Make initial state accepting state and vice versa

1L


}{1 baL n=a

b

1M

}{1nR baL =

ab

ʹ′1M

Example


Complement

1. Take the DFA that accepts 1L

1M1L ʹ′1M1L

2. Make accepting states non-final, and vice-versa


}{1 baL n=

ab

1M

ba,

ba,

}{*},{1 babaL n−= a

b

ʹ′1M

ba,

ba,

Example


Intersection

1L regular

2L regular We show 21 LL ∩

regular


DeMorgan’s Law: 2121 LLLL ∪=∩

21 , LL regular

21 , LL regular

21 LL ∪ regular

21 LL ∪ regular

21 LL ∩ regular


Example

}{1 baL n=

},{2 baabL =

regular

regular }{21 abLL =∩

regular


1Lfor for 2LDFA 1M

DFA

2M

Construct a new DFA that accepts

Machine Machine

M 21 LL ∩

M simulates in parallel and 1M 2M

Another Proof for Intersection Closure


States in M

ji pq ,

1M 2MState in State in


1M 2M

1q 2qa

transition 1p 2pa

transition

DFA DFA

11, pq a

New transition

MDFA

22, pq


0q

initial state 0p

initial state

New initial state

00, pq

1M 2MDFA DFA

MDFA


iq

accept state

jp

accept states

New accept states

ji pq ,

kp

ki pq ,

1M 2MDFA DFA

MDFA

Both constituents must be accepting states


Example:

}{1 baL n=

ab

1M

0≥n

}{2mabL =

b

b

2M

0q 1q 0p 1p

0≥m

2q 2pa

a

ba, ba,

ba,


00, pq

Automaton for intersection

}{}{}{ ababbaL mn =∩=

10, pqa

21, pq

b

ab 11, pq

20, pq

a

12, pq

22, pq

b

ba,

a

b

ba,

b

a


M simulates in parallel and 1M 2M

M accepts string w if and only if:

accepts string w1Mand accepts string w2M

)()()( 21 MLMLML ∩=

Regular Expressions


Regular Expressions Regular expressions describe regular languages Example: describes the language

*)( cba ⋅+

{ } { },...,,,,,*, bcaabcaabcabca λ=


Recursive Definition αλ,,∅

( )11

21

21

*rrrrrr

⋅

+

Are regular expressions

Primitive regular expressions:

2r1rGiven regular expressions and


Examples

( ) )(* ∅+⋅⋅+ ccbaA regular expression:

( )++ baNot a regular expression:


Languages of Regular Expressions : language of regular expression Example

( )rL r

( ) { },...,,,,,*)( bcaabcaabcacbaL λ=⋅+


Definition For primitive regular expressions:

( )

( ) { }

( ) { }aaL

L

L

=

=

∅=∅

λλ


Definition (continued) For regular expressions and

1r 2r

( ) ( ) ( )2121 rLrLrrL ∪=+

( ) ( ) ( )2121 rLrLrrL =⋅

( ) ( )( )** 11 rLrL =

( )( ) ( )11 rLrL =


Example Regular expression: ( ) *aba ⋅+

( )( )*abaL ⋅+ ( )( ) ( )*aLbaL +=

( ) ( )*aLbaL +=

( ) ( )( ) ( )( )*aLbLaL ∪=

{ } { }( ) { }( )*aba ∪=

{ }{ },...,,,, aaaaaaba λ=

{ },...,,,...,,, baababaaaaaa=


Example Regular expression

( ) ( )bbabar ++= *

( ) { },...,,,,, bbbbaabbaabbarL =


Example Regular expression ( ) ( ) bbbaar **=

( ) }0,:{ 22 ≥= mnbbarL mn


Example Regular expression *)10(00*)10( ++=r

)(rL = { all strings containing substring 00 }


Example Regular expression )0(*)011( λ++=r

)(rL = { all strings without substring 00 }


Equivalent Regular Expressions Definition: Regular expressions and are equivalent if

1r 2r

)()( 21 rLrL =


Example L = { all strings without substring 00 }

)0(*)011(1 λ++=r

)0(*1)0(**)011*1(2 λλ +++=r

LrLrL == )()( 211r 2rand

are equivalent regular expressions

Regular Expressions and

Regular Languages


Theorem

Languages Generated by Regular Expressions

Regular Languages =



Regular Languages

⊆


Regular Languages

⊇

Proof:


Proof - Part 1

r)(rL

For any regular expression the language is regular


Regular Languages

⊆

Proof by induction on the size of r


Induction Basis Primitive Regular Expressions: αλ,,∅Corresponding NFAs

)()( 1 ∅=∅= LML

)(}{)( 2 λλ LML ==

)(}{)( 3 aLaML ==

regular languages

a


Inductive Hypothesis Suppose that for regular expressions and , and are regular languages

1r 2r)( 1rL )( 2rL


Inductive Step We will prove: ( )

( )

( )

( )( )1

1

21

21

*

rL

rL

rrL

rrL

⋅

+

Are regular Languages


By definition of regular expressions: ( ) ( ) ( )

( ) ( ) ( )

( ) ( )( )

( )( ) ( )11

11

2121

2121

**

rLrL

rLrL

rLrLrrL

rLrLrrL

=

=

=⋅

∪=+


)( 1rL )( 2rLBy inductive hypothesis we know: and are regular languages

Regular languages are closed under: ( ) ( )( ) ( )( )( )*1

21

21

rLrLrLrLrL ∪Union

Concatenation

Star

We also know:


Therefore:

( ) ( ) ( )

( ) ( ) ( )

( ) ( )( )** 11

2121

2121

rLrL

rLrLrrL

rLrLrrL

=

=⋅

∪=+

Are regular languages

)())(( 11 rLrL = is trivially a regular language (by induction hypothesis)

End of Proof-Part 1


Using the regular closure of these operations, we can construct recursively the NFA that accepts

M)()( rLML =

Example: 21 rrr +=)()( 11 rLML =

)()( 22 rLML =

)()( rLML =

λ

λ


For any regular language there is a regular expression with

Proof - Part 2


Regular Languages

⊇

Lr LrL =)(

We will convert an NFA that accepts to a regular expression

L


Since is regular, there is a NFA that accepts it

LM

LML =)(

Take it with a single accept state


From construct the equivalent Generalized Transition Graph in which transition labels are regular expressions

M

Example:

aba,

cM

a

ba +

c

Corresponding Generalized transition graph


Another Example:

ba +a

b

b0q 1q 2q

ba,a

b

b0q 1q 2q

b

bTransition labels are regular expressions


Reducing the states: ba +

ab

b0q 1q 2q

b

0q 2q

babb*

)(* babb +

Transition labels are regular expressions


Resulting Regular Expression:

0q 2q

babb*

)(* babb +

*)(**)*( bbabbabbr ⋅+⋅=

LMLrL == )()(


In General Removing a state:

iq q jqa b

cde

iq jq

dae* bce*dce*

bae*


0q fq

1r

2r

3r4r

*)*(* 213421 rrrrrrr +=

LMLrL == )()(

The resulting regular expression:

By repeating the process until two states are left, the resulting graph is

Initial graph Resulting graph

End of Proof-Part 2


Standard Representations of Regular Languages

Regular Languages

DFAs

NFAs Regular Expressions


When we say: We are given a Regular Language

We mean:

L

Language is in a standard representation

L

(DFA, NFA, or Regular Expression)

Documents

Deterministic Finite Automata And Regular Languagesvganesh/TEACHING/S2014/ECE351/lectures/DFA... · Finite Automaton Output . Costa Busch - LSU 3 Transition Graph initial state accepting