LABORATORY MANUAL

of
THEORY OF COMPUTATION

(CS501)

For Third Year Students

Department of Computer Science & Engineering

IPS College of Technology & Management, Gwalior

 Experiment List

CS501: TOC Lab

Understanding of software like JFLAP (Java Formal Languages

and AutomataPackage) for experimenting with formal languages

1. Deterministic Finite Automata (DFA)

2. Nondeterministic Finite Automata (NFA)
3. Conversion of NFA to DFA
4. DFA Minimization
5. DFA to regular grammar conversion
6. DFA to regular expression conversion
7. Combining automata
8. Regular expression to DFA conversion
9. Mealy and Moore machine
10. Pushdown automata
11. Single tape Turing machine
12. Multi-tape Turing machine
13. Context free grammars (CFG) with single symbols
14. CFG with multiple symbols
15. LL Parsing
16. LR Parsing
17. Regular expressions
18. Regular pumping lemma
19. Context free pumping lemma
20. CFG to Chomsky Normal form transformation
 THEORY OF COMPUTATION (CS-501)
Lab Outcomes:
1. Demonstrate the concept of Finite Automata and Regular Expression.

2. Demonstrate the designing of Finite Automata

3. Design the grammar for respective language.

4. Demonstrate the designing of Push Down Automata

5. Demonstrate the designing of Turing Machine

 TOC LAB
Code- CS-501

Introduction: JFLAP (Java Formal Languages and Automata Package)

Department of Computer Science & Engineering

IPS College of Technology & Management, Gwalior
Definition
JFLAP defines a finite automaton (FA) M as the quintuple M = (Q, Σ, δ, qs, F) where

Q is a finite set of states {qi| i is a nonnegative

integer}Σ is the finite input alphabet
Q
δ is the transition function, δ : D → 2 where D is a finite subset of Q ×
Σ* qs(is member of Q) is the initial state
F (is a subset of Q) is the set of final states

Note that this definition includes both deterministic finite automata (DFAs), which we
will be discussing shortly, and nondeterministic finite automata (NFAs), which we
will touch on later.

Building the different types of automata in JFLAP is fairly similar, so let's start by
m n
building a DFA for the language L = {a b :m ≥ 0, n > 0, n is odd}. That is, we will
build a DFA that recognizes that language of any number of a's followed by any odd
number of b's. (Examples taken from JFLAP: An Interactive Formal Languages
andAutomata Package by Susan Rodger and Thomas Finley.)

The Editor Window

To start a new FA, start JFLAP and click the Finite Automaton option from the
menu.

Starting a new FA
This should bring up a new window that allows you to create and edit an FA. The
editor is divided into two basic areas: the canvas, which you can construct your
automaton on, and the toolbar, which holds the tools you need to construct your
automaton.

The editor window

Let's take a closer look at the toolbar.

The FA toolbar
As you can see, the toolbar holds four tools:
□
Attribute Editor tool : sets initial and final states
□
State Creator tool : creates states
□
Transition Creator tool : creates transitions
□
Deletor tool : deletes states and transitions

To select a tool, click on the corresponding icon with your mouse. When a tool is
selected, it is shaded, as the Attribute Editor tool is above. Selecting the tool puts
you in the corresponding mode. For instance, with the toolbar above, we are now in
the Attribute Editor mode.

The different modes dictate the way mouse clicks affect the machine. For example, if
we are in the State Creator mode, clicking on the canvas will create new states. These
modes will be described in more detail shortly.

Now let's start creating our FA.

Creating States
First, let's create several states. To do so we need to activate that State Creator tool by
clicking the button on the toolbar. Next, click on the canvas in different locations to
create states. We are not very sure how many states we will need, so we created four
states. Your editor window should look something like this:

States created
Now that we have created our states, let's define initial and final state.

Defining Initial and Final States

