DAYANANDA SAGAR ACADEMY OF TECHNOLOGY AND

MANAGEMENT
(Autonomous Under VTU)
Opp. Art of Living, Udayapura, Kanakapura Road, Bangalore- 560082
IQAC, DSATM
(Affiliated to Visvesvaraya Technological University, Belagavi and Approved by AICTE, New
Delhi) CE, CSE, ECE, EEE, ISE and ME are Accredited by NBA, New Delhi
NAAC Accredited with A+ Grade

THEORY OF COMPUTATION (BCS503)

Continuous Comprehensive Assessment

Report On

THEORY OF COMPUTATION USING JFLAP

Submitted by

USN Student Name

1DT22IS016 ANUSHREE G M

V Semester, Bachelor of Engineering in

Information Science and Engineering

Course Handling Faculty

Ms. Surabhi K R
Assistant Professor
Dept. of ISE, DSATM Bangalore.

Academic Year 2024-25

 Table of Contents

Sl. No Topic Page No

1 JFLAP INTRODUCTION 3
2 PROBLEM 1: FINITE AUTOMATA 4-5
3 PROBLEM 2: FINITE AUTOMATA(NFA) 5-6
4 PROBLEM 3: GRAMMAR REGULAR EXPRESSION 6-7
5 PROBLEM 4: PUSHDOWN AUTOMATA 8-9
6 PROBLEM 5: TURING MACHINE 9-11
7 LEARNING OUTCOMES 12
8 CONCLUSION 13
9 REFERENCES 13
Introduction to JFLAP
JFLAP (Java Formal Languages and Automata Package) is a software tool
designed to help students and educators understand concepts in formal
languages, automata theory, and computability. It provides a user-friendly
interface for constructing and simulating various computational models,
including finite automata, pushdown automata, Turing machines, and
contextfree grammars. JFLAP is widely used in computer science education,
particularly in courses related to theoretical computer science. Key Features
of JFLAP
1. Graphical Interface: JFLAP offers a graphical user interface that allows
users to create and manipulate automata and grammars visually. This
makes it easier to understand the structure and behavior of different
computational models.
2. Simulation: Users can simulate the operation of automata and Turing
machines on input strings. This feature helps in visualizing how the
automaton processes the input and transitions between states.
3. Conversion Tools: JFLAP provides tools for converting between different
types of automata (e.g., from nondeterministic finite automata to
deterministic finite automata) and for converting context-free grammars to
pushdown automata.
4. Grammar and Language Tools: Users can create context-free grammars
and see the derivation of strings, as well as check if a string belongs to the
language generated by a given grammar.
5. Turing Machines: JFLAP allows users to design and simulate Turing
machines, providing a platform to explore concepts of decidability and
computability.
6. Educational Resource: JFLAP is often used in academic settings to
supplement theoretical coursework. It helps students visualize complex
concepts and provides hands-on experience with formal languages and
automata.

3
 1. L = {w  {a, b}* : every a region in w is of even length}
We need to design a Finite Automaton (FA) or NFA (Non-deterministic Finite Automaton) that
accepts strings where every contiguous sequence of 'a's (a-region) has an even length. We can approach
this by keeping track of the even-length 'a' regions.
Approach:

• A region is of even length if the number of consecutive 'a's is divisible by 2.

• We will use two states:

o q0 (even count of 'a's): Starting state and accepting state when the number of
'a's is even.

o q1 (odd count of 'a's): A non-accepting state when the number of 'a's is odd.

• Transitions:

o From q0:

▪ On 'a', go to q1 (odd-length region).

