Languages
• Given an alphabet , we can make a word or
string by concatenating the letters of .
• Concatenation of “x” and “y” is “xy”
• Typical example: ={0,1}, the possible words
over  are the finite bit strings.
• A language is a set of words.
More about Languages
• The empty string  is the unique string with zero
length.
• Concatenation of two langauges:
A • B = { xy | xA and yB }
• Typical examples:
L = { x | x is a bit string with two zeros }
L = { anbn | n  N }
L = {1n | n is prime}
A Word of Warning
Do not confuse the concatenation of languages with
the Cartesian product of sets.
For example, let A = {0,00} then
A•A = { 00, 000, 0000 } with |A•A|=3,
AA = { (0,0), (0,00), (00,0), (00,00) }
with |AA|=4
Recognizing Languages
• Let L be a language  S
• a machine M recognizes L if
xS
“accept”
if and only if xL
“reject”
if and only if xL
M
Finite Automaton
The most simple machine that is not just a finite list of words.
“Read once”, “no write” procedure.
It has limited memory to hold the “state”.
Examples: vending machine, cell-phone, elevator, etc.
A Simple Automaton (0)
transition
rules
states
0
1
1
q1
0
q2
q3
0,1
starting state
accepting state
A Simple Automaton (1)
0
1
1
q1
0
q2
start
q3
0,1
accept
on input “0110”, the machine goes:
q1  q1  q2  q2  q3 = “reject”
A Simple Automaton (2)
0
1
1
q1
0
q2
q3
0,1
on input “101”, the machine goes:
q1  q2  q3  q2 = “accept”
A Simple Automaton (3)
0
1
1
q1
0
q2
q3
0,1
010: reject
11: accept
010100100100100: accept
010000010010: reject
: reject
The set of strings accepted by a
DFA M is denoted by L(M), the
language of the machine M.
We want to build DFA for various languages and also want to
understand the ones for which we can’t build a DFA.
Finite Automaton (definition)
• A deterministic finite automaton (DFA)
M is defined by a 5-tuple M=(Q,,,q0,F)
–
–
–
–
–
Q: finite set of states
: finite alphabet
: transition function :QQ
q0Q: start state
FQ: set of accepting states
M = <Q,,,q,F>
states Q = {q1,q2,q3}
1
0
1
alphabet  = {0,1}
0
q1
start state q1
q2
q3
accept states F={q2}
0,1
0
transition function :
q1 q q1
1
q2q q3
q3
10
q1
q2
1
q2
2
q3
q2
q3
q2
q2
q2
q2
q2
Recognizing Languages (definition)
A finite automaton M = (Q,,,q,F) accepts a string/word
w = w1…wn if and only if there is a sequence r0…rn of
states in Q such that:
1) r0 = q0
2) (ri,wi+1) = ri+1 for all i = 0,…,n–1
3) rn  F
Regular Languages
The language recognized by a finite automaton M is
denoted by L(M).
A regular language is a language for which there exists a
recognizing finite automaton.
Examples of regular languages
L1 = { x | x has an odd number of 1’s } over alphabet {0, 1}
L2 = { x | x has at least one 0 and at least one 1}
over alphabet {0, 1}
L3 = { x | x represents a positive integer that is divisible by 3}
We will show that each of these languages is regular by building a
DFA.