FORMAL LANGUAGE AND

AUTOMATA THEORY

A Technical Report Submitted in partial fulfillment of the requirements for the

Continuous Internal Evaluation II for the subject of
Formal Language And Automata Theory(PCC-CS-403)

by

Name :– Ayan Saha

College Roll No. :- CSE/21/007
University Roll No. :-10700121101

Under the supervision of

Prof-Lipika Dinda

DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

COLLEGE OF ENGINEERING & MANAGEMENT, KOLAGHAT

(Affiliated to Maulana Abul Kalam Azad University of Technology)

Purba Medinipur – 721171, West Bengal, India

  CONTENTS

1. Introduction.

2. Differentiate Kleene Star Closure And Kleen Plus? Draw a minimal DFA where
second and fourth bit is k for the input alphabets {k,h}.
3. What is the importance of automata? Define types of automata? Draw a minimal
DFA which accepts odd number of b for input alphabets {b,c}.
4. Define possible strings for input alphabet {f,g,h}. Draw a minimal DFA which
accepts even number of g for input alphabets {f,g}.
5. Conclusion

. 6.Reference.
INTRODUCTION:-

FLAT stands for "Formal Language and Automata Theory". It is a branch of computer
science and mathematics that deals with the study of formal languages, automata, and their
properties.
A formal language is a set of strings over a certain alphabet, where an alphabet is a set of
symbols or characters. Formal languages are used in computer science to describe
programming languages, communication protocols, and other types of formal specifications.
They are also used in linguistics to study the structure of natural languages.
An automaton is a mathematical model that describes a system that changes from one state to
another in response to input. An automaton consists of a finite set of states and a set of rules
that describe how the system moves from one state to another. Automata are used in
computer science to model computations and to recognize patterns in input data.
The study of formal languages and automata theory is important in computer science because
it provides a theoretical foundation for the design and analysis of algorithms, programming
languages, compilers, and other software tools. It also has applications in other fields, such as
linguistics, artificial intelligence, and cryptography.
The study of FLAT includes the following topics:
 Regular Languages and Regular Expressions
 Finite Automata (DFA, NFA)
 Pushdown Automata
 Context-Free Grammars and Languages
 Turing Machines and Computability Theory
 Complexity Theory and P vs. NP problem
 Compiler Design and Parsing techniques
FLAT is an important and fundamental area of computer science that provides a theoretical
framework for many other fields in the discipline.
2. Differentiate Kleene Star Closure And Kleen Plus?
Kleene star closure and Kleene plus are two operations used in regular expressions to specify
how many times a particular character or subexpression can occur within a given string.
The Kleene star closure is denoted by an asterisk (), and it means that the preceding
character or subexpression can occur zero or more times. For example, the regular
expression "a" matches any string that contains zero or more occurrences of the character
"a".
The Kleene plus is denoted by a plus sign (+), and it means that the preceding character or
subexpression must occur one or more times. For example, the regular expression "a+"
matches any string that contains one or more occurrences of the character "a".
To summarize:
 Kleene star closure (*) means zero or more occurrences of the preceding character or
subexpression.
 Kleene plus (+) means one or more occurrences of the preceding character or
subexpression.
Draw a minimal DFA where second and fourth bit is k for the
input alphabets {k,h}.

Here is the minimal DFA for the input alphabet {k,h}, where the second and fourth bits are
"k":

/- k -\
| |
--->(q0)-- h -->[(q1)]
| |
\- k -/

In this DFA, there are two states: q0 and q1. The initial state is q0, and the accepting state is
q1.
If the input starts with h, the DFA moves from q0 to itself, since the second bit is not "k". If
the input starts with k, the DFA moves to state q1, since the second bit is "k".
Once the DFA reaches state q1, it will accept any input string, whether it starts with k or h,
since the fourth bit is also "k" in both cases.
Note that this DFA is minimal because there are only two possible states: either the second
and fourth bits are "k" (state q1), or they are not (state q0).
3. What is the importance of automata?
Automata theory is a fundamental part of computer science and plays a significant role in
various areas of computing, including software engineering, programming language design,
natural language processing, and artificial intelligence. Here are some of the key importance
of automata:
1. Language Design: Automata theory provides a theoretical basis for the design and
analysis of formal languages. It helps in defining the syntax of programming
languages, which is essential for developing compilers and interpreters.
2. Compiler Design: Automata theory is used in compiler design for analyzing and
manipulating the structure of programming languages. It helps in building efficient
compilers that can translate high-level code to machine code.
3. Natural Language Processing: Automata theory is used in natural language processing
to analyze and understand human language. It helps in developing tools for text
processing, sentiment analysis, and machine translation.
4. Artificial Intelligence: Automata theory is used in artificial intelligence to model and
simulate intelligent behavior. It helps in developing intelligent systems that can
reason, learn, and adapt to new situations.
5. Verification and Validation: Automata theory is used in verification and validation of
software and hardware systems. It helps in detecting errors and ensuring that systems
meet their specifications.
In summary, automata theory provides a formal and rigorous framework for modeling and
analyzing complex systems, which is essential for developing reliable and efficient software
and hardware systems.

Define types of automata?