Arbitrarily, we decide that q0 will be our initial state. To define it to be our initial
state, first select the Attribute Editor tool on the toolbar. Now that we are in
Attribute Editor mode, right-click on q0. This should give us a pop-up menu that looks
like this:

The state menu

From the pop-up menu, select the checkbox Initial. A white arrowhead appreas to the
left of q0 to indicate that it is the inital state.

q0defined as initial state

Next, let's create a final state. Arbitrarily, we select q1 as our final state. To define it
as the final state, right-click on the state and click the checkbox Final. It will have a
double outline, indicating that it is the final state.

q1defined as final state

Now that we have defined initial and final states, let's move on to creating transtitions.
Creating Transitions
We know strings in our language can start with a's, so, the initial state must have an
outgoing transition on a. We also know that it can start with any number of a's, which
means that the FA should be in the same state after processing input of any number of
a's. Thus, the outgoing transition on a from q0 loops back to itself.

To create such a transition, first select the Transition Creator tool from the toolbar.
Next, click on q0 on the canvas. A text box should appear over the state:

Creating a transition

Note that λ, reprsenting the empty string, is initially filled in for you. If you prefer ε
representing the empty string, select Preferences : Preferences in the main menu to
change the symbol representing the empty string.

Type "a" in the text box and press Enter. If the text box isn't selected, press Tab to
select it, then enter "a". When you are done, it should look like this:

Transition created

Next, we know that strings in our language must end with a odd number of b's. Thus,
we know that the outgoing transtion on b from q0 must be to a final state, as a string
ending with one b should be accepted. To create a transition from our initial state q0 to
our final state q1, first ensure that the Transition Creator tool is selected on the
toolbar. Next, click and hold on q0, and drag the mouse to q1 and release the mouse
button. Enter "b" in the textbox the same way you entered "a" for the previous
transition. The transition between two states should look like this:

Second transition created

Lastly, we know that only strings that end with an odd number of b's should be
accepted. Thus, we know that q1 has an outgoing transition on b, that it cannot loop
back to q1. There are two options for the transtion: it can either go to the initial state
q0, or to a brand new state, say, q2.
If the transition on b was to the initial state q0, strings would not have to be of the
m n
form a b ; strings such as ababab would also be accepted. Thus, the transition cannot
be to q0, and it must be to q2.
Create a transition on b from q1 to q2. As the FA should accept strings that end with
an odd number of b's, create another transition on b from q2 to q1. Your FA is now a
full, working FA! It should look something like this:

The working FA

You might notice that the q3 is not used and can be deleted. Next, we will describe
how to delete states and transitions.

Deleting States and Transitions

To delete q3, first select the Deletor tool on the toolbar. Next, click on the state q3.
Your editor window should now look something like this:
q3deleted

Similarly, to delete a transition, simply click on the input symbol of the transition
when in Deletor mode.

Your FA, faex.jff, is now complete.

Running the FA on Multiple Strings

Now that you've completed your FA, you might want to test it to see if it really
accepts strings from the language. To do so, select Input : Multiple Run from the
menu bar.

Starting a multiple run tab

A new tab will appear displaying the automaton on the left pane, and an input table on
the right:
A new multiple run tab

To enter the input strings, click on the first row in the Input column and type in the
string. Press Enter to continue to the next input string. When you are done, click
RunInputs to test your FA on all the input strings. The results, Accept or Reject
aredisplayed in the Result column. You can also load the inputs from file delimited
by white space. Simply click on Load Inputs and load the file to add additional input
strings into multi-run pane.

Running multiple inputs

Clicking Clear deletes all the input strings, while Enter Lambda enters the empty
string at the cursor. View Trace brings up a separate window that shows the trace of
the slected input. To return to the Editor window, select File : Dismiss Tab from the
menu bar.

Building a Nondeterministic Finite Automaton

