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

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.

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

Consider this spiffy, new finite state machine.

Here's an implementation of the finite state machine.

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

Finite State Machines, adding a lexer that follows them automatically,

Finite state machines are a pictorial equivalent to regular expressions.

We converted each of those down into finite state machines.

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.

Last unit, we learned about regular expression and finite state machines.

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.

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.

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

If you like, you can say that finite state machines are generous.

Let's zoom back to finite state machines at 88 miles an hour.

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

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

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

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.

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

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 .

We also learned that you could turn regular expressions into finite state machines.

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?

Finite state machines did not really need to know where they were coming from.

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

Those regular expressions are represented as finite state machines, and that's how they're processed.

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.

Let's explore a bit more in this brave new world of finite state machines.

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.