nfa or non deterministic finite automata

Non-deterministic finite automaton

Er. Deepinder Kaur

Not A DFA

• Does not have exactly one transition from every state on every symbol:– Two transitions from q0 on a– No transition from q0 (on either a or b)

• Though not a DFA, this can be taken as defining a language, in a slightly different way

q1

a,b

q0 a

Er. Deepinder Kaur

Nondetermistic Finite Automata

• A nondeterministic finite automaton can be different from a deterministic one in that– for any input symbol, nondeterministic one can

transit to more than one states.– epsilon transition

Er. Deepinder Kaur

1q 2q

3q

a

a

a

0q

}{aAlphabet =

Nondeterministic Finite Accepter (NFA)

Er. Deepinder Kaur

1q 2q

3q

a

a

a

0q

Two choices

}{aAlphabet =

Nondeterministic Finite Accepter (NFA)

Er. Deepinder Kaur

No transition

1q 2q

3q

a

a

a

0q

Two choicesNo transition

}{aAlphabet =

Nondeterministic Finite Accepter (NFA)

Er. Deepinder Kaur

a a

0q

1q 2q

3q

a

a

First Choice

a

Er. Deepinder Kaur

a a

0q

1q 2q

3q

a

a

a

First Choice

Er. Deepinder Kaur

a a

0q

1q 2q

3q

a

a

First Choice

a

Er. Deepinder Kaur

a a

0q

1q 2q

3q

a

a

a “accept”

First Choice

Er. Deepinder Kaur

a a

0q

1q 2q

3q

a

a

Second Choice

a

Er. Deepinder Kaur

a a

0q

1q 2qa

a

Second Choice

a

3q

Er. Deepinder Kaur

a a

0q

1q 2qa

a

a

3q

Second Choice

No transition:the automaton hangs

Er. Deepinder Kaur

a a

0q

1q 2qa

a

a

3q

Second Choice

“reject”

Er. Deepinder Kaur

Er. Deepinder Kaur

An NFA accepts a string: if there is a computation of the NFA that accepts the string

i.e., all the input string is processed and the automaton is in an accepting state

Er. Deepinder Kaur

aa is accepted by the NFA:

0q

1q 2q

3q

a

a

a

“accept”

0q

1q 2qa

a

a

3q “reject”

because this computationaccepts

aa

this computationis ignored

Formal Definition of Nondeterministic Finite Automata

• An NFA is a five-tuple:N = (Q, Σ, δ, q0, F)

Q A finite set of statesΣ A finite input alphabetq0 The initial/starting state, q0 is in QF A set of final/accepting states, which is a subset of Qδ A transition function, which is a total function from Q x Σ to 2Q

δ: (Q x Σ) → P(Q) -P(Q) is the power set of Q, the set of all subsets of Q

δ(q,s) -The set of all states p such that there is a transition labeled s from q to p

δ(q,s) is a function from Q x S to P(Q) (but not to Q)

Er. Deepinder Kaur

Powerset

• If S is a set, the powerset of S is the set of all subsets of S:

P(S) = {R | R S}

• This always includes the empty set and S itself• For example,

P({1,2,3}) = {{}, {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3}}

Er. Deepinder Kaur

Difference between NFA and DFA

1.In DFA, For a given state on a given input we reach to a deterministic and unique state.2. In NFA or NDFA we may lead to more than one state for a given input.3. Empty string can label transitions.5. We need to convert NFA to DFA for designing a compiler.

Er. Deepinder Kaur

• An NFA can easily implemented using a transition table.

State a b 0 {0, 1} {0} 1 - {2} 2 - {3}

0 1 2 3a b b

a

b

Er. Deepinder Kaur

For any NFA N = (Q, , , q0, F), L(N) denotes the language accepted by N which is

L(N) = {x * | *(q0, x) F {}}.

The Language An NFA Defines

Er. Deepinder Kaur

0,1 1 0

0 1

0,1

Er. Deepinder Kaur

DCB

E

A 0

Construct a NFA for a language consisting a substring {0101} over ={0,1}

-Transitions To Accepting States

• An -transition can be made at any time• For example, there are three sequences on the empty string

– No moves, ending in q0, rejecting– From q0 to q1, accepting– From q0 to q2, accepting

• Any state with an -transition to an accepting state ends up working like an accepting state too

q0

a q1

q2

b

Er. Deepinder Kaur

-transitions For NFA Combining

• -transitions are useful for combining smaller automata into larger ones

• This machine combines a machine for {a}* and a machine for {b}*

• It uses an -transition at the start to achieve the union of the two languages

q0

a q1

q2

b

Er. Deepinder Kaur

Incorrect Union

A = {an | n is odd}

B = {bn | n is odd}

A B ?No: this NFA accepts aab

a

a

b

b

a

a

b

b

Er. Deepinder Kaur

Correct Union

A = {an | n is odd}

B = {bn | n is odd}

A B

a

a

b

b

a

a

b

b

Er. Deepinder Kaur

Example:Possible Sequences of 001

• Determining if a given NFA accepts a given string (001) can be done algorithmically:

q0 q0 q0 q0

q3 q3 (stuck) q1

q4 q4

accepted• Each level will have at most n states

0 0 1

q0

0/1

0 0q3q4

0/1

q1q2

0/11

1

Er. Deepinder Kaur

NFA – Examples

• Now there are two possible transitions to follow for state A with a leading 0. One transition is back to A, consuming the 0, while the other is to B. • Check for string 00010101

Er. Deepinder Kaur

Design a NFA for the language L=all strings over {0,1} that have atleast two consecutive 0’s or 1’s

q0

q3

q1 q2

q4

0

0

0/1

0/1

1 1

0/1

start

Er. Deepinder Kaur

Draw transition table for previous example

0 1

qo {qo,q1} {qo,q3}

q1 q2 ?

* q2 q2 q1

q3 ? q4

*q4 Q4 Q4

Er. Deepinder Kaur

Design a NFA for the language L=(ab Ս aba)*

b

q4

q1start

a a

b

a

a

b

b

q0 q3q2

a/b

DFA for the given statementEr. Deepinder Kaur

NFA’s for previous DFA

q1

q2

q1

q2

b a

ba b

a

a

q0q0

startstar

t

є

q0

ab

aba

start

Er. Deepinder Kaur

Draw the state diagram for NFA accepting languageL=(ab)*(ba)* U aa*

We can construct NFA for the language L in two parts. L=L1 U L2Where L1=(ab)*(ba)* L2=aa*

Er. Deepinder Kaur

NFA for (ab)*(ba)*

q1 q2ba

ab ba

start

q3a

a

q4

NFA for aa*

start

Er. Deepinder Kaur

For Combining the two, we take a new state q0 and join the two NFAs with null transition

q0

q1 q2ba

ab ba

ϵ

q3a

a

q4

ϵ

start

Er. Deepinder Kaur

Find NFA with four state for the languageL={(an:n>=0) U (bna:n>=1)}

L=L1 U L2 L1= an:n>=0 L2= bna:n>=1

Er. Deepinder Kaur

q1start

a

q2 q4q3b a

b

start

NFA for an

NFA for bna

Er. Deepinder Kaur

Combined NFA

q1

a

q2 q4q3b a

bϵ

Er. Deepinder Kaur

NFA Practice

• Design a NFA for language L={0101n U 0100|n>=0}

• Design a NFA to accept strings with a’s and b’s such that strings end with ‘aa’

• Construct a NFA in which double ‘1’ is followed by double ‘0’ over {0,1}

Er. Deepinder Kaur

Transformation of NFA to DFA

• For every non deterministic finite automata, there exist an equivalent deterministic finite automata.

• The equivalence is determined in terms of language acceptance.

• A NFA is nothing but a finite automata in which zero, one or more transitions on an input symbol is permitted, we can always construct a finite automata which will simulate all the moves of NFA on a particular input symbol in parallel, then get a finite automata in which there will be exactly one transition on every input symbol, hence it will be DFA equivalent to NFA Er. Deepinder Kaur

Convert the following NFA into DFA

q0 q1 q2

q3

a a

ba,b

a,b b

start

Er. Deepinder Kaur

Solution: Step1: Seek all the transition from starting state q0 for every symbol in ∑ i.e (a,b).If we get a set of states for same input, consider the set as a new single state

δ(q0,a)={q0,q1}-------------new state δ(q0,b)={q0}Step2: In step1 we are getting a new state {q0,q1}. Repeat step 1 for this

new state only i.e check all transitions of a and b from {q0,q1} as: δ({q0,q1},a)= δ(q0,a) U δ(q1,a) = {q0,q1} U {q2} = {q0,q1,q2}-------------new state δ({q0,q1},b)= δ(q0,b) U δ(q1,b) = {q0} U {q1} ={q0,q1}---------------old state

Er. Deepinder Kaur

Step 3: Repeat step 2 till you are getting any new state. All those states that consist of any of the accepting state of given NFA as member state will be considered as final states

δ({q0,q1,q2},a)= δ(q0,a) U δ(q1,a) U δ(q2,a) ={q0,q1} U {q2} U {q3} ={q0,q1,q2,q3}-------new state δ({q0,q1,q2},b)= δ(q0,b) U δ(q1,b) U δ(q2,b) = {q0} U {q1} U {q3} ={q0,q1,q3}--------new state δ({q0,q1,q2,q3},a)= δ(q0,a) U δ(q1,a) U δ(q2,a) U δ(q3,a) ={q0,q1} U {q2} U {q3} U {q3} ={q0,q1,q2,q3}----------old state δ({q0,q1,q2,q3},b)=δ(q0,b) U δ(q1,b) U δ(q2,b) U δ(q3,b) ={q0} U {q1} U {q3} U {q2} ={q0,q1,q3,q2}----------old state

Er. Deepinder Kaur

δ({q0,q1,q3},a)=δ(q0,a) U δ(q1,a) U δ(q3,a) ={q0,q1} U {q2} U {q3} ={q0,q1,q2,q3}----------old state

δ({q0,q1,q3},b)=δ(q0,b) U δ(q1,b) U δ(q3,b) ={q0} U {q1} U {q2} ={q0,q1,q2}----------old stateTransition table :

δ/∑ a b

q0 {q0,q1} {q0}

{q0,q1} {q0,q1,q2} {q0,q1}

*{q0,q1,q2} {q0,q1,q2,q3} {q0,q1,q3}

*{q0,q1,q2,q3} {q0,q1,q2,q3} {q0,q1,q2,q3}

*{q0,q1,q3} {q0,q1,q2,q3} {q0,q1,q2}

Er. Deepinder Kaur

Let us say: q0----A {q0,q1}-----B {q0,q1,q2}-----------C {q0,q1,q2,q3}---------D {q0,q1,q3}-----------E

Er. Deepinder Kaur

• A is the initial state and C,D and E are final states since they contain q2 and q3 as member which are final states of NFA

δ/∑ a b

A B A

B C B

*C D E

*D D D

*E D C

Er. Deepinder Kaur

ABa a

b

b

aa,b

bb

C

DE

start

a

Er. Deepinder Kaur

NFA to DFA conversion intuition

1 0

0, 1

q q qNFA:

DFA: 1q {q0, q1}

1

{q0, q2}

1

0 0

0

Er. Deepinder Kaur

Convert the following NFA to DFA

δ/∑ 0 1

q0 {q0,q1} {q1}

*q1 - {q0,q1}

Er. Deepinder Kaur

A 0

1

B

D

start

1

DFA for previous problem

0

1

0

A=[q0]B=[qo,q1]C=[q1]

Er. Deepinder Kaur

q0q10 0

1

q2

start

Convert the following NFA into DFA

q3

0

1

q2q4

q2

1

Er. Deepinder Kaur

Epsilon Transitions• Extension to NFA – a “feature” called epsilon

transitions, denoted by ε, the empty string• The ε transition lets us spontaneously take a

transition, without receiving an input symbol• Another mechanism that allows our NFA to be in

multiple states at once. – Whenever we take an ε edge, we must fork off a new

“thread” for the NFA starting in the destination state. • While sometimes convenient, has no more power

than a normal NFA – Just as a NFA has no more power than a DFA

Er. Deepinder Kaur

Formal Definition of NFAs with ε Moves

• An NFA-ε is a five-tuple:N = (Q, Σ, δ, q0, F)

Q A finite set of statesΣ A finite input alphabetq0 The initial/starting state, q0 is in QF A set of final/accepting states, which is a subset of Qδ A transition function, which is a total function from Q x Σ U {ε} to P(Q)

δ: (Q x (Σ U {ε})) → P(Q)

• A String w in Σ* is accepted by NFA iff there exists a path in NFA from q0 to a state in F labeled by w and zero or more ε transitions.

• Sometimes referred to as an NFA-ε other times, simply as an NFA.

Er. Deepinder Kaur

Formal Definition of ε Closure

• The ε closure (p) is a set of all states which are reachable from state p on ε transitions such that:

1. Ε- CLOSURE (P)=P where P ЄQ2. If there exists ε-closure (p) ={q} and δ(q, ε) = r then

ε-closure (p)={q,r}

ε-closure (q0)={q0,q1,q2}ε-closure (q1)={q1,q2}ε-closure (q2)={q2}

q0

ε0/1

q2

1

0

q1

0

q3

ε

0

1

Er. Deepinder Kaur

Epsilon Closure• Epsilon closure of a state is simply the set

of all states we can reach by following the transition function from the given state that are labeled ε.

• ε-closure(q) = { q }

• ε-closure(r) = { r, s}

qStart r sε1

0

ε0

1

Example:

Er. Deepinder Kaur

Eliminating Epsilon Transitions

1. Compute ε-closure for the current state, resulting in a set of states S. 2. δD(S,a) is computed for all a in by

a. Let S = {p1, p2, … pk}

b. Compute k

ii ap

1

),(

and call this set {r1, r2, r3 … rm} This set is achieved

by following input a, not by following any ε-transitions

c. Add the ε-transitions in by computing m

iirclosureaS

1

)(),(

3. Make a state an accepting state if it includes any final states in the ε-NFA.

In simple terms: Just like converting a regular NFA to a DFA except follow the epsilon transitions whenever possible after processing an input

To eliminate ε-transitions, use the following to convert to a DFA:

Er. Deepinder Kaur

Conversion of NFA with ε to NFA without ε

qStart r

s

a

b c

Er. Deepinder Kaur

Step 1: Find ε closures ε closure(q)= {q,r,s} ε closure(r)= {r,s} ε closure(s)= {s}

Step 2: Find δ for all statesδ’(q,a)= ε closure (δ(δ’(q, ε),a))

= ε closure (δ(ε closure(q),a)) = ε closure(δ((q,r,s),a)) = ε closure (δ(q,a) U δ(r,a) U δ(s,a) )

= ε closure (q U θ U θ ) = ε closure (q)

= {q,r,s} δ’(q,b)= ε closure (δ(δ’(q, ε),b))

= ε closure (δ(ε closure(q),b)) = ε closure(δ((q,r,s),b))

qStart r

s

a

b c

Er. Deepinder Kaur

= ε closure (δ(q,b) U δ(r,b) U δ(s,b) ) = ε closure (θ UrU θ ) = ε closure (r)

= {r,s}δ’(q,c)= ε closure (δ(δ’(q, ε),c))

= ε closure (δ(ε closure(q),c)) = ε closure(δ((q,r,s),c)) = ε closure (δ(q,c) U δ(r,c) U δ(s,c) )

= ε closure (θ U θ U s ) = ε closure (s)

= {s} δ’(r,a)= ε closure (δ(δ’(r, ε),a))

= ε closure (δ(ε closure(r),a)) = ε closure(δ((r,s),a)) = ε closure (δ(r,a) U δ(s,a) ) = ε closure (θ U θ ) = θ

qStart r

s

a

b c

Er. Deepinder Kaur

δ’(r,b)= ε closure (δ(δ’(r, ε),b)) = ε closure (δ(ε closure(r),b)) = ε closure(δ((r,s),b)) = ε closure (δ(r,b) U δ(s,b) ) = ε closure (r U θ ) = ε closure (r ) ={r,s}

δ’(r,c)= ε closure (δ(δ’(r, ε),c)) = ε closure (δ(ε closure(r),c))

= ε closure(δ((r,s),c)) = ε closure (δ(r,c) U δ(s,c) )

= ε closure (θ U s ) = ε closure (s)

= {s}δ’{s,a}= ε closure (δ(δ’(s, ε),a))

=ε closure (δ(s,a)) = ε closure (θ ) = θ

qStart r

s

a

b c

Er. Deepinder Kaur

δ’{s,b}= ε closure (δ(δ’(s, ε),b)) =ε closure (δ(s,b))

= ε closure (θ ) = θ

δ’{s,c}=ε closure (δ(δ’(s, ε),c)) =ε closure (δ(s,c) )

= ε closure (s ) = {s}

qStart r

s

a

b c

Er. Deepinder Kaur

q

s

r

a b c

q {q,r,s} {r,s} s

r θ {r,s} S

s θ θ c

Step 4: Draw NFA without ε transitions

a

a,b

a,b,c

b

b,c

c

qStart r

s

a

b c

Er. Deepinder Kaur

Conversion of NFA with ε to DFA

qStart r

s

a

b c

Er. Deepinder Kaur

Step 1: Find ε closures ε closure(q)= {q,r,s} ε closure(r)= {r,s} ε closure(s)= {s}

Step 2: Find δ for all new states δ’{(q,r,s),a}= ε closure (δ((q,r,s),a))

= ε closure (δ(q,a) U δ(r,a) U δ(s,a) ) = ε closure (q U θ U θ ) = ε closure (q)

= {q,r,s} δ’{(q,r,s),b}= ε closure (δ((q,r,s),b))

= ε closure (δ(q,b) U δ(r,b) U δ(s,b) ) = ε closure (θ UrU θ ) = ε closure (r)

= {r,s}

qStart r

s

a

b c

Er. Deepinder Kaur

Step 1: Find ε closures ε closure(q)= {q,r,s} ε closure(r)= {r,s} ε closure(s)= {s}

Step 2: Find δ for all new states δ’{(q,r,s),a}= ε closure (δ((q,r,s),a))

= ε closure (δ(q,a) U δ(r,a) U δ(s,a) ) = ε closure (q U θ U θ ) = ε closure (q)

= {q,r,s} δ’{(q,r,s),b}= ε closure (δ((q,r,s),b))

= ε closure (δ(q,b) U δ(r,b) U δ(s,b) ) = ε closure (θ UrU θ ) = ε closure (r)

= {r,s}

qStart r

s

a

b c

Er. Deepinder Kaur

δ’{(r,s),c}= ε closure (δ((r,s),c)) = ε closure (δ(r,c) U δ(s,c) )

= ε closure (θ U s ) = ε closure (s)

= {s}δ’{s,a}= ε closure (δ(s,a))

= ε closure (θ ) = θ

δ’{s,b}= ε closure (δ(s,b)) = ε closure (θ )

= θδ’{s,c}= ε closure (δ(s,c) )

= ε closure (s ) = {s}

qStart r

s

a

b c

Er. Deepinder Kaur

Step 3: Draw transition table for all new statesLet q,r,s= D r,s =E

s =F

qStart r

s

a

b c

a b c

D D E F

E θ E F

F θ θ F

Er. Deepinder Kaur

D

F

E

a b c

D D E F

E θ E F

F θ θ F

Step 4: Draw NFA without ε transitions

a

b

c

b

c

c

qStart r

s

a

b c

Er. Deepinder Kaur

G

a

a,b

Epsilon Elimination Example

qStart r sε1

0

ε0

1

qStart sr0,1

0,1

Converts to:

Er. Deepinder Kaur

Examples

NFA with epsilon-transitions:

Er. Deepinder Kaur

Minimizing DFA

• Minimization of automata refers to detect those states of automata whose presence or absence in a automata does not affect the language accepted by automata. • These states are like Unreachable states, Dead states, Non-distinguishable states etc.

Er. Deepinder Kaur

Minimizing DFAMinimization Algorithm for DFA 

Construct a partition   = { A, Q - A } of the set of states Q ; new := new_partition( } ; while ( new!=    )           :=  new ;          new := new_partition( ) 

final :=   ; function new_partition( ) for each set S of    do         partition S into subsets such that two states p and q of S are in the same subset of S         if and only if for each input symbol, p and q make a transition to (states of) the same set of   .   The subsets thus formed are sets of the output partition in place of S.  If S is not partitioned in this process, S remains in the output partition. end 

Er. Deepinder Kaur

Minimizing DFA

Example:

State 0 1

-> q0 q1 q5

q1 q6 q2

q2(Final state) q0 q2

q3 q2 q6

q4 q7 q5

q5 q2 q6

q6 q6 q4

q7 q6 q2

Er. Deepinder Kaur

Minimizing DFAFor minimizing the above automata,   Q1= F={q2} Final state Q2= Q-Q0= {q0, q1, q3,q4,q5,q6,q7}

Hence ,пo = { {q2}, {q0, q1, q3,q4,q5,q6,q7}}We cannot partition {q2} further, Hence Q1’={q2}Now Consider another set from пo i.e. {q0, q1, q3,q4,q5,q6,q7}.Now compare input entries of q0 for all remaining states in this set.

0 1

q0 q1 q5

q1 q6 q2

Here q5 belongs to Q2 and q2 belongs to Q1Hence they are not 1-equivalent

Here q1 and q6 both belongs to Q2

Er. Deepinder Kaur

Minimizing DFA0 1

q0 q1 q5

q3 q2 q6

Here q1 belongs to Q2 and q2 belongs to Q1Hence they are not 1- equivalent

0 1

q0 q1 q5

q4 q7 q5

Same StatesQ1 and q7 both belongs to Q2

Hence they are 1- equivalentEr. Deepinder Kaur

Minimizing DFA0 1

q0 q1 q5

q5 q2 q6

Here q1 belongs to Q2 and q2 belongs to Q1Hence they are not 1- equivalent

0 1

q0 q1 q5

q6 q6 q4 q5 and q4both belongs to Q2

q1 and q6both belongs to Q2

Hence they are 1-equivalentEr. Deepinder Kaur

Minimizing DFA0 1

q0 q1 q5

q7 q6 q2

Here q5 belongs to Q2 and q2 belongs to Q1Hence they are not 1- equivalentAs q0, q4 and q6 are equivalent thus {q0,q4,q6} will be one

subset in п1 We will now consider a subset {q1,q3,q5,q7}. Now we will find the 1-equivalent subset from this subset. Hence we need to compare q1 with q3,q5 and q7 resp.0 1

q1 q6 q2

q3 q2 q6

Here q6 belongs to Q2 and q2 belongs to Q1Hence they are not 1-equivalentEr. Deepinder Kaur

Minimizing DFA0 1

q1 q6 q2

q5 q2 q6

Here q6 belongs to Q2 and q2 belongs to Q1Hence they are not 1-equivalent

0 1

q1 q6 q2

q7 q6 q2 q2 belongs to Q1

q6 belongs to Q2 Hence they are 1-equivalent

Er. Deepinder Kaur

Minimizing DFAi.e. q1 is 1- equivalent to q7. Hence {q1,q7} will be one subset . We cannot partition this subset further. Hence Q3={q1,q7}

0 1

q1 q6 q2

q7 q6 q2 q2 belongs to Q1

q6 belongs to Q2 Hence they are 1-equivalent

Er. Deepinder Kaur

Minimizing DFANow we will compare q3 with q5

0 1

q3 q2 q6

q5 q2 q6 q6 belongs to Q2

q2 belongs to Q1 Hence they are 1-equivalent

Q4={q3,q5}Now п1 = { {q2}, {q0, q4,q6}, {q1,q7}, {q3,q5}}

Er. Deepinder Kaur

Minimizing DFAFrom п1 we can consider a subset {q0,q4,q6}. We will again compare q0 with q4 and q6. This will be known as 2- equivalent

0 1

q0 q1 q5

q4 q7 q5

Same StatesQ1 and q7 both belongs to Q3

Hence they are 2- equivalent0 1

q0 q1 q5

q6 q6 q4

Hence they are 2-equivalentEr. Deepinder Kaur

Minimizing DFA

Now п2 = { {q2}, {q0, q4}, {q6}, {q1,q7}, {q3,q5}}Similarly q3 and q5 are 2-equivalentThenп3 = { {q2}, {q0, q4}, {q6}, {q1,q7}, {q3,q5}}here п2 = п3  so stop making п sets.

Now we can construct finite automata with minimized state as M’=(Q’,{0,1}, δ’,q0’,F’)Where Q’ is set of states in FAi.e. {[q2],[q0,q4],[q6],[q1,q7],[q3,q5]}q0’ is initial state i.e. [q0,q4]F’ is set of final states i.e. [q2]

Er. Deepinder Kaur

Minimizing DFA

State 0 1

[q0, q4] [q1, q7] [q3, q5]

[q1, q7] [q6] [q2]

[q2] [q0, q4] [q2]

[q3, q5] [q2] [q6]

[q6] [q6] [q0, q4]

Minimized DFA:

Er. Deepinder Kaur

Minimizing DFA

Example:

Er. Deepinder Kaur

Minimizing DFA

Initially  Pi = { { 3 } , { 1 , 2 , 4 , 5 , 6 } }. By applying new_partition to this  ,  Pi new = { { 3 } , { 1 , 4 , 5 } , { 2 , 6 } } is obtained. Applyting new_partition to this  , Pi new = { { 3 } , { 1 , 4 } , { 5 } , { 2 } , { 6 } } is obtained. Applying new_partition again,  Pi new = { { 1 } , { 2 } , { 3 } , { 4 } , { 5 } , { 6 } } is obtained. Thus the number of states of the given DFA is already minimum and it can not be reduced any further.  Er. Deepinder Kaur

Minimizing DFA: Exercises

Construct the minimum state automaton equivalent to the following transition table:

State A b

-> q0 q1 q0

q1 q0 q2

q2 q3 q1

q3(Final state) q3 q0

q4 q3 q5

q5 q6 q4

q6 q5 q6

q7 q6 q3

Er. Deepinder Kaur

Minimizing DFA: Exercises

Construct the minimum state automaton equivalent to the following transition table:

State 0 1

-> q0 q0 q3

q1 q2 q5

q2 q3 q4

q3(Final state) q0 q5

q4 q0 q6

q5 q1 q4

Er. Deepinder Kaur