Scribd
Upload
185 views

Closure Prop Dfa

DFA

Uploaded by

Arvin Anthony Sabido Araneta
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
185 views

Closure Prop Dfa

DFA

Uploaded by

Arvin Anthony Sabido Araneta
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 22

Automata and Formal Languages

Closure Properties of DFAs

Sipser pages 44 - 47

Lecture 9 Tim Sheard 1


Closure properties of DFAs

Languages captured by DFA’s are closed under


• Union
• Concatenation
• Kleene Star
• Complement
• Intersection

That is to say if L1 and L2 are recognized by a DFA,


then there exists another DFA, L3, such that

1. L3 = complement L1 { x | x ∉ L1 }
2. L3 = L1 ∪ L2 { x | x ∈ L1 or x ∈ L2 }
3. L3 = L1 ∩ L2 { x | x ∈ L1 and x ∈ L2 }
4. L3 = L1*
5. L3 = L1 • L2 (The first 3 are easy, we’ll wait on 4 and 5)
Complement

Complementation
Take a DFA for L and change the status - final
or non-final - of all its states. The resulting
DFA will accept exactly those strings that the
first one rejects. It is, therefore, a DFA for the
Complent(L).

Thus, the complement of DFA recognizable


language is DFA recognizable.
Complement Example

Contains a “0”
Contains only “1”
2nd Complement Example

Just “abc”

Anything but “abc”


As a Haskell Program

compDFA :: (Ord q) => DFA q s -> DFA q s


compDFA m = DFA (states m)
(symbols m)
(trans m)
(start m)
new
where new = [ s
| s <- states m
, not(elem s (accept m))]
Intersection

The intersection L ∩ M of two DFA


recognizable languages must be
recognizable by a DFA too. A constructive
way to show this is to construct a new
DFA from 2 old ones.
Constructive Proof

The proof is based on a construction that given two


DFAs A and B, produces a third DFA C such that
L(C) = L(A) ∩ L(B). The states of C are pairs
(p,q) , where p is a state of A and q is a state
of B. A transition labeled a leads from (p,q) to
(p',q') iff there are transitions

p
→ p '
a
q
→
a
q'
in A and B. The start state is the pair of original
start states; the final states are pairs of original
final states. The transition function
δA∩Β(q,a) = ( δA(q,a), δB(q,a) )
This is called the product construction.
Example 1 aa+aaa+aaaa
a+aa+aaa

What is the
intersection?

Make a new DFA


where states of the
new DFA are pairs of
states form the old
ones
Automata and Formal Languages

Lecture 9 Tim Sheard 10


Reachable states only

Intersection

{a,aa,aaa} ∩ {aa,aaa,aaaa}
Example 2
1
p 0 q A – string contains a 0
0,1

0
1
r s
0,1 B – string contains a 1

C – string contains a
0 and a 1
Automata and Formal Languages

Contains a “0”

Contains both a
“1” and a “0”

Contains a “1”

Lecture 9 Tim Sheard 13


As a Haskell Program

intersectDFA (DFA bigQ1 s1 d1 q10 f1)


(DFA bigQ2 s2 d2 q20 f2)
= DFA [(q1,q2) | q1 <- bigQ1, q2 <- bigQ2]
s1
(\ (q1,q2) a -> (d1 q1 a, d2 q2 a))
(q10,q20)
[(q1,q2) | q1 <- f1, q2 <- f2])
Difference

The identity:

L - M = L ∩ C(M)

reduces the closure under set-theoretical


difference operator to closure under
complementation and intersection.
M={aa,aaa,aaaa}
Example Difference
L={a,aa,aaa}

L - M = L ∩ C(M)

- =
Union

• The union of the languages of two DFAs (over the


same alphabet) is recognizable by another DFA.
• We reuse the product construction of the intersection
proof, but widen what is in the final states of the
constructed result.
Let A=(Qa,Σ,Ta,sa,Fa) and
B = (Qb,Σ,Tb,sb,Fb)

Then: A ∪ B =((Qa×Qb),Σ,δ,(sa,sb),Final)

Final = { (p,q) | p ∈ Fa, q ∈ Qb} ∪


{ (p,q) | p ∈ Qa, q ∈ Fb}

δ((a,b),x) = ( Τa(a,x), Τb(b,y) )


Automata and Formal Languages

B={bc}
A={ab}

A ∪ B ={ab,bc}

Lecture 9 Tim Sheard 18


Only reachable from start
As a Haskell Program
unionDFA (DFA bigQ1 s1 d1 q10 f1)
(DFA bigQ2 s2 d2 q20 f2)
= DFA [(q1,q2) | q1 <- bigQ1, q2 <- bigQ2]
s1
(\ (q1,q2) a -> (d1 q1 a, d2 q2 a))
(q10,q20)
([(q1,q2) | q1 <- f1, q2 <- bigQ2] ++
[(q1,q2) | q1 <- bigQ1, q2 <- f2])
Example Closure Construction

Given a language L, let L' be the set of all


prefixes of even length strings which
belong to L. We prove that if L is
regular then L' is also regular.

It is easy to show that prefix(L) is regular


when L is (How?). We also know that the
language Even of even length strings is
regular (How?). All we need now is to
note that
L' = Even ∩ prefix(L)
and use closure under intersection.
What’s next

We have given constructions for showing


that DFAs are closed under
1. Complement
2. Intersection
3. Difference
4. Union
In order to establish the closure properties
of
1. Reversal
2. Kleene star
3. Concatenation
We will need to introduce a new
computational system.

You might also like