Building a nondeterministic finite automaton (NFA) is very much like building a
DFA. However, an NFA is different from a DFA in that it satisfies one of two
conditions. Firstly, if the FA has two transitions from the same state that read the
same symbol, the FA is considered an NFA. Secondly, if the FA has any transitions
that read the empty string for input, it is also considered an NFA.

Let's take a look at this NFA, which can be accessed through ex1.3a.jff: (Note: This
example taken from JFLAP: An Interactive Formal Languages and AutomataPackage
by Susan Rodger and Thomas Finley.)

An NFA

We can immediately tell that this is an NFA because of the four λ-transitions coming
from q3 and q9, but we might not be sure if we have spotted all the nondeterministic
states. JFLAP can help with that.
Highlighting Nondeterministic States
To see all the nondeterministic states in the NFA, select Test :
HighlightNondeterminismfrom the menu bar:

Highlighting nondeterministic states

A new tab will appear with the nondeterministic states shaded a darker color:

Nondeterministic states highlighted

As we can see, q3 and q9 are indeed nondeterministic because of their outgoing λ-

transitions. Note that they would both be nondeterministic even if they each had one
λ-transition instead of two: only one λ-transition is needed to make a state
nondeterministic. We also see that q1 is nondeterministic because two of its outgoing
transitions are on the same symbol, a. Next, we will go through JFLAP's tools for
running input on an NFA.
Running Input on an NFA
To step through input on an NFA, select Input : Step with Closure... from the menu
bar. A dialog box prompting you for input will appear. Ordinarily, you would enter
the input you wish to step through here. For now, type "aaaabb" in the dialog box and
press Enter. You can also load the input file instead of typing the string.

NOTE :When loading input from the file, JFLAP determines end of input string bythe
white space. Thus if there is string “ab cd” in a file, only “ab” will be considered as an
input (“cd” will be ignored since there is a white space before them).

Entering input

A new tab will appear displaying the automaton at the top of the window, and
configurations at the bottom. The current state is shaded.

A new input tab

First, let's take a closer look at a configuration:

A configuration icon

The configuration icon shows the current state of the configuration in the top left hand
corner, and input on the white tape below. The processed input is displayed in gray,
and the unprocessed input is black.

Click Step to process the next symbol of input. You will notice q1 becomes the shaded
state in the NFA, and that the configuration icon changes, reflecting the fact that the first
a has been processed. Click Step again to process the next a. You will find that four
states are shaded instead of one, and there are four configurations instead of one.

aa processed
This is because the machine is nondeterministic. From q1, the NFA took both a
transitions to q2 and q9. As q9 has two λ-transitions (which do not need input), the
NFA further produced two more configurations by taking those transitions. Thus, the
simulator now has four configurations. Click Step again to process the next input
symbol.

aaa processed

Notice that two of the configurations are highlighted red, indicating they were
rejected. Looking at their input, we also know that only aa was processed. What
happened?

Producing a Trace
To select a configuration, click on it. It will become a solid color when selected,
instead of the slightly graded color. Click on the icon for the rejected configuration
with state q11, and click Trace. A new widow will appear showing the traceback of
that configuration:
A configuration's traceback

The traceback shows the configuration after processing each input symbol. From the
traceback, we can tell that that configuration started at q0 and took the transition to q1
after processing the first a. After processing the second a, it was in q11. Although q11
is not adjacent to q1, it can be reached by taking a λ-transition from q9. As the
simulator tried to process the next a on this configuration, it realized that there are no
outgoing a transitions from q11 and thus rejected the configuration.

Although rejected configurations will remove themselves in the next step, we can also
remove configurations that have not been rejected.

Removing Configurations
Looking at the tracebacks of the rejected configurations, we can tell that any
configurations that are in q11 or q6 and whose next input symbol is a will be rejected.

As the next input symbol is a, we can tell that the configurations that are currently in
q6 and q11 will be rejected. Click once on each of the four configurations to select
them, then click Remove. The simulator will no longer step these configurations.
(Although we are only removing configurations that are about to be rejected, we can
remove any configurations for any purpose, and the simulator will stop stepping
through input on those configurations.)