There are several types of automata in automata theory, which differ in their capabilities and
the types of languages they can recognize. Here are some of the most common types of
automata:
1. Finite Automata (FA): A finite automaton is a simple type of automaton that reads
input from a tape and moves through a finite set of states based on the input. It accepts
or rejects the input based on whether it ends up in an accepting or rejecting state.
Finite automata are used to recognize regular languages.
2. Pushdown Automata (PDA): A pushdown automaton is a type of automaton that has a
stack to store and retrieve information while processing input. It reads input from a
tape and moves through a finite set of states based on the input and the contents of the
stack. Pushdown automata are used to recognize context-free languages.
 3. Turing Machine (TM): A Turing machine is a type of automaton that can simulate any
computer algorithm. It consists of a tape and a head that can read and write to the
tape. It moves through a finite set of states based on the input and the contents of the
tape. Turing machines are used to recognize recursively enumerable languages.
4. Linear Bounded Automaton (LBA): A linear bounded automaton is a type of Turing
machine that is restricted to using a tape whose length is proportional to the length
of the input. LBAs are used to recognize context-sensitive languages.
5. Non-deterministic Finite Automata (NFA): A non-deterministic finite automaton is a
type of finite automaton that can be in multiple states at the same time. It reads input
from a tape and moves through a set of states based on the input and the possible
transitions. NFAs are equivalent in power to DFAs but are easier to construct.
These are some of the most common types of automata used in automata theory. Each type of
automaton has its strengths and limitations, and the choice of which to use depends on the
type of language being recognized and the computational resources available.

Draw a minimal DFA which accepts odd number of b for

input alphabets {b,c}
Here is the minimal DFA that accepts odd numbers of b for the input alphabet {b, c}:

/-- b -->[(q1)]
| |
--->(q0)-- c -->[q0]
| |
\-- b -->[(q2)]

In this DFA, there are three states: q0, q1, and q2. The initial state is q0, and the accepting
state is q1.
If the input is c, the DFA stays in state q0, since there are no bs in the input. If the input is b,
the DFA transitions to either q1 or q2, depending on whether the number of bs seen so far is
odd or even, respectively.
Once the DFA reaches state q1, it will accept any input string that has an odd number of bs,
since it has seen an odd number of bs so far. If the DFA reaches state q2, it will accept any
input string that has an even number of bs, since it has seen an even number of bs so far.
Note that this DFA is minimal because there are three possible states: either the number of
bs seen so far is odd (state q1), even (state q2), or none (state q0)
4. Define possible strings for input alphabet {f,g,h}.
The possible strings that can be formed from an input alphabet {f, g, h} are all the possible
combinations of the letters from the alphabet. In other words, any sequence of letters that can
be formed using only the letters f, g, and h is a possible string for this alphabet.
Here are some examples of possible strings for the input alphabet {f, g, h}:
 f
 g
 h
 fg
 gf
 fh
 hf
 gh
 hg
 fgh
 gfh
 hgf
 fhg
 ghf
 hfg
 and so on...
The number of possible strings that can be formed from an input alphabet depends on the
length of the strings and the size of the alphabet. For an alphabet with n letters, the number of
possible strings of length k is n^k. For example, for the alphabet {f, g, h} and strings of
length 2, there are 27 possible strings (3^2 = 9 possible combinations of letters, each of which
can be repeated in the first and second positions).

Draw a minimal DFA which accepts even number of g for

input alphabets {f,g}
Here is the minimal DFA that accepts an even number of g for the input alphabet {f, g}:

/-- g -->[(q1)]
| |
--->(q0)-- f -->[q0]
| |
\-- g -->[(q2)]

In this DFA, there are three states: q0, q1, and q2. The initial state is q0, and the accepting
state is q0.
If the input is f, the DFA stays in state q0, since there are no gs in the input. If the input is g,
the DFA transitions to either q1 or q2, depending on whether the number of gs seen so far is
odd or even, respectively.
Once the DFA reaches state q0, it will accept any input string that has an even number of gs,
since it has seen an even number of gs so far. If the DFA reaches state q1 or q2, it will accept
any input string that has an odd number of gs, since it has seen an odd number of gs so far.
Note that this DFA is minimal because there are three possible states: either the number of
gs seen so far is odd (state q1), even (state q2), or none (state q0).
5.CONCLUSION:-
In conclusion, Formal Language and Automata Theory (FLAT) is a branch of computer
science and mathematics that deals with the study of formal languages and automata. It is an
important field that provides a theoretical foundation for the design and analysis of
algorithms, programming languages, compilers, and other software tools. The study of FLAT
includes various topics such as regular languages and expressions, finite automata, pushdown
automata, context-free grammars and languages, Turing machines, complexity theory, and
compiler design. FLAT has applications in many fields such as linguistics, artificial
intelligence, and cryptography. It is an essential area of study for computer science students
and researchers.

6.REFERENCES:-
 "Introduction to the Theory of Computation" by Michael Sipser
 "Automata Theory, Languages, and Computation" by John E. Hopcroft,
Rajeev Motwani, and Jeffrey D. Ullman
 https://www.tutorialspoint.com/automata_theory/automata_theory_introduction.htm
 https://www.geeksforgeeks.org/kleenes-theorem-in-toc-part-1/
