Deterministic Finite Automata And Regular Languagesvganesh/TEACHING/S2014/ECE351/lectures/DFA... ·...

transcript

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

Costa Busch - LSU 4

5qa a bb

},{ 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

Initial state

Input Tape head

Costa Busch - LSU 6

Scanning the Input

5qa a bb

a b b a

Costa Busch - LSU 7

5qa a bb

a b b a

Costa Busch - LSU 8

5qa a bb

a b b a

Costa Busch - LSU 9

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

5qa a bb

a b b a

Input finished

Last state determines the outcome

Costa Busch - LSU 10

1q 2q 3q 4qa b b a

5qa a bb

A Rejection Case

Input String

5qa a bb

reject

Input finished

Last state determines the outcome

1q 2q 3q 4qa b b a

5qa a bb

Another Rejection Case

Tape is empty

reject

Input Finished (no symbol read)

Language Accepted: { }abbaL =

5qa a bb

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

{ }abbaabL ,,λ=

Accept state

)(λEmpty Tape

5qa a bb

accept

Input Finished

Another Example

0q 1q 2q

Accept state

trap state

0q 1q 2q

a baInput String

0q 1q 2q

accept

Input finished

0q 1q 2q

A rejection case

Input String

0q 1q 2q

reject

Input finished

Language Accepted: }0:{ ≥= nbaL n

0q 1q 2q

Another Example

}1{=ΣAlphabet:

Language Accepted:

even} is and :{ * xxxEVEN Σ∈=

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

Formal Definition Deterministic Finite Automaton (DFA)

( )FqQM ,,,, 0δΣ=

: set of states

: input alphabet

: transition function

: initial state

: set of accepting states

Σ∉λ

Set of States

5qa a bb

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

Example

Input Alphabet

5qa a bb

ba,{ }ba,=Σ

:the input alphabet never contains λΣ∉λ

Example

Initial State

1q 2q 3q 4qa b b a

5qa a bb

Example

Set of Accepting States

QF ⊆

0q 1q 2q 3qa b b a

5qa a bb

ba,{ }4qF =

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

( ) 10, qaq =δExample:

( ) 50, qbq =δ

1q 2q 3q 4qa b b a

5qa a bb

( ) 32, qbq =δ

δ a b0q1q2q3q4q5q

1q 5q5q 2q5q 3q4q 5q

5qa a bb

ba,5q5q5q5q

Transition Table for st

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

0q 1q 2q

Example:

( ) 50* , qabbbaaq =δ

1q 2q 3q 4qa b b a

5qa a bb

( ) 41* , qbbaq =δ

5qa a bb

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

( )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** δ

0q qʹ′w Fq ∉ʹ′

More DFA Examples

},{ ba=Σ

*)( Σ=ML

}{)( =MLEmpty language All strings

},{ ba=Σ

0q ba,

}{)( λ=MLLanguage of the empty string

( )ML = { all strings with prefix } ab

0q 1q 2q

accept

},{ ba=Σ

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

λ 0 00 001

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

λ 0 00 001

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

0q 2q 3q

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

21LLConcatenation:

*1LStar:

21 LL ∪Union:

Are regular Languages

For regular languages and we will prove that:

21 LL ∩

Complement:

Intersection:

RL1Reversal:

We say: Regular languages are closed under

21LLConcatenation:

*1LStar:

21 LL ∪Union:

21 LL ∩

Complement:

Intersection:

RL1Reversal:

Equivalent NFA

A useful transformation: use one accept state

2 accept states

1 accept state

Equivalent NFA

Single accepting state

λλλ

In General

NFA without accepting state

Add an accepting state without transitions

Extreme case

1LRegular language

( ) 11 LML =

NFA 2M

( ) 22 LML =

Regular language

Take two languages

}{1 baL n=a

{ }baL =2ab2M

Example

Union NFA for

21 LL ∪

}{1 baL n=

}{2 baL =

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

Example

Concatenation NFA for 21LL

1M 2Mλ

NFA for

}{1 baL n=}{2 baL =

}{}}{{21 bbaababaLL nn ==

Example

Star Operation NFA for *1L

*1L∈λλ λ

Lwwwww

NFA for *}{*1 baL n=

}{1 baL n=

Example

Reverse RL1

1MNFA for

ʹ′1M

1. Reverse all transitions

2. Make initial state accepting state and vice versa

}{1 baL n=a

}{1nR baL =

ʹ′1M

Example

Complement

1. Take the DFA that accepts 1L

1M1L ʹ′1M1L

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

}{1 baL n=

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

ʹ′1M

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

Example

}{1 baL n=

},{2 baabL =

regular

regular }{21 abLL =∩

regular

1Lfor for 2LDFA 1M

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

1q 2qa

transition 1p 2pa

transition

DFA DFA

11, pq a

New transition

22, pq

initial state 0p

initial state

New initial state

00, pq

1M 2MDFA DFA

accept state

accept states

New accept states

ji pq ,

ki pq ,

1M 2MDFA DFA

Both constituents must be accepting states

Example:

}{1 baL n=

}{2mabL =

0q 1q 0p 1p

2q 2pa

ba, ba,

00, pq

Automaton for intersection

}{}{}{ ababbaL mn =∩=

10, pqa

21, pq

ab 11, pq

20, pq

12, pq

22, pq

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 αλ,,∅

*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

∅=∅

Definition (continued) For regular expressions and

( ) ( ) ( )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

)()( 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

Proof:

Proof - Part 1

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

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

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

Inductive Step We will prove: ( )

( )( )1

Are regular Languages

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

( ) ( ) ( )

( ) ( )( )

( )( ) ( )11

rLrLrrL

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

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

rLrLrLrLrL ∪Union

Concatenation

We also know:

Therefore:

( ) ( ) ( )

( ) ( )( )** 11

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

Since is regular, there is a NFA that accepts it

LML =)(

Take it with a single accept state

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

Example:

Corresponding Generalized transition graph

Another Example:

b0q 1q 2q

bTransition labels are regular expressions

Reducing the states: ba +

b0q 1q 2q

)(* babb +

Transition labels are regular expressions

Resulting Regular Expression:

)(* babb +

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

LMLrL == )()(

In General Removing a state:

iq q jqa b

dae* bce*dce*

*)*(* 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

NFAs Regular Expressions

When we say: We are given a Regular Language

We mean:

Language is in a standard representation

(DFA, NFA, or Regular Expression)

Deterministic Finite Automata And Regular Languagesvganesh/TEACHING/S2014/ECE351/lectures/DFA... ·...

Documents