▪ On 'b', stay at q0 (because 'b' doesn't affect the count of 'a's).

o From q1:

▪ On 'a', go to q0 (even-length region).

▪ On 'b', stay at q1 (because 'b' doesn't affect the count of 'a's).

4
 2. Design an NFA with ∑ = {a, b} accepts all string starting with a.
The goal is to create a NFA that accepts all strings starting with 'a'. This NFA will only reject
strings that start with 'b'.

Approach:

• We will create two states:

o q0: The starting state. If the first symbol is 'a', we will accept.

o q1: This is an accepting state where we have already encountered an 'a', so we can
accept the rest of the string.

• Transitions:

o From q0:

▪ On 'a', go to q1.

▪ On 'b', go to a dead state (we will not accept strings starting with 'b').

o From q1:

▪ On both 'a' and 'b', stay at q1

• Start state: q0.
• Accept state: q1.
• Dead state: A non-accepting state that absorbs strings starting with 'b'

5
3. Obtain the Regular Expression for L = {w: n_a(w) mod 3 = 0, w
∈ (a,b)*}
We want a regular expression for strings where the number of 'a's is a multiple of 3 (i.e.,
na(w)mod 3=0n_a(w) \mod 3 = 0na(w)mod3=0).

Approach:To construct a regular expression for this, we need a pattern that ensures the
number of 'a's is a multiple of 3. The simplest way to achieve this is by having groups of
exactly three 'a's, with any number of 'b's in between.

The regular expression will be:(b*ab*ab*)*

• b∗: Any number of 'b's (including zero).

6
• aaa: A single 'a'.

• b∗b*b∗: Any number of 'b's (including zero).

• aaa: A single 'a'.

• b∗b*b∗: Any number of 'b's (including zero).

• aaa: A single 'a'.

7
4. Construct PDA to accept the following language: L = {a^n b^n| n≥0}
which consists of strings with the same number of 'a's followed by the same number of 'b's, we
can define the PDA as follows

1. States:

• ( q_0 ): Start state (also the state for reading 'a's)

• ( q_1 ): State for reading 'b's

• ( q_f ): Accept stat

Transition Function δ:

The transition function δ is defined as follows:

1. From q0 (start state):

o On reading an a, push A onto the stack and stay in state q0.

δ(q0,a,Z0)=(q0,AZ0)

δ(q0,a,A)=(q0,AA)

o On reading a b, if the stack is not empty (i.e., there are symbols A in the stack), pop an A
and move to state q1.

δ(q0,b,A)=(q1,ϵ)

2. From q1 (processing the b's):

o On reading a b, pop an A from the stack and stay in state q1.

δ(q1,b,A)=(q1,ϵ)

o If we encounter the end of the input string and the stack has only the initial symbol Z0,
move to the accepting state qf.

δ(q1,ϵ,Z0)=(qf,Z0)

3. Accepting State:

o qf is the accepting state, which indicates that the input string has been processed
successfully.

8
5.Turing machine for L = {a nb n c n }. Add seven states
to the screen, setting the initial state to be q0 and the final
state to be q6.
Steps to Construct a Turing Machine in JFLAP

1. Open JFLAP and Start a New Turing Machine:

o Launch JFLAP.
o From the main menu, select "Turing Machine".
2. Set Up the Workspace:
o A blank workspace for creating your Turing Machine will open, with a
toolbar at the top for adding states, transitions, and other components.
3. Add States:
o Click the "Create State" button (circle icon).

9
 o Click on the workspace to create states. Each state will appear as a circle
with a unique identifier (e.g., q0, q1).
o Add as many states as needed for your Turing Machine.
4. Set the Start State:
o Right-click on the state where your Turing Machine computation should
begin.
o Select "Set as Initial" from the context menu. An arrow pointing to this
state will appear.
5. Set Accepting and Rejecting States:
o Right-click on a state that should serve as an accepting state, then select
"Set as Final". The state will be marked with a double-circle outline.
o Optionally, designate a rejecting state to indicate strings that should be
rejected.
6. Add Transitions:
o Click the "Create Transition" button (arrow icon).
o Click on the source state, drag to the destination state, and release the
mouse.
o A dialog box will appear where you define the transition

10
11
LEARNING OUTCOMES

1. Understanding of Finite Automata

• NFA Construction: Learn how to design a Non-deterministic Finite Automaton

(NFA) to recognize specific patterns in strings, such as substrings or suffixes.
• State Transition Diagrams: Gain skills in creating state transition diagrams that
visually represent the behavior of NFAs.
2. Regular Expressions

• Regular Expression Formulation: Develop the ability to formulate regular

expressions for specific languages, such as strings of fixed length or containing certain
characters.
• Pattern Recognition: Understand how to express language constraints using regular
expressions.
3. Context-Free Grammars (CFG)

• CFG Construction: Learn how to construct Context-Free Grammars to generate

specific languages, particularly those that require certain conditions (e.g., at least one
occurrence of a character).
• Grammar Rules: Understand the components of CFGs, including variables,
terminals, start symbols, and production rules.
4. Pushdown Automata (PDA)

• PDA Design: Gain experience in designing a Pushdown Automaton to accept context-

free languages, particularly those that require counting (e.g., matching numbers of
different symbols).
• Stack Utilization: Understand how a stack is used in PDAs to manage state
transitions based on input symbols.
5. Theoretical Foundations of Computation

• Language Recognition: Develop a deeper understanding of the theoretical

foundations of computation, including the relationships between different types of
automata (finite automata, PDAs) and the languages they can recognize.

12
CONCLUSION

In conclusion, the exploration of formal languages, automata theory, and their associated
constructs—such as NFAs, regular expressions, context-free grammars, and pushdown
automata— provides a foundational understanding of how computational systems recognize
and process languages.
Through the design and analysis of various automata and grammars, learners gain valuable
insights into the principles of computation, including the relationships between different types
of languages and the computational models that recognize them. This knowledge not only
enhances theoretical understanding but also equips learners with practical problem-solving
skills applicable in various domains, such as programming language design, compiler
construction, and text processing.
Moreover, the ability to construct and manipulate these theoretical models fosters critical
thinking and analytical skills,

REFERENCE

Books:

• "Introduction to the Theory of Computation" by Michael Sipser

• This book provides a comprehensive introduction to the theory of computation,

including formal languages, automata, and complexity theory.
• "Automata, Computability and Complexity: Theory and

Applications" by Elaine Rich

• This text covers the fundamentals of automata theory, formal languages, and their
applications in computer science.
• "Elements of the Theory of Computation" by Harry R. Lewis and

Christos H. Papadimitriou

• This book offers a clear introduction to the theory of computation, including detailed
discussions on automata and formal languages.

13