Introduction

At the end of last day, we said how to write a deterministic finite automata down formally and what it means for it to accept a string formally.
We begin today by using this idea to create a supped up version of the transition function that operates on strings rather than symbols from our alphabet.

The Extended Transition Function

Let `M= (Q, Sigma, delta, q_0, F)` be a finite automaton and let `w=w_1w_2 ldots w_n` be a string.
We define the extended transition function `delta^star:Q times Sigma^star rightarrow Q` inductively:
1. `delta^star(q, epsilon) rightarrow q`
2. `delta^star(q, wa) rightarrow delta(delta^star(q,w),a)`
Intuitively, the equation `delta^star(q, w) =q'` tells us that if we are in state `q` when we begin to process the string `w`, then after processing `w` we will be in state `q'`.
An equivalent to the last slide's way to define `M` accepts `w` is to say, `M` accepts `w` if for some `q in F` we have `delta^star(q_0, w)=q`. i.e., we start in the start state `q_0`, process `w`, and end up in an accept state.
In more formal treatments of automata theory, say in an abstract algebra class, the extended transition function can be used to define the so-called transformational monoid of the automata.
A monoid is a set endowed with an associative operation that has an identity element. One example is `NN` under + where the identity is 0. In our context, the set of strings where the operation is concatenation and the identity element is the empty string also forms a monoid.
We can use `delta^star` as a way to have the string monoid act on/transform our set of states to produce new states, hence, it is a transformational monoid.

Designing Automata

Suppose we want to recognize the language that consists of an odd number of 1s.
One approach is to "pretend to be the automaton".
You get symbols from {0,1} one by one.
Ask how much of the string so far do we need to remember in order to decide whether to accept or not? In this particular case, we just need to remember if we are currently even or currently odd.
Now we make each of these possibilities states. Next we pretend we are in one of the states and see a symbol. What do we do?
Finally, we figure out what our accept and final states are:

Trap States

For DFAs, we require `delta` to be a total function.
This means for every state `q` and every alphabet symbol `a`, `delta(q,a)` must return some state `q'`.
That `delta` is total will force `delta^star` to be total as well.
Consider the problem of designing an automaton for the language: `{w | w = a^nb \ mbox{for some}\ n geq 0}`.
On a string like `aabab`, after the third `a` we know the string is not in the language; nevertheless, since the transition function is total we still need to continue processing the string until it is done.
This can be done with a trap state, which has a loop back to itself for every alphabet symbol.

Walks on Automata

Theorem

Let `M= (Q, Sigma, delta, q_0, F)` be a DFA, and `G_M` be its associated transition graph. Then for every `q_i`, `q_j` in `Q` and `w` in `Sigma^star` , `delta^star(q_i,w) = q_j` iff there is in `G_M` a walk with label `w` (that is, the edge labels written down as a string are `w`) from `q_i` to `q_j`.

Proof. We give a proof by induction on the length `n geq 0` of `w`. Notice `delta^star(q, epsilon)=q` corresponds exactly with a walk of length `0` in `G_M` . So the `|w|=0` case holds. Assume the statement is true up to some `n`. Let `w=va` where `|v|=n`. (The induction step case.) Suppose `delta^star(q_i,v) = q_k` . By the induction hypothesis there is a walk `W` of length `n` in `G_M` from `q_i`,to `q_k`. If `delta^star(q_i,w) = q_j` we must have `delta^star(q_i,w) = delta (delta^star(q_i,v), a) = q_j` by the definition of `delta^star.` So we have `delta(q_k,a) = q_j`. Thus, if we add to `W` the edge `(q_k, q_j)`, the label on the resulting walk will be `va=w` as desired. This new walk has length `n+1`. It is also not hard to turn this argument around to show if one stated with a walk of length `n+1` with label `w`, that one could show `delta^star(q_i,w) = q_j`. You should do this at home.

Regular Operations

Just as the natural number are closed under operations like addition and multiplication, the regular languages enjoy some closure properties:
- Union `A cup B = {x| x in A or x in B}`.
- Concatenation `AB = {xy | x in A ^^ y in B}`
- Star `A^star = {x_1 x_2 ldots x_k| k geq 0 \ mbox{and each} \ x_i in A }`
These closure conditions require proof. We will prove the first one today. We will show the last two after we introduce nondeterministic finite automata.

Product Construction

Theorem

If `A_1` and `A_2` are two regular languages, so is their union `A_1 cup A_2`.

Proof. Let `M_1=(Q_1, Sigma, delta_1, q_1, F_1)` and `M_2 =(Q_2, Sigma, delta_2, q_2, F_2)` be the DFAs recognizing languages `A_1` and `A_2`. We would like to make a new DFA, `M`, which simultaneously simulates both `M_1` and `M_2` and accepts a string `w` if either of `M_1` and `M_2` accepts. To simulate both machines at the same time we use a so-called "Cartesian product construction". To do this let `Q = Q_1 times Q_2`. `M`'s alphabet is `Sigma` like that of `M_1` and `M_2`. Define `delta((q, q'), a) = (delta_1(q,a), delta_2(q',a))`. Let the start state of `M` be `(q_1, q_2)`. Finally, let `F = (F_1 times Q_2 )cup (Q_1 times F_2 )`. Verify at home that `M` has the desired properties.

Example

Let `L = {w | w=101v \ mbox{where} \ v in {0, 1}^star }` and let `L' = {w | w=01v' \ mbox{where} \ v' in {0, 1}^star }`
Then a DFA for `L` might look like:
And one for `L'` might look like:
Doing the product construction by hand can be super painful. Humans and non-brain dead algorithms, might create the product of the states but then only draw the edges that are reachable from the start node. We gave an algorithm for reachability a couple days back.
The reachable portion of the product graph (all states drawn, but only reachable edges listed) for the above two automata might look like: