Theory of Automata

Lecture – 1
Course Information
• Instructor: Arslan Tariq
• Email: arslantariq.fast@gmail.com
• Course information and updates will be posted on Google Classroom
• Schedule
• News and announcements
• Lecture Slides
• Assignments
• etc.
• Class Code is zamvmuh
Textbooks
• Introduction to Computer Theory
by Daniel Cohen
Grading Scheme
• Midterm 30%
• Sessional 30%
• Final 40%
Introduction – Automata Theory
Automata theory is the study of abstract machines and automata, as
well as the computational problems that can be solved using them
• Abstract Machine: Is a theoretical model of a computer hardware or software
• Automata: It comes from the Greek word αὐτόματα meaning "self-acting". So
it refers to a self-operating machine.

Automata play a major role in theory of computation, compiler

design, artificial intelligence, parsing and formal verification.
Introduction – Automata Theory
• Automaton:
• Its singular of automata.
• An automaton is a mathematical object that takes a word as input and
decides either to accept it or reject it.

• The set of words accepted by an automaton is called its language.

Introduction – Automata theory and formal
language theory
• Automata theory is also closely related to formal language theory.

• Formal Language: In mathematics, computer science, and linguistics,

a formal language is a set of strings of symbols that may be forced by
rules that are specific to it.

• An automaton is a finite representation of a formal language that may

be an infinite set.
Introduction – Our focus
Many computation models exist.
• Can’t cover them all.
Will concentrate on 3 groups of models:
1. Regular languages & Finite automata
2. Context-free languages & Push-down automata
3. Recursively-enumerable languages & Turing machines
A simple computer

BATTERY

input: switch
output: light bulb
actions: flip switch
states: on, off
A simple “computer”

BATTERY start off on

input: switch
output: light bulb
actions: f for “flip switch”
states: on, off
A simple “computer”

BATTERY start off on

input: switch
output: light bulb bulb is on if and only if
there was an odd number
actions: f for “flip switch” of flips
states: on, off
Another “computer”
1

BATTERY

inputs: switches 1 and 2

actions: 1 for “flip switch 1”
actions: 2 for “flip switch 2”
states: on, off
Another “computer” 1
1 start off off
1

2 2 2 2
BATTERY
1
2
off on
1

inputs: switches 1 and 2

actions: 1 for “flip switch 1”
actions: 2 for “flip switch 2”
states: on, off
Another “computer” 1
1 start off off
1

2 2 2 2
BATTERY
1
2
off on
1

inputs: switches 1 and 2

actions: 1 for “flip switch 1” bulb is on if and only if
actions: 2 for “flip switch 2” both switches were flipped
an odd number of times
states: on, off
Introduction to languages
Kinds of languages:

• Talking language
• Programming language
• Formal Languages
Alphabets
• Definition:
A finite non-empty set of symbols (letters), is called an
alphabet. It is denoted by Σ ( Greek letter sigma).

• Example:
Σ={a,b}
Σ={0,1} // important as this is the language
//which the computer understands.
Σ={i,j,k}
• A certain version of language ALGOL has 113 letters.
Strings
• Definition:
Concatenation of finite symbols from the alphabet is called a string.

• Example:
If Σ= {a,b} then a, abab, aaabb, ababababababababab
Words
• Definition:
Words are strings belonging to some language.

• Example:
If Σ= {a} then a language L can be defined as L={an :
n=1,2,3,…..} or L={a,aa,aaa,….}

Here a,aa,… are the words of L

NOTE:

All words are strings, but not all strings are words
 Language

Language is the set of all words of terminal symbols derivable from

alphabet.
NOTE:
EMPTY STRING or NULL STRING

• Sometimes a string with no symbol at all is used,

denoted by (Small Greek letter Lambda) λ or (Capital
Greek letter Lambda) Λ, is called an empty string or
null string.

• The capital lambda will mostly be used to denote the

empty string, in further discussion.
Valid/In-valid alphabets
• While defining an alphabet, an alphabet may contain letters
consisting of group of symbols for example Σ1= {B, aB, bab, d}.

• Now consider an alphabet

Σ2= {B, Ba, bab, d} and a string BababB
Valid/In-valid alphabets
• This BababB (string) can be tokenized in two different
ways
• (Ba), (bab), (B)
• (B), (abab), (B)

• Which shows that the second group cannot be

identified as a string, defined over
Σ2= {B, Ba, bab, d}
Valid/In-valid alphabets
• As when this string is scanned by the compiler (Lexical Analyzer), first
symbol B is identified as a letter belonging to Σ, while for the second
letter the lexical analyzer would not be able to identify, so while
defining an alphabet it should be kept in mind that ambiguity should
not be created.
Conclusion
• Σ1= {B, aB, bab, d}
• Σ2= {B, Ba, bab, d}