Your simulator should now look something like this:

Rejected configurations removed

Now when we step the simulator, the two configurations will be stepped through.

Looking at the two configurations above, we might realize that the configuration on
q3 will not lead to an accepting configuration. We can test our idea out by freezing the
other configuration.

Freezing and Thawing configurations

To freeze the configuration on q10, click on q10 once, then click the Freeze button.
When a configuration is frozen, it will be tinted a darker shade of purple:
Configuration on q10 frozen

With that configuration frozen, as you click Step to step through the configuration on
q3, the frozen configuration remains the same. Clicking Step two more times will
reveal that the configuration on q3 is not accepted either. Your simulator will now
look like this:

Other configurations rejected

To proceed with the frozen configuration, select it and click Thaw. The simulator will
now step through input as usual. Click Step another three times to find an accepting
configuration. An accepting configuration is colored green:

Accepting configuration found

If we click Step again, we will see that the last configuration is rejected. Thus, there is
only one accepting configuration. However, we might be unsure that this is really the
case, as we had removed some configurations. We can double-check by resetting the
simulator.

Resetting the simulator

At any point in the simulation, we can restart the entire simulation process by clicking
Reset. This will clear all the current configurations and restart the simulation. If we
click Reset and step all the configurations, we will find that there is, indeed, only one
accepting configuration.
 TOC LAB
Code- CS-501

Experiment 1: Deterministic Finite Automata (DFA) Using JFLAP

Department of Computer Science & Engineering

IPS College of Technology & Management, Gwalior
Exp.1 Deterministic Finite Automata (DFA)
mn
Problem:-Construct DFA for the languageL= {a b :m≥0, n > 0,nis odd}. That is, we willbuild a
DFA that recognizes that language of any number of a's followed by any odd number of b's.

Solution- To start a new FA, start JFLAP and click the Finite Automaton option from themenu.

This should bring up a new window that allows us to create and edit an FA. The editor is divided
into two basic areas: the canvas, where we can construct our automaton on, and the toolbar,
which holds the tools we need to construct our automaton.

First, let's create several states. To do so we need to activate that State Creator tool by clicking
the button on the toolbar. Next, click on the canvas in different locations to create states.
Arbitrarily, we decide that q0 will be our initial state. To define it to be our initial state, first
select the Attribute Editor tool on the toolbar. Now that we are in Attribute Editor mode, right-
click on q0. This should give us a pop-up menu that looks like this:

From the pop-up menu, select the checkbox Initial. A white arrow head appears to the left of q0
to indicate that it is the initial state.

Q0 defined as initial state

Next, let's create a final state. Arbitrarily, we select q1 as our final state. To define it as the final
state, right-click on the state and click the checkbox Final. It will have a double outline,
indicating that it is the final state.
We know that only strings that end with an odd number of b's should be accepted. Thus, we
know that q1 has an outgoing transition on b that it cannot loop back to q1. There are two options
for the transition: it can either go to the initial state q0, or to a brand new state, say, q2.
mn
If the transition on b was to the initial state q0, strings would not have to be of the form a b ;
strings such as ababab would also be accepted. Thus, the transition cannot be to q0, and it must
be to q2.

Create a transition on b from q1 to q2. As the FA should accept strings that end with an odd
number of b's, create another transition on b from q2 to q1. Our FA is now look something like
this:

Running the FA on Multiple Strings

Now that we have completed our FA, Now we test it to see if it really accepts strings from
the language. To do so, select Input: Multiple Run from the menu bar.

A new tab will appear displaying the automaton on the left pane, and an input table on the right:
To enter the input strings, click on the first row in the Input column and type in the string. Press
Enter to continue to the next input string. When we are done, click Run Inputs to test our FA
on all the input strings. The results, Accept or Reject are displayed in the Result column. We
can also load the inputs from file delimited by white space. Simply click on LoadInputs and
load the file to add additional input strings into multi-run pane.
 TOC LAB
