Scribd
Upload
15 views35 pages

Compsci 102 Discrete Math For Computer Science: Feb. 2, 2012 Prof. Rodger

This document contains lecture slides on deterministic finite automata (DFAs) from a computer science course. It includes: - Definitions and examples of DFA components like states, transitions, accepting states. - Examples of DFA diagrams that recognize languages like strings with an even number of 1s. - Theorems showing that regular languages are closed under operations like union and regular expressions. - A proof using the pigeonhole principle that the language of strings with an equal number of a's and b's is not a regular language and cannot be recognized by a DFA.

Uploaded by

Beverly Paman
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
15 views35 pages

Compsci 102 Discrete Math For Computer Science: Feb. 2, 2012 Prof. Rodger

This document contains lecture slides on deterministic finite automata (DFAs) from a computer science course. It includes: - Definitions and examples of DFA components like states, transitions, accepting states. - Examples of DFA diagrams that recognize languages like strings with an even number of 1s. - Theorems showing that regular languages are closed under operations like union and regular expressions. - A proof using the pigeonhole principle that the language of strings with an equal number of a's and b's is not a regular language and cannot be recognized by a DFA.

Uploaded by

Beverly Paman
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 35

CompSci 102

Discrete Math for Computer Science

Feb. 2, 2012
Prof. Rodger

Slides from Maggs, lecture developed by Steven Rudich at CMU

Deterministic
Finite
Automata

Let me show you a


machine so simple
that you can
understand it in
less than two
minutes

11

1
0,1

1
0111

111

1
0

0
1

The machine accepts a string if the


process ends in a double circle
Steven Rudich:
www.cs.cmu.edu/~rudich

Anatomy of a Deterministic Finite


1
Automaton
0
states

1
q1
0

0,1
accept states (F)

0
q12

q0

The machine accepts a string if the


start state
(q0) ends in
q3a double circle
states
process
Steven Rudich:
www.cs.cmu.edu/~rudich

Anatomy of a Deterministic Finite


Automaton
q1

1
0,1

1
q0

q2

0
0
The alphabet of a finite automaton is the
1{0,1}
set where the symbols come from:
q3
The language of a finite automaton is the
Rudich:
set of strings thatwww.cs.cmu.edu/~rudich
itSteven
accepts

q0

0,1

L(M) =All
strings of 0s and 1s
The Language of Machine M

Steven Rudich:
www.cs.cmu.edu/~rudich

q0

1
1

q1

{ w | w has an even number of 1s}


L(M) =

Steven Rudich:
www.cs.cmu.edu/~rudich

Notation
An alphabet is a finite set (e.g., = {0,1})
A string over is a finite-length sequence of
elements of
For a string x, |x| isthe length of x
The unique string of length 0 will be
denoted by and will be called the empty or
null string
A language over is a set of strings over
Steven Rudich:
www.cs.cmu.edu/~rudich

A finite automaton is a 5-tuple M = (Q, , , q0, F)


Q is the set of states
is the alphabet
: Q Q is the transition function
q0 Q is the start state
F Q is the set of accept states
L(M) = the language of machine M
= set of all strings machine M
accepts
Steven Rudich:
www.cs.cmu.edu/~rudich

M = (Q, , , q0, F)
where

Q = {q0, q1, q2, q3}


= {0,1}
: Q Q transition function
q0 Q is start state
F = {q1, q2} Q accept states

q1

0
1
q0
0

M
q3

1
0,1

q2
0
1
Steven Rudich:
www.cs.cmu.edu/~rudich

q0

q0

q1

q1

q2

q2

q2

q3

q2

q3

q0

q2

Build an automaton that accepts all and


only those strings that contain 001
1

0,1

0
0
1

q0

q00

Steven Rudich:
www.cs.cmu.edu/~rudich

q001

A language is regular if it is
recognized (accepted) by a
deterministic finite automaton
L = { w | w contains 001} is regular
L = { w | w has an even number of 1s} is regular

Steven Rudich:
www.cs.cmu.edu/~rudich

Union Theorem
Given two languages, L1 and L2,
define the union of L1 and L2 as
L1 L2 = { w | w L1 or w L2 }
Theorem: The union of two regular
languages is also a regular
language