• Σ1 is a valid alphabet while Σ2 is an in-valid alphabet.

Length of Strings

• Definition:
The length of string s, denoted by |s|, is the number
of letters in the string.

• Example:
Σ={a,b}
s=ababa
|s|=5
• Example:
Σ= {B, aB, bab, d}
s=BaBbabBd
Tokenizing=(B), (aB), (bab), (B), (d) |s|=5
Reverse of a String

• Definition:
The reverse of a string s denoted by Rev(s) or sr, is
obtained by writing the letters of s in reverse order.
• Example:
If s = abc is a string defined over
Σ={a,b,c} then
Rev(s) or sr = cba
Reverse of a String
• Example:
Σ= {B, aB, bab, d}
s=BaBbabBd
Tokenizing=(B) (aB) (bab) (B) (d)

Rev(s)=dBbabaBB
Defining Languages
• The languages can be defined in different ways , such
as
1. Descriptive definition,
2. Recursive definition,
3. using Regular Expressions(RE) and
4. using Finite Automaton(FA) etc.

• Descriptive definition of language:

The language is defined, describing the conditions
imposed on its words.
• Example:
The language L of strings of odd length, defined over
Σ={a}, can be written as
L={a, aaa, aaaaa,…..}
• Example:
The language L of strings that does not start with a,
defined over Σ={a,b,c}, can be written as
L={b, c, ba, bb, bc, ca, cb, cc, …}
• Example:
The language L of strings of length 2, defined over
Σ={0,1,2}, can be written as
L={00, 01, 02,10, 11,12,20,21,22}

• Example:
The language L of strings ending in 0, defined over
Σ ={0,1}, can be written as
L={0,00,10,000,010,100,110,…}
• Example:
The language EQUAL, of strings with number of a’s
equal to number of b’s, defined over Σ={a,b}, can be
written as
{Λ ,ab,aabb,abab,baba,abba,…}
• Example:
The language EVEN-EVEN, of strings with even number
of a’s and even number of b’s, defined over Σ={a,b}, can
be written as
{Λ, aa, bb, aaaa,aabb,abab, abba, baab, baba, bbaa,
bbbb,…}
• Example:
The language INTEGER, of strings defined over Σ={-
,0,1,2,3,4,5,6,7,8,9}, can be written as
INTEGER = {…,-2,-1,0,1,2,…}

• Example:
The language EVEN, of stings defined over
Σ={-,0,1,2,3,4,5,6,7,8,9}, can be written as
EVEN = { …,-4,-2,0,2,4,…}
• Example:
The language {anbn}, of strings defined over Σ={a,b}, as
{anbn : n=1,2,3,…}, can be written as
{ab, aabb, aaabbb,aaaabbbb,…}
• Example:
The language {anbn an}, of strings defined over Σ={a,b},
as {anbn an : n=1,2,3,…}, can be written as
{aba, aabbaa, aaabbbaaa,aaaabbbbaaaa,…
• Example:
The language factorial, of strings defined over
Σ={0,1,2,3,4,5,6,7,8,9} i.e.

{1,2,6,24,120,…}

• Example:
The language FACTORIAL, of strings defined over Σ={a}, as
{an! : n=1,2,3,…}, can be written as

{a,aa,aaaaaa,…}.
• Example:
The language DOUBLEFACTORIAL, of strings defined
over Σ={a, b}, as {an! bn! : n=1,2,3,…}, can be written
as
{ab, aabb, aaaaaabbbbbb,…}

• Example:
The language SQUARE, of strings defined over Σ={a},
as
{an2 : n=1,2,3,…}, can be written as
{a, aaaa, aaaaaaaaa,…}
• Example:
The language DOUBLESQUARE, of strings defined over Σ={a,b}, as
{an2 bn2 : n=1,2,3,…}, can be written as
{ab, aaaabbbb, aaaaaaaaabbbbbbbbb,…}
• Example:
The language PRIME, of strings defined over Σ={a}, as
{ap : p is prime}, can be written as
{aa,aaa,aaaaa,aaaaaaa,aaaaaaaaaaa…}
An Important language

• PALINDROME
The language consisting of Λ and the strings s defined
over Σ such that Rev(s)=s. It is to be denoted that
the words of PALINDROME are called palindromes.

• Example:
For Σ={a,b}, PALINDROME={Λ , a, b, aa, bb, aaa,
aba, bab, bbb, ...}
Kleene Star Closure

• Given Σ, then the Kleene Star Closure of the alphabet Σ, denoted by

Σ*, is the collection of all strings defined over Σ, including Λ.

• It is to be noted that Kleene Star Closure can be defined over any set
of strings.
Examples
• If Σ = {x}
Then Σ* = {Λ, x, xx, xxx, xxxx, ….}

• If Σ = {0,1}
Then Σ* = {Λ, 0, 1, 00, 01, 10, 11, ….}

• If Σ = {aaB, c}
Then Σ* = {Λ, aaB, c, aaBaaB, aaBc, caaB,
cc, ….}
Note
• Languages generated by Kleene Star Closure of set of strings, are
infinite languages.

• (By infinite language, it is supposed that the language contains infinite

many words, each of finite length).
PLUS Operation (+)

• Plus Operation is same as Kleene Star Closure except

that it does not generate Λ (null string),
automatically.
• Example:
• If Σ = {0,1}
Then Σ+ = {0, 1, 00, 01, 10, 11, ….}
• If Σ = {aab, c}
Then Σ+ = {aab, c, aabaab, aabc, caab, cc, ….}
Remark

• It is to be noted that Kleene Star can also be operated

on any string i.e. a* can be considered to be all
possible strings defined over {a}, which shows that a*
generates Λ, a, aa, aaa, …

• It may also be noted that a+ can be considered to be

all possible non empty strings defined over {a}, which
shows that a+ generates
a, aa, aaa, aaaa, …
Defining Languages Continued…
• Recursive definition of languages:

• The following three steps are used in recursive

definition
1. Some basic words are specified in the language.
2. Rules for constructing more words are defined in
the language.
3. No strings except those constructed in above, are
allowed to be in the language.
Example

• Defining language of INTEGER

• Step 1: 1 is in INTEGER.

• Step 2: If x is in INTEGER then x+1 and x-1 are also

in INTEGER.

• Step 3: No strings except those constructed in

above, are allowed to be in INTEGER.
Example

• Defining language of EVEN

• Step 1: 2 is in EVEN.

• Step 2: If x is in EVEN then x+2 and x-2 are also in

EVEN.

• Step 3: No strings except those constructed in

above, are allowed to be in EVEN.
Example
• Defining the language factorial

• Step 1: As 0!=1, so 1 is in factorial.

• Step 2: n!=n*(n-1)! is in factorial.

• Step 3: No strings except those constructed in

above, are allowed to be in factorial.
Defining the language PALINDROME, defined over Σ = {a,b}

• Step 1: a and b are in PALINDROME

• Step 2: if x is palindrome, then s(x)Rev(s) and xx

will also be palindrome, where s belongs to Σ*

• Step 3: No strings except those constructed in

above, are allowed to be in palindrome
Defining the language {anbn }, n=1,2,3,… , of
strings defined over Σ={a,b}

• Step 1: ab is in {anbn}

• Step 2: if x is in {anbn}, then axb is in {anbn}

• Step 3: No strings except those constructed

in above, are allowed to be in {anbn}
Defining the language L, of strings ending in a , defined over
Σ={a,b}
• Step 1: a is in L

• Step 2: if x is in L then s(x) is also in L, where s belongs to Σ*

• Step 3: No strings except those constructed in above, are allowed

to be in L
Defining the language L, of strings beginning and ending in same
letters , defined over Σ={a, b}

• Step 1: a and b are in L

• Step 2: (a)s(a) and (b)s(b) are also in L, where s

belongs to Σ*

• Step 3: No strings except those constructed in

above, are allowed to be in L
Defining the language L, of strings containing aa or bb , defined
over Σ={a, b}

• Step 1: aa and bb are in L

• Step 2: s(aa)s and s(bb)s are also in L, where s

belongs to Σ*

• Step 3: No strings except those constructed in

above, are allowed to be in L
Defining the language L, of strings containing exactly aa, defined
over Σ={a, b}

• Step 1: aa is in L

• Step 2: s(aa)s is also in L, where s belongs to b*

• Step 3: No strings except those constructed in

above, are allowed to be in L
Prove that for any set of strings S
(S+)*=(S*)*

Solution: In general Λ is not in S+ , while Λ does belong to S*.

Obviously Λ will now be in (S+)*, while (S*)* and S* generate the
same set of strings. Hence (S+)*=(S*)*.
• ii) (S+)+=S+

Solution: since S+ generates all possible strings that can be obtained

by concatenating the strings of S, so (S+)+ generates all possible
strings that can be obtained by concatenating the strings of S+ , will
not generate any new string. Hence (S+)+=S+
• Is (S*)+ =(S+)*

• Solution: since Λ belongs to S* ,so Λ will belong to (S*)+ as member of

S* .Moreover Λ may not belong to S+, in general, while Λ will
automatically belong to (S+)*. Hence
(S*)+ =(S+)*