DFA Operations. Complement, Product, Union, Intersection, Difference, Equivalence and Minimization of DFAs

(1)

DFA Operations

Complement, Product, Union, Intersection, Difference, Equivalence

CS235 Languages and Automata

Wednesday, October 6 and Friday, October 8, 2010 Reading: Sipser pp. 45-46, Stoughton 3.11 – 3.12

and Minimization of DFAs

CS235 Languages and Automata

Department of Computer Science Wellesley College

Some DFAs

Here are some simple DFAs we will use as examples in today’s lecture.

What languages do they accept?

a L K DFA₅

a B a

b b

A DFA₁

a _DFA₂ a

b F

a b

E DFA₃

a G a,b

b _DFA₄ a a,b

b L K

b M a

a,b

DFA₆ b D

C b a I

H b J a O

N b

b P a

a,b

(2)

Complement of DFAs

If DFA accepts language L, then L is accepted by DFA, a version of DFA in which the accepting and

non-accepting states have been swapped.

a L K DFA₅

a B a

b b

A DFA₁

b F

a b

E DFA₃

a G a,b

b L K

b M a

a,b

DFA₅

DFA Operations 14-3

a B a

b b

A DFA₁

b F

a b

E DFA₃

a G a,b

a L K b

b M a

a,b

DFA Complement in Forlan

- val dfa1 = DFA.input “begin_and_end_with_a.dfa";

val dfa1 = - : dfa - DFA.complement;

val it = fn : dfa * sym set -> dfay

- val dfa1_comp = DFA.complement (dfa1, SymSet.fromString "a,b");

val dfa1_comp = - : dfa

- SymSet.toString (DFA.states dfa1_comp);

val it = "W, X, Y, <dead>" : string

- SymSet.toString (DFA.acceptingStates dfa1_comp);

val it = "W, Y, <dead>" : string

- DFA.output ("dfa_begin_and_end_with_a_comp.dfa", dfa_comp);

val it = () : unit

(3)

We can run two DFAs in parallel on the same input via the product construction, as long as they share the same alphabet.

Suppose DFA₁= (Q₁, , ₁, s₁, F₁) and DFA₂= (Q₂, , ₂, s₂, F₂) W d fin DFA x DFA s f ll s:

Product of DFAs

( )

We define DFA₁x DFA₂as follows:

States: Q_1x2= Q₁x Q₂ Alphabet: 

Transitions:

_1x2Q_1x2x   Q_1x2

 ( ((q q ) ) ) r r

q₂ q₁



( , )

 

DFA Operations 14-5

( , )

_1x2( ((q₁,q₂), ) )

