Experiment List

CS 501: TOC Lab

Understanding of software like JFLAP (Java Formal Languages and

Automata Package) 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. Regular expression
Exp 1. Deterministic Finite Automata (DFA)

mn
Problem:-Construct DFA for the language L= {a b :m≥0, n > 0,nis 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.

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

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 new state, say, q2.
m n
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 Load Inputs and
load the file to add additional input strings into multi-run pane.
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 :
Highlight Nondeterminism 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
beignored 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.
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.
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, with
the 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:
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.
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 Collapsar” 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.
Exp 7. Combining automata

Problem- Construct two DFA which represent the languages a*b and a(ba)* respectively, or
construct 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.
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’s and c’s repeated in any order.

Solution- Load JFLAP and create a new regular expression. Enter the given regular expression into
the text 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.
Exp 9. Mealy and Moore machine

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

Solution- Open JFLAP and create a Mealy machine with an initial state. Set its label to a “0” to
rememberthat 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.
Exp 10. Pushdown Automata

n n
Problem- Construct PDA for the language L= {a b : n > 0}

Solution- Our approach is to push an “a” on the stack for each “a” in the input, and to
pop 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:
Exp 11. Single tape Turing machine

n n n
Problem- Construct a Turing machine for the language L = {a b c ,n>=1}.

Solution- To start a new one-tape Turing machine, start JFLAP and click the Turing
Machine option from the menu, as shown below:

n n n
We will be adding a lot of states to create a Turing machine for L = {a b c }. Add
seven states to the screen, setting the initial state to be q0 and the final state to be q6.
The screen should be roughly similar to one below.

Now its time to add the transitions. Attempt to add a transition between the states q0
and q1. Now, it's time to add input. To change the transition from the default, click on
the first box. Enter a value of “a” for the first box, a value of “x” for the second box,
and a value of “R” in the third box. Use Tab or the mouse to move between the boxes,
and press enter or click the mouse on the screen outside the boxes when done. This
transition has the following meaning. If the head is under an “a” and the machine is in
state “q0”, then replace the “a” with an “x” and move the head to the right. When
done adding input, the area between q0 and q1 should resemble the example below.

Let's finish up the transitions as shown in figure given below

Now, let's try out our new Turing machine. Because of the number of steps, we will
avoid the “Step” option we used with finite automata (although for finite automata
titled “Step with Closure”) and instead use the “Fast Run” option. To use this, click on
the “Input” menu, and then click on “Fast Run”. After clicking “OK” or pressing
enter, the following screen should come up:
Exp 12. Multi-tape Turing machine

Problem- Create multitape turing machine for L={w2rw2, where w contains a pattern of 1s
and zeros}.

Solution- We will use a two tape machine. The second Tape will play the role of a stack. So
while our the head of our first tape is over a 0 or 1, we will copy it to the second tape and move
both tapes to the right. When the first tape sees a 2, we will transition to a new state and simple
position the second tape head. In this new state, while the character that the first tape is reading is
equal to the character under second tape read head. When we read a 2 on the first tape, we make
one more transition to the left one the second tape and make sure we read a blank before
accepting.
Exp 13. Context free grammars (CFG) with single symbols

→
Problem- Check input 0011 for production rule S 0S1| ε. Here V = {S}, T = {0, 1} and the start symbol
is S.

Solution- Enter the input and click set. Now clicking the step button will make JFLAP step
through the rules and see if the provided input string can be generated. With a single step, we can
get ε and 0S1 as shown here
 →
Finally clicking step once more gives us the string 0011 by using the rules S ε
Exp 14. CFG with multiple symbols.

Problem- Check strings aabbbbbccc for production rule

Solution-

Now we can input a string and check whether it is accepted. Enter the string
2 5 3
“aabbbbbccc” (a b c ) in the input text field. Then either click Start or press Enter
key. Brute Force Parser notifies that the string we entered is accepted. Now, we can
click on the Step button to see how we can derive that string using our productions.
After clicking the Step button twice, our window should look like this
To change to Derivation Table mode, click on Noninverted Tree and select
Derivation Table. The Brute Force Parse window should change to :
The derivation table shows the productions that are applied (shown under Production)
and the result of applying those productions to the start variable (shown under
Derivation). It gives a clear picture of how Brute Force Parsing is working. After
clicking Step until we reach our input string, the Brute Force Parse is finished and the
Derivation Table and Noninverted Tree should look like these :
Exp 15. Regular expressions

Problem- Convert the a*b(a+b) regular expression into NFA.

Solution-

Converting to a NFA
Now, click on the “(D)e-expressionify Transition” button (third from the left, to the
immediate left of the “Do Step” button). Then, click on the transition from “q0” to
“q1”. We should now see a screen like this