We will now begin our study of how to build machines which can recognize languages.
As a prelude, I will demo JFLAP now.
To download JFLAP please use the link on the class page.
Running JFLAP
When you launch JFLAP you get a window like:
Under Preferences you can set the empty string character to epsilon from its default of lambda.
Next we will be using the Finite Automaton button.
Clicking it will give a window like:
The four buttons across the top of the edit area allow one to: (1) select a state, (2) create a state, (3) create a transitions, (4) delete a state or transition
If you are not running JFLAP as an applet, you can save the automaton you make using the File menu.
Introductory Examples
Finite automata are computer models which are useful when one has very limited memory availability.
Consider an automatic door say at a grocerystore:
We can model the door state this using a finite automata:
More on Door Example
The controller might start in a CLOSED state and receive the signals: OUTSIDE, INSIDE, NEITHER, INSIDE, BOTH, OUTSIDE, INSIDE NEITHER.
It would then transition between the states CLOSED (start), OPEN, OPEN, CLOSED, CLOSED, CLOSED, OPEN, OPEN, CLOSED.
Notice only need 1-bit of memory to keep track of state.
It is also straightforward to represent transitions in a table:
Neither
Outside
Inside
Both
Closed
Closed
Open
Closed
Closed
Open
Closed
Open
Open
Open
Finite automata and the their probabilistic counterparts called Markov chains are also useful for pattern recognition. For example, recognizing keywords in programming languages. Or figuring out which word English is most likely in a given context based on the previously seen words.
Running an Automaton in JFLAP on Different Inputs
We can build the automaton we just discussed in JFLAP.
We'll use `i` for inside, `o` for outside, `n` for neither, and `b` for both.
To test this automaton on some inputs we first need to say what state it starts in by right clicking on a state and setting it to be a start state.
If we want to say what final states should be viewed as good (aka accepting) we can also do this by right-clicking.
Then using the Input menu, we can select to run the automaton Step-by-State.
You will be prompted for an input to the automaton, at which point you then get a window that let's you step through its computation.
Names for things
The picture we drew of our automata a couple slides back is called a state
diagram.
We will usually use the variables `M`, `N`, ... for machines.
Here is another example machine `M_1`:
The start state is the state with an arrow going from nowhere into it.
If we are recognizing strings then we stop processing when we get to the end
of a string of inputs.
If we are in a double circled state at that point we accept the string otherwise
we reject it. So double circled states called accept states.
Arrows going from one state to another are called transitions.
You might want to see if you can figure out if the above automata accepts each of the following strings: `0001`, `01100`, `1101`.
Formal Definition
A finite automaton is a 5-tuple `(Q, Sigma, delta, q_0, F)`, where
`Q` is a finite set called the states.
`Sigma` is a finite set called the alphabet.
`delta:Q times Sigma rightarrow Q` is the transition function.
`q_0 \in Q` is the start state.
`F subseteq Q` is the set of accept states.
The transition function tells us if we are in a given state reading a given symbol what is the next state to go to.
The definition of finite automaton originates in a paper of McCulloch and Pitts (Biophysics Vol. 5, 1943); however, their paper
was concerned with neural nets.
More modern looking definitions can be found in Huffman (1954), Mealy (1955), and Moore (1956).
Example of the Definition
Consider the machine:
The corresponding five tuple for this machine has:
For no `n` do the integers `mod n` form an equivalence relation.
A language must be a finite set.
Implementing Finite Automata -- Base Class
Suppose we had the job of implementing a finite automata in Java.
Typically, we would want to process strings according to how the finite automata would process them.
To make our set-up as flexible as possible we should probably have a base class that implements the core
string processing algorithm.
Then in sub-classes specify the transition function, start state, and final states to use.
An example base class might be:
public abstract class Automata
{
public Automata()
{
}
public void setState(int state)
{
currentState = state;
}
public boolean processString(String w)
{
for(int i = 0; i < w.length(); i++)
{
currentState = delta(currentState, w.charAt(i));
}
boolean accept = finalState(currentState);
return accept;
}
public abstract int delta(int state, char c);
public abstract boolean finalState(int state);
int currentState;
}
Implementing Finite Automata -- Specific Automata
Now if we wanted to implement the automata of a couple slides ago we could write:
public class TestAutomata extends Automata
{
public TestAutomata()
{
}
public int delta(int state, char c)
{
int outState = 1;
switch(state)
{
case 1:
if(c == '0')
{
outState = 1;
}
else
{
outState = 2;
}
break;
case 2:
if(c == '0')
{
outState = 3;
}
else
{
outState = 2;
}
break;
case 3:
outState = 2;
break;
}
return outState;
}
public boolean finalState(int state)
{
return (state == 2) ? true : false;
}
public static void main(String args[])
{
TestAutomata test = new TestAutomata();
test.setState(1);
if(args.length == 0 ){
System.out.println("It is not recognized by this automata.");
}
System.out.println("Checking the string "+ args[0]);
if(test.processString(args[0]))
{
System.out.println("It is recognized by this automata.");
}
else
{
System.out.println("It is not recognized by this automata.");
}
}
}
Comments on Code
Notice the only memory requirements besides the input string are all constant. For example, 4 bytes
to store the int for the currentState -- so DFAs are very memory efficient.
Notice also to determine if the string was in the language we made a single scan on the input string
and at each step while scanning only process a fixed number of instructions.
So the processing was linear time in the input length. i.e., very fast.
Formal Definition of Accepting a String
Let `M= (Q, Sigma, delta, q_0, F)` be a finite automaton and let `w=w_1 w_2 ldots w_n` be a string. Then
`M` accepts `w` if a sequence of states `r_0 r_1 ... r_n` in `Q` exist satisfying:
`r_0=q_0`
`delta(r_i, w_(i+1)) = r_(i+1)`, for `i=0,1, ldots , n-1`,
`r_n in F`.
That the string `0100` is accepted by the automata of a few slides ago is witnessed by the sequence of states
`q_1 q_1 q_2 q_3 q_2`. Notice this is a walk on the automata viewed as a labeled graph.
We write `L(M)` for the language that `M` accepts. That is, those strings that `M` accepts.
Given a set of strings `S`, we say `M` recognizes `S` if `L(M)=S`.
So `M_1` of a couple slides back recognizes `{ w | w \ mbox{contains at least one 1 and an even number of 0s follow the last 1}}`
A language is called a regular language if some finite automaton recognizes it.