= ( ₁( (q₁,) ), ₂( (q₂,) ) Start State: s_1x2= (s₁, s₂)

Final States: Definition depends on how we use product r₂ r₁

Sample Products

a B a

b b

A DFA₁

b F

a b

E DFA₃

a G a,b

b D b

a a

C DFA₂

a I

b a

H DFA₄

b J a,b

DFA₁x DFA₂

a ( E H ) a ( E I ) b ( F J )

a b

DFA₃x DFA₄

( A , D )

( A , C ) ( B , C )

( B , D ) a

a a

b b b b

( F , H )

( E , H ) ( E , I )

( G , I ) a

b

( F , J )

( G , J ) b

a

(4)

Practice

a B a

b b

A DFA₁

b F

a b

E DFA₃

a G a,b

DFA₁x DFA₃

DFA Operations 14-7

Intersection of DFAs

We can intersect DFA₁and DFA₂(written DFA₁DFA₂) by defining the accepting states of DFA₁x DFA₂as those state pairs in which both states are final states of their DFAs.

( A D )

DFA₁DFA₂

( A , C ) ( B , C )

( B D ) a

a

b b a b b

( F , H )

( E , H ) ( E , I )

( G , I ) a

a b

( F , J )

( G , J ) b

a

b b

a DFA₃DFA₄

( A , D ) a ( B , D )

b a

a,b

(5)

Union of DFAs

We can union DFA₁and DFA₂(written DFA₁DFA₂) by defining the accepting states of DFA₁x DFA₂as those state pairs in which either state is a final state of its DFA.

( A D )

DFA₁DFA₂

( A , C ) ( B , C )

( B D ) a

a

b b a b b

( F , H )

( E , H ) ( E , I )

( G , I ) a

a b

( F , J )

( G , J ) b

a

b b

a DFA₃DFA₄

DFA Operations 14-9

( A , D ) a ( B , D )

b a

a,b

Difference of DFAs

The difference of two DFAs (written DFA₁− DFA₂) can be defined in terms of complement and intersection:

DFA₁− DFA₂= DFA₁DFA₂

DFA₁− DFA₂

( A C ) ( B C ) a

a ( E , H ) a ( E , I ) b ( F , J )

a b

DFA₃− DFA₄

So we can take the difference of DFA₁and by defining the final states of DFA₁− DFA₂as those state pairs in which the first state is final in DFA₁and the is second state is not final in DFA₂.

( A , D )

( A , C ) ( B , C )

( B , D ) a

a a

b b b b

( F , H ) a ( G , I ) b

b

( G , J ) b

a

a,b

(6)

What is a Closure Property?

A set S is closed under an n-ary operation f iff x

₁

,…, x

_n

 S implies f(x

₁

,…, x

_n

)  S

Examples:

• Bool is closed under negation, conjunction, disjunction.

• Nat is closed under + and * but not – and /.

CFL Properties 14-11

• Int is closed under +, *, and -, but not /.

• Rat is closed under +, *, -, and / (except division by 0).

Some Closure Properties of Regular Languages Recall that a language is regular iff there is a

DFA that accepts it.

Based on the previous DFA constructions, we know the p , following closure properties of regular languages.

Suppose L

₁

and L

₂

are regular languages. Then:

• L

₁

and L

₂

are regular;

• L

₁

 L

₂

is regular;

l

• L

₁

 L

₂

is regular;

• L

₁

− L

₂

and L

₂

− L

₁

are regular.

(7)

Are Any of the Following DFAs Equivalent?

a L K b DFA₅

a O N b DFA₆

a S b R DFA₇ b Q a

b M a

a,b

b

b P a

a,b

a

b T b

a,b a

a,b U

DFA Operations 14-13

DFA

₅

and DFA

₆

are Not Equivalent

a L K DFA₅

a O N DFA₆ Look at their product!

b L K

b M a

a,b

b O N

b P a

a,b

DFA₅x DFA₆ DFA₅accepts 

but DFA₆doesn’t

DFA₆accepts a but DFA₅doesn’t

( K , N ) a ( L , O )

( M , P ) b

b a

but DFA₆doesn t

(8)

DFA

₅

and DFA

₇

Are Equivalent

a L K b DFA₅

S b R DFA₇

Q a Look at their product!

b L K

b M a

a,b

DFA₅x DFA₇

a S R

b T b

a,b Q

a

a b

a,b U

( K , Q ) ( K , S )

( M , T )

b

b a

a,b

( L , R ) a ( M , U ) a,b

a

DFA Equivalence Algorithm

To determine if DFA₁and DFA₂are equivalent, construct DFA₁x DFA₂and examine all state pairs containing at least one accepting state from DFA₁or DFA₂:

• If in all such pairs, both components are accepting, DFAIf in all such pairs, both components are accepting, DFA₁₁and and DFA₂are equivalent --- i.e., they accept the same language.

• If in all such pairs, the first component is accepting but in some the second is not, the language of DFA₁is a superset of the language of DFA₂and it is easy to find a string accepted by DFA₁and not by DFA₂

• If in all such pairs, the second component is accepting but in th fi t i t th l f DFA i b t f th some the first is not, the language of DFA₁is a subset of the language of DFA₂, and it is easy to find a string accepted by DFA₂and not by DFA₁

• If none of the above cases holds, the languages of DFA₁and DFA₂are unrelated, and it is easy to find a string accepted by one and not the other.

(9)

Products in Forlan

val inter : dfa * dfa -> dfa val minus : dfa * dfa -> dfa

datatype relationshipyp p

= Equal | Incomp of str * str | ProperSub of str | ProperSup of str val relation : dfa * dfa -> relationship

val relationship : dfa * dfa -> unit val subset : dfa * dfa -> bool val equivalent : dfa * dfa -> bool

q

Note that a union operator is missing. It really should be there!

We’ll see later how it can be defined.

Forlan Products: Example

- val bwa = DFA.input "begin_with_a.dfa";

val bwa = - : dfa

- val ewa = DFA.input "end_with_a.dfa";

val ewa = - : dfa

- val baewa = DFA.inter(bwa,ewa);

val baewa = - : dfa

- DFA.output("baewa.dfa", baewa);

val it = () : unit

(10)

Forlan Products: Example (Continued)

- val dfa1 = DFA.input "begin_and_end_with_a.dfa";

val dfa1 = - : dfa

- DFA.relationship(baewa, dfa1);

languages are equal languages are equal val it = () : unit

- DFA.relation(baewa, dfa1);

val it = Equal : DFA.relationship

- DFA.relation(bwa, baewa);

val it = ProperSup [-,-] : DFA.relationship

- let val DFA.ProperSup s = it in Str.toString s end;

DFA Operations 14-19 stdIn:19.9-19.29 Warning: binding not exhaustive

ProperSup s = ...

val it = "ab" : string

- DFA.subset(baewa, bwa);

val it = true : bool

Minimal DFAs

a L K b DFA₅

b

a S b R DFA₇

b b

Q a a

b M a

a,b

• A DFA is minimal if it has the smallest number of states of any DFA accepting its language.

• Is DFA₅minimal?

b T

a,b U

a,b

Is DFA₅minimal?

• Is DFA₇minimal?

(11)

State Merging

a L K b DFA₅

b

a S b R DFA₇

b b

Q a a

b M a

a,b

• A DFA is not minimal iff two states can be merged to form a single state without changing the meaning of the DFA.

• Final states and non-final states can never be merged.

b T

a,b U

a,b

• Can merge two states iff for each symbol they transition to mergeable states.

• Which states in DFA₇can be merged?

State Merging in DFA

₇

Merge T with U

a S b R DFA₇

b Q a

a

a S b R

b Q a

a

Merge Q with S

b T b

a,b a

a,b U

b

a,b

{ T,U }

a b

a R

b a,b

a {T,U}

{ Q ,S }

(12)

Problem: States Can’t Always be Merged Iteratively

DFA₈

a a

V ab W b

Simultaneously merge V with X and W with Y

Y

Z b

a,b X

a

a b

a

{W,Y}

{ V , X } b a

a,b Z

b a

Key to solution: rather than iterating to find mergeablestate pairs, iterate to find all state pairs that are provably unmergeable. Then any remaining state pair is mergeable.

This is an example of a greatest fixed point iteration, in which items are assumed related unless proven otherwise.

DFA Minimization Algorithm: Step 1

a S b R DFA₇

b b

Q a a List all pairs of states than must

not be merged = pairs of one final and one non-final state.

Other pairs might be mergeable;

th id d bl

U_s Q

b T

a,b U

a,b they are considered mergeable

until proven otherwise.

It’s a good idea to keep track of state pairs in half of a table*:

U T

?

S RU_s Unmergeable by string s

U_s U_s R ? S T

* Lyn adapted this table representation from Katie Sullivan (Olin)

MightBeMergeable

? Table₁ U_s U_s U_s

? ?

(13)

DFA Minimization Algorithm: Step 2

a S b R DFA₇

b b

Q a a Change from MightBeMergeable to Unmergeable

any pair (A,B) such that there is a transition to a (C,D) in Unmergeable:

( , )

^A ^B

MightBeMergeable

b T

a,b U

( , )

_C _D a,b

a a a

Unmergeable

Repeat this step until no more state pairs can be changed.

In Table₂, In Table₁ pairs

U T S R U T S R

(R,T) ^b (S,T) (R,U) ^b (S,T)

In Table₂, no pairs can be changed In Table₁, pairs

(R,T) and (R,U) be changed:

Q U

R S T

?

? U

U U

?

? U_ U_

Table₁

Q U

R S T

? U_b U

U U

U_b

? U_ U_

Table₂

DFA Minimization Algorithm: Step 3

When no more pairs can be changed from MightBeMergeable to Unmergeable, merge the pairs remaining in MightBeMergeable.

Q U U

T M S R

U U

Q U U

T

? S R

U U U_s Unmergeable by s

b a

DFA₇ Merge Q with S

b M ^Mergeable

? MightBeMergeable

Q U

R S T

M U_b U_ U U

U_b M U_ U

Table₂ Q U

R S T

? U_b U_ U U

U_b

? U_ U

Table₂

a a S

R

7

b T b

a,b Q a

a

a,b U

and T with Ug Q R

b a,b

a {T,U}

{ Q ,S }

(14)

DFA Minimization: More Practice

DFA₈

X a

W V ab

b Merge V with X

and W with Y { V ,W } {W,Y}

a b

Y

Z b

a,b X

a a

b

V Z U

Y

? X W

U U

Z U

Y

? X W

U U

Z U

Y X W a,b Z

b a

a

V U_ W X

Y

?

? U

U_ U_

?

? U U_

Table₁

V U

W X

Y

?

? U_ U U

U_b U_b U_ U

Table₂

V U_ W X

Y

M M U

U_ U_ U_b

U_b U U

Table₃

Both examples happen to converge after 1 iteration of step 2, but in general can take 0 to (|Q|-1) iterations.

Minimization in Forlan

val minimize : dfa -> dfa