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 | xA and yB }

• 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,

AA = { (0,0), (0,00), (00,0), (00,00) } with |AA|=4

Recognizing Languages

• Let L be a language S

• a machine M recognizes L if

MxS

“accept”

“reject” if and only if xL

if and only if xL

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)

q1 q2 q3

1 0

0,1

0 1

statestransition rules

starting state

accepting state

A Simple Automaton (1)

q1 q2 q3

1 0

0,1

0 1

on input “0110”, the machine goes:q1 q1 q2 q2 q3 = “reject”

start

accept

A Simple Automaton (2)

q1 q2 q3 q2 = “accept”

q1 q2 q3

1 0

0,1

0 1

on input “101”, the machine goes:

A Simple Automaton (3)

010: reject11: accept010100100100100: accept010000010010: reject: reject

q1 q2 q3

1 0

0 1

0,1

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 :QQ

– q0Q: start state

– FQ: set of accepting states

M = <Q,,,q,F>

states Q = {q1,q2,q3}

alphabet = {0,1}

start state q1

accept states F={q2}

transition function :

223

232

211

10

qqq

qqq

qqq

q1 q2 q3

1 0

0 1

0,1

0 1

q1 q1 q2

q2 q3 q2

q3 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.