Code- CS-501

Experiment 2: Non-Deterministic Finite Automata (NFA) Using JFLAP

Department of Computer Science & Engineering

IPS College of Technology & Management, Gwalior
Exp-2 Nondeterministic Finite Automata (NFA)

Problem: - Determine given finite automata is nondeterministic in nature through JFLAP.

Solution- To see all the nondeterministic states in the NFA, select Test :
HighlightNondeterminism from the menu bar:

A new tab will appear with the nondeterministic states shaded a darker color:
Running Input on an NFA

When loading input from the file, JFLAP determines end of input string by the white space.
Thus if there is string “ab cd” in a file, only “ab” will be considered as an input (“cd” will be
ignored since there is a white space before them).

A new tab will appear displaying the automaton at the top of the window, and configurations at
the bottom. The current state is shaded. Click Step to process the next symbol of input. You will
notice q1 becomes the shaded state in the NFA, and that the configuration icon changes,
reflecting the fact that the first a has been processed. Click Step again to process the next a. We
will find that four states are shaded instead of one, and there are four configurations instead of
one.
 TOC LAB
Code- CS-501

Experiment 3: Conversion of Non-Deterministic Finite Automata (NFA) to

Deterministic Finite Automata Using JFLAP

Department of Computer Science & Engineering

IPS College of Technology & Management, Gwalior
EXP-3 Conversion of NFA to DFA
Problem- Convert the given NFA as shown in figure into corresponding DFA.

Solution- Create the NFA above in JFLAP. Click Convert > Convert to DFA

The unfinished DFA equivalent is started on the right-hand pane of the screen.

Click the Complete button and the DFA is completed.

Click Export to bring the DFA to its own work area. Click OK on the confirming message.
Reposition the states so that the DFA is readable.
 TOC LAB
Code- CS-501

Experiment 4: Minimization of Deterministic Finite Automata Using JFLAP

Department of Computer Science & Engineering

IPS College of Technology & Management, Gwalior
Exp. 4 DFA Minimization
Problem- Minimize the given DFA.

Solution- In the view, there is a toolbar along the top. To the left there is the original DFA,
withthe addition of the trap state (if necessary). To the right there is the tree where the set of
distinguishable groups is determined.

When the tool starts out, there are two major groups: non-final and final states. The current
groups are those groups in the leaf nodes. The union of all current groups is the set of all
states, and all current groups are state disjoint.

We will now convert this DFA into a minimal state DFA.

Click on the “Convert → Minimize DFA” menu option and this screen should come up:
 TOC LAB
Code- CS-501

Experiment 5: Deterministic Finite Automata to Regular Grammar

Conversion Using JFLAP

Department of Computer Science & Engineering

IPS College of Technology & Management, Gwalior
EXP.5 DFA to regular grammar conversion

Problem- Convert the following DFA into regular grammar.

Solution- We will now convert this DFA into a regular grammar.

Click on the “Convert → Convert to Grammar” menu option, and this screen should come up:

JFLAP, by default, assigns unique variables to each state. Each transition in the graph
corresponds with a production in a right-linear grammar.
 TOC LAB
Code- CS-501

Experiment 6: Deterministic Finite Automata to Regular Expression

Conversion Using JFLAP

Department of Computer Science & Engineering

IPS College of Technology & Management, Gwalior
EXP-6. DFA to regular expression conversion

Problem- Convert the following DFA into regular expression