Steven Rudich:
www.cs.cmu.edu/~rudich

Theorem: The union of two regular


languages is also a regular
language
Proof Sketch: Let
M1 = (Q1, , 1, 1q0, F1) be finite automaton for
L1
2

and
M2 = (Q2, , 2, q0, F2) be finite automaton for
We
L2 want to construct a finite automaton
M = (Q, , , q0, F) that recognizes L = L1
L2

Steven Rudich:
www.cs.cmu.edu/~rudich

Idea: Run both M1 and M2 at the same


time!
Q = pairs of states, one from M1 and one from M2
= { (q1, q2) | q1 Q1 and q2 Q2 }
= Q1 Q2

Steven Rudich:
www.cs.cmu.edu/~rudich

Theorem: The union of two regular


languages is also a regular
language
0
0

q0

1
1

q1

p0
Steven Rudich:
www.cs.cmu.edu/~rudich

0
0

p1

Automaton for Union


1
q0,p0

q1,p0

1
0

1
q0,p1

q1,p1

1
Steven Rudich:
www.cs.cmu.edu/~rudich

Automaton for
Intersection
1

q0,p0

q1,p0

1
0

1
q0,p1

q1,p1

1
Steven Rudich:
www.cs.cmu.edu/~rudich

Theorem: The union of two regular


languages is also a regular
language
Corollary: Any finite language is
regular

Steven Rudich:
www.cs.cmu.edu/~rudich

The Regular Operations


Union: A B = { w | w A or w B }
Intersection: A B = { w | w A and w B }
Reverse: AR = { w1 wk | wk w1 A }
Negation: A = { w | w A }

Concatenation: A B = { vw | v A and w B }
Star: A* = { w1 wk | k 0 and each wi A }
Steven Rudich:
www.cs.cmu.edu/~rudich

Regular Languages Are


Closed Under The
Regular Operations
We have seen part of the proof for
Union. The proof for intersection is
very similar. The proof for negation is
easy.
Steven Rudich:
www.cs.cmu.edu/~rudich

The Grep Problem


Input: Text T of length t, string S of length n
Problem: Does string S appear inside text T?
Nave method:

a1, a2, a3, a4, a5, , at


Cost: Roughly nt comparisons

Automata Solution
Build a machine M that accepts any
string with S as a consecutive substring
Feed the text to M
Cost: t comparisons + time to build M
As luck would have it, the Knuth, Morris,
Pratt algorithm builds M quickly

Real-life Uses of DFAs


Grep
Coke Machines
Thermostats (fridge)
Elevators
Train Track Switches
Lexical Analyzers for Parsers

Are all
languages
regular?

Consider the language L = { anbn | n > 0 }


i.e., a bunch of as followed by an
equal number of bs
No finite automaton accepts this language
Can you prove this?

anbn is not regular.


No machine has
enough states to
keep track of the
number of as it
might encounter

That is a fairly weak


argument
Consider the following
example

L = strings where the # of occurrences


of the pattern ab is equal to the
number of occurrences of the pattern
ba
Cant be regular. No machine has
enough states to keep track of
the number of occurrences of ab

a
b

b
a

M accepts only the strings with


an equal number of abs and
bas!

Let me show you a


professional strength
proof that anbn is not
regular

Pigeonhole principle:
Given n boxes and m >
n objects, at least one
box must contain more
than one object

Letterbox principle:
If the average number
of letters per box is x,
then some box will
have at least x letters
(similarly, some box
has at most x)

Theorem: L= {anbn | n > 0 } is not regular


Proof (by contradiction):
Assume that L is regular
Then there exists a machine M with k
states that accepts L
For each 0 i k, let Si be the state M is
in after reading ai
i,j k such that Si = Sj, but i j
M will do the same thing on aibi and ajbi
But a valid M must reject ajbi and accept aibi

Deterministic Finite
Automata
Definition
Testing if they accept a string
Building automata

Regular Languages
Heres What
You Need to
Know

Definition
Closed Under Union,
Intersection, Negation
Using Pigeonhole Principle to
show language aint regular

You might also like