Outline

• Example of State Minimization
• Myhill Nerode Theorem
• In-Class Exercise
• Regular Languages and Regular Expressions
• Regular Grammars
• Classifying Regular Languages

Example

• You can use JFLAP to take an NFA convert it to a DFA and then minimize the result.
• For example, we might start with the following NFA:
  
• We can then use JFLAP to get the following DFA (JFLAP will step you through the procedure if you like so you can learn it):
  
• In the above, I added the trap state with label emptyset and moved around the states to make it prettier looking (I hope).
• Finally, we can convert this last DFA to the minimal DFA:
  
• Since this is a DFA we know we can code it in C or Java. It is also as small as possible so it will be easier to code.

Indistinguishability and the Myhill-Nerode Theorem

• We used the notion of two states being distinguishable in our minimizing construction. One can similarly define the notion of two strings `u`, `v` being distinguishable with respect to a language if there is a string `w` such that `uw in L` but `vw !in L`.
• If two strings are not distinguishable we say they are indistinguishable with respect to `L`. We write `[v]_L` for the equivalent class of all strings equivalent to `v`.
• We can define a binary operation `[v]_L*[w]_L = [vw]_L` which is easy to show is associative with empty string as an identity `[epsilon]_L[v]_L = [v]_L[epsilon]_L =[v]_L`.
• The equivalence classes imbued with this operation are called the syntactic monoid of `L`.
• Notice in the case where one of the two strings is an alphabet symbol, the operation above can be viewed as a transition function: `delta([v]_L, a) = [va]_L`.
• If `v in L` then all members of `[v]_L` will be in `L` so it makes sense to call these the accept states of this automaton.
• We can let the set of equivalence classes `[v]_L` be our states.
• If `L` has a finite number of equivalence classes then this machine will be a DFA and `L` will be a regular language.
• If a language is regular, we can take a DFA for it and minimize it. For state `q`, `q'` of this machine, let `v_q` and `v_(q')` be strings that takes one to these states. As our minimality construction for the DFA did not say these two state are the same, there must be some string such that `delta^star(q,w)` and `delta^star(q',w)` are not both accepting or both rejecting. So `v_q` and `v_(q')` must be distinguishable with respect to `L`. On the hand, if two strings map one to the same state `q` then they will be indistinquishable with respect to `L`. So the states of our minimal machine exactly correspond to the equivalence classes of `L` and so the later will be finite.
• This is the content of the Myhill Nerode theorem which is due to Nerode 1958 building on a paper of Myhill 1957: A language is regular iff the set of equivalence classes of `L` with respect to indistinguishability is finite.
• It shows the automata one gets from our construction is unique up to a renaming of states.

In-Class Exercise

Consider the language consisting of string over `{0,1}` containing 010 as a substring. Determine the equivalence classes of this language with respect to distinguishability. Draw the automata given by the transition function for the Myhill Nerode Theoremm.

Please post your solution to the Feb 19 In-Class Exercise Thread.

Regular Expressions

• In arithmetic, we can use the operations `+` and `cdot` to build up expressions such as: `(5 + 3) cdot 4`.
• Similarly we can use the regular operations to build up expressions describing regular languages.
• For instance, `0(0 cup 1)^star`.
• This means the language which results from concatenating the language containing 0 with the language of `(0 cup 1)^star`. This in turn is the star of the union of the two languages one containing just `0`; the other containing just `1`.
• These kind of expressions are used in many modern programming languages: Perl, PHP, Python, Java, AWK, GREP.