And then every finite state machine can be converted to a deterministic finite state machine.

Every regular expression has a finite state machine, and every finite state machine has a regular expression.

Consider this spiffy, new finite state machine.

Now for finite state machine state, that was pretty easy.

Here's an implementation of the finite state machine.

Here I've shown a finite state machine for ab .

It's just that their finite state machine is much bigger.

So now let's really prove the power of our finite state machine interpreter by showing that we could figure out any finite state machine.

Then I want to make a new finite state machine that accepts ba ba, ba ba, ba ba, doublings of the first finite state machine.

If you look closely, you'll see that this finite state machine.

I find it helpful to draw the finite state machine first.

This new finite state machine will still accept 1, 2, 3.

So let's get started on our finite state machine simulation quiz.

Now we represent that big finite state machine internally as edges.

Otherwise, we fall off the finite state machine and return false.

Now I'm going to do my trimming of my finite state machine.

Possible to have ambiguity or epsilon transitions in a finite state machine.

Our finite state machine rejects this just like our regular expression would.

Given the definition for a non deterministic finite state machine, we're going to use our crystal ball of Python code to read into the mind of the finite state machine and output any string if there exists one that is accepted by that finite state machine.

Well, once again, I recommend getting started by drawing the finite state machine.

So here I have a finite state machine representation of that regular expression.

Over here, I've drawn a different finite state machine, again with 3 states.

Here's a finite state machine that corresponds to the regular expression a 1 .

Suppose I have any finite state machine A. You draw it out for me. Can I then make a new finite state machine that accepts strings of the following form?

If the current state is dead, we're not going to copy it into our new finite state machine.

So to go through an example, let's say we have this finite state machine.

Suppose this time that I give you the encoding of the finite state machine.

Matches exactly the same set as the original one, finite state machine, but backwards.

With all of that in mind, let's encode our finite state machine in Python.

Here I've drawn a finite state machine, a visual representation of this regular expression.

Every regular expression, concatenation, plus, question mark, star, has an equivalent finite state machine.

This should not be accepted by our finite state machine, and it is not.

We can convert nondeterministic finite state machines down into deterministic finite state machines.

I could recognize these comments with another finite state machine, and all I have to do is just merge these 2 finite state machines together conceptually.

Let's just verify that by tracing out the input, aa1, on this finite state machine.

But the first big design decision is, how do we represent this finite state machine?

However, this finite state machine does not allow us to accept on a single a.

But you may have noticed quite a bit of duplication in this finite state machine.

You can take any finite state machine and represent it with a context free grammar.

So we can check any finite state machine to see if it accepts a string.

If I have a finite state machine B, can I make a new finite state machine that accepts strings of this form x concatenated with x where x was a string accepted by B?

In this finite state machine, to go the other direction, and finishing it off by changing the start state with the accepting state.

What should this edge label be so that this finite state machine accepts those phone numbers?

Here I've drawn a potentially familiar finite state machine, and what I'd like you to do is check each box that corresponds to a string that is accepted by this finite state machine exactly and fully.

Once we have a deterministic finite state machine, we can simulate it, and it turns out it's very easy about 10 lines of recursive code to see if a deterministic finite state machine accepts a string.