Solution:-We will now convert this DFA into a regular expression. Click on the “Convert →
Convert FA to RE” menu option, and this screen should come up:
This tool is accessed using the fourth button from the left, the “State Collapser” button. Click on
that and then try to click on either state “q0” or “q1”. You should be informed that the final or
initial state cannot be removed (whichever one you clicked on). Thus, the only state that can be
removed is “q2”. Thus, click on that state. Once we click on it, a “Transitions” window should
come up, which lists all the transitions and labels that will be present in the current graph once
the current state has been removed. If we click on the individual rows in the window, the old
transitions in the editor window that correspond to the new transition will be highlighted, in
addition to the state that will be removed. The screen below is an example of both the transition
window, highlighted old transitions, and the highlighted state to be removed (in a resized main
window).
Click on “Finalize” and the “Transitions” window will disappear. The following screen should
now be visible, with the new regular expression under the “Generalized Transition Graph
Finished.
 TOC LAB
Code- CS-501

Experiment 7: Combining Automata Using JFLAP

Department of Computer Science & Engineering

IPS College of Technology & Management, Gwalior
Exp.-7 Combining automata

Problem- Construct two DFA which represent the languages a*b anda(ba)* respectively,
orconstruct them in two separate JFLAP windows and then combine it into one finite automata.

Solution- Construct DFA for L= { a*b}

Now construct DFA for L= { a(ba)*}

Now, in one of the windows, click on the “Convert → Combine Automata” menu option.
 TOC LAB
Code- CS-501

Experiment 8: Regular Expression to Deterministic Finite Automata

Conversion Using JFLAP

Department of Computer Science & Engineering

IPS College of Technology & Management, Gwalior
EXP-8 Regular expression to DFA conversion

Problem:-Convert a(b+c)*a to a DFA. The string must start with an a which is followed by a mix of
b’sand c’s repeated in any order.

Solution- Load JFLAP and create a new regular expression. Enter the given regular expression into
thetext box.

Next, convert the regular expression to a finite automata using Convert > RE to FA. The window changes
into an FA with the regular expression labeled in the transition.
When a double framed window shows, click Complete on the right hand pane.

The DFA appears on the right hand side. To export this to its own work area, click Export. Click OK on
the pop-up to confirm the export. Adjust the states as necessary so that edge labels are clear.
 TOC LAB
Code- CS-501

Experiment 9: Mealy and Moore Machine Using JFLAP

Department of Computer Science & Engineering

IPS College of Technology & Management, Gwalior
EXP-9 Mealy and Moore machine

Problem- Construct a Mealy machine which takes a binary number and replaces the first 1 with a 0
fromevery substring starting with 1. For example, 0001001110 become 0000000110.

Solution- Open JFLAP and createa Mealy machine with an initial state. Set its label to a “0” toremember
that a zero is read. Next, add a second state to remember that a “1” was read. Label this with a “1”.

Four transitions will be needed.

1. At q0, a 0 is read so a loopback to q0 is needed. Output a 0.

2. At q0, a 1 is read so a transition to q1 is needed. Output a 0 since this is the first 1 in a

substring starting with a 1.

3. At q1, a 0 is read so a transition to q0 is needed. Output a 0.

4. At q1, a 1 read so a loopback to q1 is needed. Output a 1.

Run some test strings using Input > Multiple Runs.
 TOC LAB
Code- CS-501

Experiment 10: Pushdown Automata Using JFLAP

Department of Computer Science & Engineering

IPS College of Technology & Management, Gwalior
10. Pushdown Automata
n n
Problem- Construct PDA for the languageL= {a b : n > 0}

Solution- Our approach is to push an “a” on the stack for each “a” in the input, and
topop an “a” off the stack for each “b” in the input. To start a new NPDA, start JFLAP
and click the Pushdown Automaton option from the menu, as shown below:

n n
Four states should be enough for the language L = {a b : n > 0}. Add four states to
the screen, setting the initial state to be q0 and the final state to be q3. The screen
should look similar to one below.
 n
Add a transition (a, a; aa) between q1 and q1 to finish up the a segment. Create the
n
transition (b, a; λ) between q1 and q2 and between q2 and q2 to represent the b
segment. Finally, (λ , Z; Z) between q2 and q3 will allow an input to arrive at the final
state. When finished, the screen should look like this: