BY:

KRISHNA REDDY K 1304044

JAYESH BAFNA P

1304026

NITHIN RAJ D

1304027

ATCHAYA KUMAR

1304047

GNANESH V

1304028

MURUGESHWAR U 1304039
RIBERRO SILVA

1304020

INTRODUCTION:
The automaton simulation is done using an automaton simulator. The
automaton simulator allows us to draw and simulate a variety of theoretical
machines, including:

Deterministic finite automata

Non-deterministic finite automata

Deterministic push-down automata

Turing machines

An Automaton is an abstract computing device. A device need not even be a

physical hardware. The study of abstract computing devices, or machines is
called Automata Theory. A language is a collection of sentences of finite length
all constructed from a finite alphabet of symbols. In this simulation, we design
an abstract machine to simulate the working of a Deterministic finite automata
to accept a language of all strings ending with ab.

ABOUT THE PROJECT:

The automaton simulator is equipped with a GUI that is used to design the
Deterministic finite automata quickly and easily. The simulator has the
following tools:
State tool to draw states and designate starting & final state.
Transition tool to draw transitions between states and designate
symbols for which states the transitions apply.
Label tool to name the states present in the automata.
Simulation tool to run the simulation and either accept or reject the
language based on the input entered in the input field.
After designing the deterministic finite automata, the simulation is run. During
the simulation, input is given symbol by symbol and the transitions are seen
for each input symbol and whether the given language is accepted or rejected.

DETERMINISTIC FINITE AUTOMATA (DFA):

A deterministic nite automaton (DFA) consists of:
1. A nite set of states (often denoted Q)
2. A nite set of symbols (alphabet)
3. A transition function that takes as argument a state and a symbol and
returns a state(often denoted )
4. A start state often denoted q0
5. A set of nal or accepting states(often denoted F)
Here q0 Q and F Q.
So a DFA is mathematically represented as a quintuple (Q, , , q0, F).
The transition function is a function in which
QQ
Q is the set of 2-tuples (q, a) with q Q and a .
A DFA can be represented using:
Transition table
Transition diagram
Transition table:
0

q0

q2

q0

*q1

q1

q1

q2

q2

q1

The indicates the start state: here q0.

The indicates the nal state(s) (here only one nal state q1).
The above transition table is a representation for the DFA given below.

Transition table:
The following is a transition diagram for the same DFA represented as a
transition table above:

For this example,

Q = {q0, q1, q2}
Start state: q0
F = {q1}
= {0, 1}
is a function from Q to Q
: Q Q
(q0,1)= q0
(q0,0)= q2
Acceptance or Rejection in DFA:
A DFA accepts the given language if it reads the language and stops in the
accepting state. The DFA rejects the given language if there is also a stop or
dead state, in which case the DFA is not accepting the language or stopping at
the final state after the given language is finished reading.
An automaton is considered a DFA only if:
There is only 1 transition for a given symbol from any given state.
Each possible input determines the resulting state q uniquely, unlike
NFA where some inputs may allow a choice of resulting states.
The automaton can change state only after reading an input.

PROBLEM:
Design a DFA to accept a language of all strings containing = {0, 1} and
ending with ab.

SOLUTION:
The solution is obtained by beginning with a starting state.
The starting state should be able to read the input symbol a or b and
determine its next state.
Each state should have 2 possible outcomes or state changes 1 on
reading a and 1 on reading b.
Before reaching the final state, the DFA should have read the preceding
a before the final b, in which case the DFA accepts the language.
The DFA is represented as a transition diagram and transitions are
drawn for each state showing what transitions are made on reading
each input symbol.
Transition diagram:

Fig. Transition diagram for the given DFA

Here, q is the starting state and q2 is the accepting state.

The language is accepted if the DFA stops in q2 after it finishes reading
the input string.
The language is rejected if the DFA does not stop in q2 but stops in
either q0 or q1 after it finishes reading the input string.

 The DFA is also represented as a transition table specifying the starting

state and accepting state and showing which state the automaton goes
to on reading each input symbol from a given state.
Transition table:
A

q0

q1

q0

q1

q1

q2

*q2

q1

q2

Fig. Transition table for the given DFA

INPUT:
The input is given using the input field present in the simulator.
The input reads the string symbol by symbol.
For each symbol, if the symbol is part of i.e if its a valid symbol for the
given DFA, it shows the transition for the symbol from the state to the
next state.
If the symbol is not part of i.e if an invalid symbol is entered, it does
not show a transition and the state turns red in color and the language
is rejected.

SIMULATION:
The simulation is run to check if the designed DFA accepts or rejects the given
strings. The simulation is run for the following 2 example inputs i.e to accept
or reject the strings:

abbabab

abba
1. For the input string abbabab:
The DFA starts with the starting state and makes the transitions
according to the input symbols being read as the input from the string.

The DFA is in the starting state q0.

The DFA reads a and transitions to q1. Input read so far: a

The DFA reads b and transitions to q2. Input read so far: ab

The DFA reads b and transitions to q0. Input read so far: abb

The DFA reads a and transitions to q1. Input read so far: abba

The DFA reads b and transitions to q2. Input read so far: abbab

The DFA reads a and transitions to q1. Input read so far: abbaba

The DFA reads b and transitions to q2. Input read so far: abbabab

STATUS: ACCEPTED [Since the DFA stopped in the accepting state after
it finished reading the input]

2. For the input string abba:

The DFA starts with the starting state and makes the transitions
according to the input symbols being read as the input from the string.

The DFA is in the starting state q0.

The DFA reads a and transitions to q1. Input read so far: a

The DFA reads b and transitions to q2. Input read so far: ab

The DFA reads b and transitions to q0. Input read so far: abb

The DFA reads a and transitions to q1. Input read so far: abba

STATUS: REJECTED [Since the DFA did not stop in the accepting state
after it finished reading the input. It stopped in q1 which is not an
accepting state]

SCREENSHOTS:

CONCLUSION:
Thus the automaton simulation was done to design a Deterministic finite
automata and run the simulation to accept or reject the given language. This
simulation allowed us to read the input string symbol after symbol and
showed the transitions from each state as each input symbol was read. This
way, we were able to see the transitions and see how the DFA works. In the
case that the given language is not accepted, we can see where the transition
stops and why it is not being accepted. Also, being able to see the transitions
step by step, it becomes easier to debug the DFA and correct the design in the
case the DFA does not work as it was intended to. Therefore, the simulation is
the perfect way to understand how automata works and how the input strings
are processed by the abstract machine.

***END OF THE REPORT***