21 views

Uploaded by Huong Luong

- Dac v3 Bonus Functionality
- Finite State Machine Pattern - The One True Pattern - Stack Overflow
- Security & Rules API - Firebase
- QI
- cp man
- AI793C Lab Notes
- DX 901 Developer Guide En
- SumitaAroraChap8Programs
- acctest.ps
- tmp5B8.tmp
- 00170224
- IP Project
- Cmm Serial Io
- 1340-CS2303.doc
- compiler-lexical analysis
- Dynamic_Programming_-_Set_29_(Longest_Common_Substring)_-_Ge.pdf
- Srchfor(con varianets de Busqueda).pdf
- cmu05
- MCA - System Programming (Set-2)
- codingbat-python-soru-cevap-2.pdf

You are on page 1of 14

like ascii, or Unicode are sets of symbols

used in, in the various computer

applications in most of our examples we

will use simpler alphabets which will

include... Some of the alphabet,

consisting of the number zero, one, one

called the binary alphabet. Sometimes I'll

use a small set of letters like A, B, C,

or for the, for the case of our, our

tennis example, we had the set of S and O

as our input alphabet. Another interesting

example might be the set of signals used

by a protocol, such as transmit end and so

on. Okay, a string, first of all, every

string is over some particular alphabet

which we'll call a capital sigma it's,

it's a list of elements each of which is a

member sigma. And we'll show strings with

no commas or quotes. So for example, ABC

is a string, over the, it could be

alphabetic C or it could be ascii alphabet

011 01 is probably a is a string probably

over the binary alphabet of zero and one

this could be over any other alphabet that

contains the ON1, strings are essentially

the usual data type that you've seen in

languages like C or java, Oral, we are

going to write them without the special

quotes It's also legitimate to see strings

as lists of symbols as long as they're

chosen from some particular alphabet

sigma, and of course we never use commas

or any other separator between the,

symbols of the string. We'll use the

notation sigma star to mean the set of all

possible strings over, a particular finite

alphabet sigma. The length of the string

is the number of positions and it should

be a common idea from a language like

java. And we will use epsilon to stand for

the empty string or string of length zero.

Something which you meant find by quote,

quote, in, one or another programming

language. Okay, so here is an example,

first of all, zero one star is the set of

all strings over the binary alphabet of

zero and one. Here is a list of some of

the, strings, We'll do it shortest length

first so the empty string is of course of

length zero and then zero is the string

consisting of the single character zero,

one, again a string of length one, with a

character one, and then you have things

like zero, zero and so on the four strings

of length two, and so on. There are

infinite number of strings of course in

zero, one, star. [sound] eh, you might

notice that when I write something like

zero, that could either be the character

zero, the symbol zero, or it could be a

string of length one that has one position

and in that position is a zero, it these

are not the same thing, they are different

types of objects, no question about that,

but, you can generally tell whether I am

talking about strings or, or symbols for

example only strings can be members of

languages, symbols can't be members of a

language although you could have obviously

a string of length one which looks like a

symbol [sound] Now language is a sets of

strings and they can be finite or infinite

sets of strings. The only limitation that

we place on a language is that there is

some finite alphabet from which all the

strings of the language are composed. The

Language L given as an example has 01 as

its alphabet. It has all strings that do

not have two consecutive 1s okay, so the

empty string is there and both strings of

length one, that is zero and one, of the

strings of length two all are there except

one, one, right, because one, one does

obviously have two consecutive ones. Five

of the eight possible strings of length

three are there. The other three possible

strings do have consecutive ones. And I

haven't shown it all here, but there are

eight of the sixteen strings of length

four, are present. Now, just to give you,

throw out a little bit of, of a question,

you see that there is one of length zero,

two of length one, three of length two,

five of length three Eight of length four,

you might think about how many would there

be of length five. There' s an obvious

pattern, it would be interesting for you

to try to figure that out. Okay. Now,

deterministic finite automata okay it's a

formalism for defining languages and that

formalism consists of a finite set of

states okay, and with any use cap Q

typically as the set of states of a

[inaudible] if I don't tell you anything

else, give it ano-. Give that set of

states another name, but then think of it

as Q. There will be an input, input

alphabet which we will typically call

capital Sigma. There will be a transition

function typically again denoted delta.

There will be a start state, and the start

state's always in obviously it's one of

the states, so it's in the set Q,

typically write it as Q0. As you see

there. And there will be a set of final

states which we will typically call F and

the set of final states is always a sub

set of obviously the set of all states.

The thing that makes the automaton work is

the transition function. This function

usually denoted by delta takes two

arguments. A state Q and an input symbol

A. It gives you back the state that the

automaton goes to when it is in state Q,

and the next input symbol to arrive is A.

The function delta is total, that is it

has a value for every state and symbol.

There are examples of automata where we

really don't want to continue in certain

situations. For example our example our

tennis automaton did not have transitions

out of the two states where one player or

the other has won the game. To fix up such

situations, we have to introduce a dead

state. A dead state is a state that is not

accepting and that has a transition to

itself on every input symbol. Once you get

to a dead state you cannot leave and you

can never accept, so dead is a pretty good

description of what is going on. We're

going to use the, abbreviation DFA for

deterministic finite automaton. The

deterministic means that there is a unique

transition for every state and input

symbol. We're going to meet

non-deterministic automata soon and there,

it is possible to transition to many

states from one state on one input. Here

is a tennis example. Notice that the two

final states have two transitions out. So

we add a dead state And all the missing

transitions go to that state. The

transitions from the dead state are to

itself on all possible inputs. In this

case that would be just S and O. Notice

this is the probably the first example

where we have more than one symbol, label,

labeling in R. That's just fine. Now,

we're going to represent a general DFAs by

graphs. Pretty much as was done in the

tennis example. Nodes of the graph,

correspond to states of the DFA. An arc

represents a transition func- the

transition function. An arc from say state

P to state Q. Labeled will be labeled by

all those symbols say A and B. That have

transitions from P to Q. There will be an

arrow labeled start to the start state so

we do something like this perhaps and

we'll indicate final states by double

circles so if Q is final, we would put a

double circle around there. This is an

interesting circle of an automaton that

processes text. The goal is to recognize

the string read so far in [inaudible] in

I, N, G. Okay, the start state which we

see here... Represents a condition where

we have made no progress towards seeing I,

N, G If in that state we see an I, that we

have made some progress. So we go to a

state that says I was the last symbol C.

That's the state that we call saw I.

Otherwise, we're going to stay in the

start states so there's a transition on

every symbol, every letter but I. To the

start state that says that we're really,

we made no progress. Now, from the saw I

state, If we next see an N then we've made

more progress and we go to the state,

that, as we've seen The sequence IN. On

the other hand, if from saw I we see

another I, then we've not made progress

but neither have we lost ground. We may be

reading a word like skiing with a double I

and thus the transition from state saw I

on I is to itself, that's right here. On

any symbol other than I or N we go from

the saw I state back to the start state

where we're seeing nothing. In state saw

N. If we next see G then we win. We have

just seen ING and we go to the accepting

state which is saw ING. On the other hand,

if we're in state saw N and we see an I

then the pattern IN is broken but there's

a new pattern beginning I that has started

so we're gonna go back to the saw I state.

That's this transition. On any input other

than I or G including an N from the saw in

state we have no progress at all so we go

back to the start state. Finally, from the

state saw ING we can only go back to saw I

if we see another I. That's this. Or if we

see anything but an I, we have to go back

to the start state where we've seen Here's

another example. It's an automaton that

represents the simplest possible protocol

for sending data. The program is in one of

two states; ready and sending. It starts

in the ready state. And eventually it gets

a signal that some data has been loaded

into its buffer at that point it enters

the sending state where it does whatever

is necessary to transmit the contents of

the buffer the receiver will send an act

symbol when the content is received in

which case we can return to the ready step

However if the receiver is down, we may

instead get a local timeout signal that

warns something is wrong and the buffer

must be retransmitted. This automaton does

not complete. There are no final states

because the automaton is designed to run

forever without rendering a decision. Also

there are missing transitions. Now it is

okay to ignore the act or timeout signals

when you are in the ready state, staying

therefore in the ready state so we might

draw for example In R from ready to ready

and that could include signals, time out,

and ack. Okay. That's probably okay.

However, a data in single in the sending

state is an indication of an error so we

might want to go to an error state. So you

are going to have an error state. And if

you are in the sending state and you

receive a data in signal, you go to that

error state. Okay, now, each, state, of

course error er, has a transition out on

each of the three signals, static and act

and time out. A tech, a technical question

that's asked about protocol is whether you

can get to an error state. We could for

example make the error state the final

state so I'll garble carefully here and

oh, by the way, it's really a dead state

so I probably oughta add transitions on

any of the three sym-, input symbols. And

one of the interesting things about

[inaudible] is that it's possible to

answer questions like can this [inaudible]

ever get into the error state. Okay,

that's a question of course you could not

ask about programs in general. For a

running example, we're going to use this

automaton. It's language is the set of

binary strings that do not contain two

consecutive zeros. State A, where the

automaton will be whenever the input

string seems so far is good. That is it

contains no consecutive 1s. Also it does

not end in a one. Surely the state should

be a start state since when no input has

been received, there are two no two

consecutive 1s and moreover the input does

not end in a one. We get to state B when

the input is good, that is no two

consecutive ones, but the last symbol seen

is a one. Notice that the only way to get

to B is to be in A and then get an input

one. C is actually a dead state. We're

there whenever two consecutive ones have

been received. We arrive at C for the

first time from B, which you recall means

that the previous input was one, and in

state B we receive a second one. Once in C

we stay there because once a string has

one, one you can never undo that fact, no

matter how many zeroes you see. Okay. Here

is, the other representation that we're

going to use for finite automata. A

transition table, okay. The ... This, this

transition table that we are showing here

represents the same automaton as the

little graph that I ... I show in the, in

the corner over here. Okay. Now in the

table the rows correspond to the states.

So you can see there, there is a row for

A, B, and C. The columns correspond to the

input symbols. We have columns for zero

and for one. A final state will represent

by starring it in its column in its row

sorry and we will put an arrow next to the

star state now the entries to the table

are the values of delta, so for example,

this entry is in the row for B and the

column for one. So it represents delta of

B and one, that is the transition that you

make from state B when you get input one.

And you can see on the, well, here at the

automaton, if you're in state B and you

see a one, you go to state C. So that's

why the entry there is a C. Okay, now

we're gonna use a convention which is

actually very important because it reminds

you of the types of things that might

otherwise be confusing. That is, we will

use lower case letters near the end of the

alphabet; w, x, y, z and maybe u

occasionally to represent strings of input

symbols. On the other hand, letters at the

beginning of the alphabet, typically A, B

or C will represent single input symbols,

remember these are analogous, to,

characters in a language like java or, or

C. Now, The delta function was defined you

give it, you give it a, a state, and you

give it a single input symbol. We want to

extend it so that you can give the

function a, an argument that's a state and

another argument that's any string of

symbols including the empty string. Okay,

and we want the extended delta applied to

state Q and any string W to tell us where

the automaton get to, if follows the path

of the transition diagram from Q, where

the arcs are labeled by each of the

symbols of W in order That is we look for

the unique path who's labels form W. In

the text we put a hat over the delta to

remind us that it is the extended version.

However, as we are going to see very

shortly the extended delta agrees with the

given delta when the string W is of length

one. That is, when it's a single symbol.

Thus there's not really a need to

distinguish the extended and the original

deltas and we're not going to do that

here. Now the, extended delta is defined

inductively, that is it's an induction on

the length of the string. The basis says

that delta of Q and the empty string is

just Q. That is, if you're in state Q and

nothing arrives in the input then you're

gonna stay in state Q. That's the nature

of how an automaton works. For the

induction, suppose the input string is WA.

Okay, now remember our convention,

whenever you see something like WA you

know that W is a string of some length,

could be empty even but it is a string.

And A being at the beginning of the

alphabet is a single symbol. Okay, this is

sort of the mathematical analog of type

definitions of program variables. Now, the

inductive rule says that, we first see

where you get, where you get from state Q

on string of inputs W. That is, we're

going to recursively use the extended

delta to figure out what delta of Q and W

is. And then that is going to be some

state. I dunno what it is, P. Then we

apply the original delta function to delta

of that state. And put, the last input

symbol A. Okay so here is an example I am

using the, transition, table,

representation of the, same automaton we

have been playing with. Okay. I want to

figure out what the extended delta is from

state B and 011. Now, 011 is broken up

into a string that is 01 and a final

symbol one. Okay. So what that tells us to

do is figure out what delta of being 01 is

that that's the string everything but the

last symbol. And then apply the original

delta function to that string and the last

symbol one Now, what's delta of B and zero

one. Well, it's a string and another

symbol. So I can break that up using the

recursive rule to say that it's the delta,

the standard delta function applied to

delta of D and zero and the final symbol

one. And then, okay. Now I know what delta

B and zero is, I can look it up. Oh, here,

B and zero is A. So I can replace this by

an A. That's what I have here. Okay. Now,

I know what delta of A and one is. I'll

look it up A, one that's B. Okay. So I

replace that by B. And now what's delta of

B and one? It's C. That's, that's that. As

I mentioned, the extended delta wears a

hat in the text book. However we really

don't need to distinguish the two deltas

because they agree on the single symbols.

That is, if we want the extended delta for

a state Q and a string consisting of one

symbol A, formally we treat that string as

the empty string followed by the symbol A.

Then we have to compute delta hat of Q and

epsilon. That's, what we have done here.

But we know by the basis rule that that's

Q itself and therefore, the extended delta

of Q and A is just the original delta

applied to Q and A. In fact I really

cheated on the previous slide. I needed

delta hat of B and zero and I just went to

the table and looked it up as if it was

delta of B and zero. Now we see that it is

so there was no harm, no foul. There are

many different kinds of automata. We've

seen only the deterministic [inaudible] of

automata so far. But there are many

others. But no matter what kind of

automaton, its job is to define some

language. We'll use the notation L of A to

refer to the language defined by the

automaton A. If A is a deterministic

finite automaton, then the language it

defines is the set of strings to take the

start state to a final state. That is,

your zero is as high as the star

[inaudible] and set of strings That get

you to a final state. Okay, formally that

was defined that the language of A is the

set of strings W such that delta of Q zero

and W is in F. Okay, so, here's an

example, string 101 is in the language of

running DFA. We start in the start state

right here. We follow the first one. That,

that's a string. From B we follow the zero

that gets back to A. From A we follow the

third one, the third addition, which is a

one getting us to B, B is an accepting

state so 101 is in the language. That

makes sense given that the lang-, the

automaton is supposed to accept the

language of all strings that don't have

two consecutive 1s and obviously 101 does

not. Okay, the expression, this expression

It is called the set former. It starts

with a curly brace and then an expression

representing the things that we want to

put in the set. So, in this case, the

expression simply says that the set

consists of some string's W. We know again

that they're strings because of our

convention. That, that the letters at the

end of the alphabet represent strings. The

vertical bar can be read such that And

then there will follow a description of

what must be true for something to be a

member of the set. In this case, it's

saying that W is, binary string that it's

in, it's in the strings over alphabet zero

one. And W does not have two consecutive

ones. That that's what I've been telling

you all along the language of this

automaton was. We're going to prove that

the DFA that we've been playing with

accepts the language I claimed it does: a

set of binary strings without consecutive

ones. I'm going to spend a good deal of

time proving this simple result because it

will give you all the details about how

one proves something about languages. In

the future I'm not going to be so focused

on proofs, but I think it's important that

everyone go through one of these proofs in

all of its gory detail. To prove sets

equal we generally mean to just prove two

things, that each is contained in the

other. That is we stop by assuming W is a

member of one so as and we use that fact

to prove that W is in the other too. Then

we start all over and we assume that W is

in two. We use that to prove W is also in

S In what follows, we take S to be the DFA

that we've been playing with and T to be

the set of binary strings without

consecutive 1s. First, we're going to

prove that if W is accepted by the

automaton, then W has no one ones and the

proof is an induction on the length of W.

It turns out that if we simply try to

prove this statement we fail. And I'll

point out in a few slides what goes wrong.

A common trick for inductive proofs is to

make a more detailed statement than you

really want because it makes the inductive

proof work. Here you need to distinguish

whether an accepted string gets you to

state A or B because we need to know

whether or not the string ends in one even

though the conclusion no one ones is true

in both the states A and B. The inductive

hypothesis will have two parts. Okay, part

one says that if W gets you to state A

then not only is W good in the sense that

it doesn't have consecutive 1s but it

doesn't even end in one Part two says that

if W gets you to state B, then W is still

good but it must end in one. Okay. The

basis is when the length of W is zero,

that is W is the empty string. By the way

notice that the bars around the string

represent the, that we want the length of

that string. So bar W bar means length of

W. Now let us prove part one of the basis.

Delta of A and the empty string does equal

A so if part is true but the conclusion is

also true because the empty string

obviously does not have executive 1s and

does not end in one. For part two, the

things are a little trickier. It is false

that delta of A and the empty string

equals B, but unfortunately it is also

false that the empty string ends in a

single one. Okay, however an important

principle of logic is that the statement

false implies false is true. That is,

whenever the if portion of the statement

is false it doesn't matter whether the

then, portion is true or not. The

statement as a whole is true. Thus a

statement like, 'if I am superman, then I

wear red undershorts' is a true statement

simply because I am not superman. You

don't have to concern yourself with the

color of my undershorts. The mathematical

term for an if then statement that is true

because it is the [inaudible], [inaudible]

is that the statement holds vacuously. To

begin the proof of the inductus step we

assume W is a string of length of at least

one and we assume that the inductor has

opposites that is statements one and two

of that string that gets the automaton to

stage A and B. It's true that [inaudible]

shorter than W Let W equal XA by our

convention A is the last symbol of W and X

is all the symbols, possibly none, up to

not including the last symbol of W. Since

X is shorter than W, we assume the

inductive hypothesis for X. We're going to

improve both statements one and two for W.

[sound] let's start with one. That is if

delta of A and W is A then W is good and

does not end in one. How do you get to A

by reading string X followed by symbol A?

Well look at the diagram. The only

transitions into A Are on input zero, that

is they're here and here. So A must be

zero. That immediately lets us conclude

the unit does not end in one. Furthermore

these transitions to A are only from A and

B. Thus X must get us to either A or B. In

either case we can conclude using the

inductive hypothesis that X is good it has

no consecutive 1s. Thus W has no one no

consecutive 1s, and surely does not end in

one. Now for part two. If delta of A and W

is B, then W is good and ends in one. Now

there is only one way to get B. You have

to be in state A and the input has to be

in one. That is this transition right

here. Thus if W is X followed by A. Then

we know X gets us to state A and the, the

input symbol little a is one. We can

therefore conclude that W ends in one. Now

we imply the inductive hypothesis, to X

and we conclude that X not only has no

consecutive 1's, but it doesn't end in one

because it got us to state A. Thus the

fact that W is X followed by A doesn't

allow the possibility that W ends in

eleven. And since any occurrence of one,

one and W, would either have to be at the

end or lie completely with an X we

conclude that W does not have any

consecutive ones. Notice that if we go and

use this more complicated inductive

hypothesis where we distinguish between

states A and B according to whether the

string ends in one, string X ends in one,

then we can not make the inductive proof.

If we know only that X gets us to A or B

if it's good, then it might end in one and

get us to state A in which case W equals

XA would have two consecutive 1s and yet

get us to B. That therefore we would not

be able to push though inductive

hypothesis that didn't distinguish between

whether we get to state A or B. [sound]

Well we're not done. We still have to

prove that T is contained in S, that is if

W is a good strength, no consecutive ones

then it's accepted by the automaton. It is

helpful to restate what we need to prove

in it's contra-positive form which is

logically equivalent to the original. The

contra positive of an if then statement

say if X then Y is if not Y then not X. We

can see why this is an equivalent

statement since if Y is false it couldn't

be that X is true because whenever X is

true Y is true. In this case X is the

statement that W is a good string. That is

it has no 11s. And, and Y is the statement

that W is accepted by the automaton. The

contra-positive is that if W is not

accepted by the automaton then W is not a

good strength that is it contains one, one

as a sub string. Because there is an

unique transition from every state and

every input symbol, each W gets the, DFA

to exactly one state. Thus the only way W

is not accepted is if it gets you to C.

Notice that the only way to get the

automaton to see it, is for some string X

to get it to B. That is, that is here. And

then from input one to follow. Once in C,

you stay in C so anything can follow the X

and the one. We'll call that Y, that is

any string W that gets the automaton to

see must be of the form X one Y where X

gets us to B. [sound] We already observed

that the only way to get to B is by a

string that ends in one. Since the only

transition into B is on a one. That's

this. Thus X must be of the form Z1 for

some Z. Thus W can be written as Z11Y and

we conclude that delta of A and W if W ...

Sorry. We can conclude that if delta of A

and W is C then W is bad. That is it

definitely contains two consecutive ones.

Now we introduce a class of languages

called regular languages. These are the

languages that have a DFA accepting them.

That means that the languages exactly the

set of strings accepted by this automaton.

Soon we shall see that there are several

other ways to describe the regular

languages including the regular

expressions and several forms of non

deterministic automaton. [inaudible] While

many common languages are regular there

are also many that are not. Intuitively

[inaudible] automaton cannot count beyond

a fixed number thus they cannot do things

like check whether it has seen the same

number of zeros as ones on the input or

check the parentheses are balanced and are

arithmetic expression. For these tasks we

need more powerful mechanisms such as

context free grammars which we shall meet

soon enough. Here is an example of a

language that is simple to understand but

is not a regular language. To understand

what this notation is saying we first need

to know that at exponent I and a symbol is

shorthand for the string consisting of

high copies of that symbol. Thus zero to

the fourth is a shorthand for zero, zero,

zero, zero. We read the [inaudible] from

her that is as zero to the N one to the N

such that N is greater than or equal to

one or more [inaudible]. The set of

strings consisting of N zeros followed by

N ones such that n is at least one. The

strings in the language L1 are thus 01

0011 three zeros followed by three ones

and so on you get the pattern alright.

[sound] Okay here's another example the

set of W such that W is in the set of

strings formed by the left and right

parentheses and W is balanced. Okay I hope

people are familiar with the idea of

balanced parentheses, but intuitively

they're just those sequences of

parentheses that can appear in some

arithmetic expression. For example this

string could appear in an arithmetic

expression like A plus B times C plus D,

notice you've got left, right, left,

right. Okay. An example of strings that

are not balanced, well, right then left

is, is obviously not balanced. You can't

have, ever have in any prefix of the

string more right parenthesis than you

have left parentheses. Another example of

a non-balanced string would be left, left,

right, because there you have more, lefts

than rights. However regular languages are

common. For example in each language there

is a format for floating point numbers and

this format can be quite complicated with

optional E's and or optional decimal

points and strings of digits that could or

could not be empty. But in all programming

languages I know about the set of strings

that represent some floating point number

forms a regular language. Okay. This is a

very interesting case illustrating what

finite memory really means. We want to

know if a binary number is divisible by

twenty three. We're going to read the bits

high order first, but we have only finite

memory. How can we remember exactly what

sequence of bits has been read since the

sequence can grow very long and in

particular longer than the number of

states or longer than any limit that you

might care to put on it. Okay. But there's

a trick. We don't really need to remember

everything about the bits read. It's

sufficient to remember what the remainder

is. When we divide the number by twenty

three. Thus, we're gonna have twenty three

states, corresponding with the twenty

three possible remainders when an integer

is divided by twenty three. These are of

course zero through twenty two. The start

state is zero because we interpret an

empty string as representing zero. That

may be a bit of an assumption, but nothing

else makes sense and treating it as zero

makes everything work out right. The state

zero is also the only final state since we

want the inputs that leave a, that leave a

remainder of zero when divided by twenty

three. We're going to assume that things

are working right after reading a binary

string W. That is W takes state zero to

the state that is the correct remainder

when W is divided by twenty three. I'm

using the C style percent operator to

denote remainder. You can also read the

percent as modulo, which is just another

way of saying the remainder when divided

by. Okay? So, I percent twenty three is

the remainder when I is divided by twenty

three or I modulo twenty three. The

transition from each state I on input zero

is to the state that is the remainder of

2I divided by twenty three. To see why

this works, we know that I is, can, let's

see can be written as I equals twenty

thr-, sorry, twenty three A plus B for

some integer A and some integer B that's

in the range zero to twenty two. That is B

is the remainder or I modulo twenty three.

Okay. Then two I is what? It's, well it's

forty six A plus two B. Since forty six is

divisible by twenty three we can sort of

forget it, okay, so what we have, what we

have left is that two I is two B. Okay.

Now if we want the remainder, of two I

when I is divided by twenty three, we can

just take the remainder of two B divided

by twenty three. The important point is

that we never need to know what A is and

we never need to know I exactly. We just

need to know its remainder. Now, for the

same reason, when a one arrives in the

input we can go from state I to the state

that is the remainder of two I plus one,

when that's divided by twenty three.

That's two I plus one mod-, modulo twenty

three. For some examples, delta of fifteen

and a zero, that's state fifteen and input

zero, double the fifteen you get thirty

and then you take the remainder of thirty,

divided by twenty three and that's seven.

On, in, but zero state fifteen goes to

state seven. For another example, if

you're in state eleven and a one comes in.

Well, twice eleven is twenty two plus one

is twenty three. So it's twenty three mod

twenty three which is zero. So that says

whenever you're in state eleven and a one

comes in, you go to state zero. And what

that means is that any string that leaves

a remainder of eleven no matter how long

that string is if it leaves a remainder of

eleven you follow it by a one, it will be

exactly divisible, divisible by 23.

Interestingly you can also recognize all

the binary strings divisible by 23 or any

other particular number if we like. If we

[inaudible] the strings in backwards that

is [inaudible] first for example this

string zero one, one, one, zero one zero,

zero is in the, this language because if

you reverse it you get this string: zero,

zero one, zero one, one zero. And if you

convert that to binary you get forty six

and obviously forty six is divisible by

twenty three. Now, I challenge you to

construct the DFA for this language L

four, but it exists. Okay. There's a

theorem which we're soon going to see that

says if a language is regular than its

reversal, that is what you get by

reversing each of its strings, is also a

regular language. The proof of the theorem

will let us construct the DFA for the

reverse language from the DFA we just saw.

- Dac v3 Bonus FunctionalityUploaded byisopharius4462
- Finite State Machine Pattern - The One True Pattern - Stack OverflowUploaded byBogdan Comsa
- Security & Rules API - FirebaseUploaded byJC Yocop
- QIUploaded byujjwal123456
- cp manUploaded byChirag Patel
- AI793C Lab NotesUploaded byNilanjan Mondal
- DX 901 Developer Guide EnUploaded bySuneel Bandi
- SumitaAroraChap8ProgramsUploaded byAbhinav Longwal
- acctest.psUploaded bygardenergardener
- tmp5B8.tmpUploaded byFrontiers
- 00170224Uploaded byRafia Naz Memon
- IP ProjectUploaded bySiddharth kumar jha
- Cmm Serial IoUploaded bySamir Benabdallah
- 1340-CS2303.docUploaded bySandeep Kumar
- compiler-lexical analysisUploaded byvidhya_bineesh
- Dynamic_Programming_-_Set_29_(Longest_Common_Substring)_-_Ge.pdfUploaded byAmbati Lakshmana Rao
- Srchfor(con varianets de Busqueda).pdfUploaded byriomar
- cmu05Uploaded byDeion Liew
- MCA - System Programming (Set-2)Uploaded byleohunter
- codingbat-python-soru-cevap-2.pdfUploaded byrrs_1988
- 1 Set TheoryUploaded byAlex N. Mabalot
- Lab Manual Seq DetectorUploaded byrkpkd
- fUploaded byPaulo Souza
- unit5Uploaded byLalith Kumar
- uml_patterns.pdfUploaded bysamim71
- Efore You Run the SampleUploaded byNaveen Madiraju
- Excel Advance CurriculumUploaded byadityaintouch
- Lecture 6Uploaded byNava Krishnan
- Data Cleansing Text HandoutUploaded byMatheus Fidélis
- Programs UnitUploaded byJesvin Bency

- 22_pnp3Uploaded byHuong Luong
- 21_pnp2Uploaded byHuong Luong
- pnp1Uploaded byGauri
- 6 - 3 - 22. Specific NP-complete Problems (33 Min.)Uploaded byHuong Luong
- 6 - 2 - 21. Satisfiability and Cook's Theorem (44 Min.)Uploaded byHuong Luong
- 6 - 1 - 20. P and NP (25 min.)Uploaded byHuong Luong
- 19_tm4Uploaded byHuong Luong
- 19_tm4Uploaded byHuong Luong
- 18_tm3Uploaded byHuong Luong
- 17_tm2Uploaded byHuong Luong
- 5 - 3 - 19. Specific Undecidable Problems (56 Min.)Uploaded byHuong Luong
- 5 - 2 - 18. Decidability (18 min.)Uploaded byHuong Luong
- 5 - 1 - 17. Extensions and Properties of Turing Machines (37 Min.)Uploaded byHuong Luong
- 16_tm1Uploaded byHuong Luong
- 15_cfl5Uploaded byHuong Luong
- 14_cfl4Uploaded byHuong Luong
- 13_pda2Uploaded byHuong Luong
- 13_pda2Uploaded byHuong Luong
- 4 - 4 - 16. Turing Machines (34 Min.)Uploaded byHuong Luong
- 4 - 3 - 15. Decision and Closure Properties for CFL's (35 Min.)Uploaded byHuong Luong
- 4 - 2 - 14. the Pumping Lemma for CFL's (12 Min.)Uploaded byHuong Luong
- 4 - 1 - 13. Equivalence of PDA's and CFG's (18 Min.)Uploaded byHuong Luong

- First IOP Test ReportUploaded byEngineering
- ADS--229983#1-EN-00Uploaded byHuseyin Gokhan Adiman
- Software Engineering Jobs Prospects (Report Writing)Uploaded bybalti
- TMS WebUpdate Developers GuideUploaded byaltamirosantos
- lmomcoUploaded byMalim Muhammad Siregar
- Ccna 2 Practice Lab SolutionsUploaded bySandrino Postelnicu
- UNIX Linux NotesUploaded byAnandhababuS
- Admit,Reject 2015Uploaded bySai Adarsh
- Tesla Outsourcing Services - Deliver Elusive CAD Services And BIM Services To Global ClientsUploaded byTesla Outsourcing Services
- Paranoia XP - Alpha Complex Nights 2Uploaded byStBash
- tor-and-the-dark-art-of-anonymi-henderson-lance.pdfUploaded byq967843
- go-pear.batUploaded byDeepak Gupta (DG)
- Telecommunications Switching Systems 3Uploaded byRamcharan Buddi
- momuserdoc_en4_1Uploaded byDoru Stoica
- Oakton 150 PH-CONUploaded byJadyr No Lo Pensaba Usar
- Color PAL - 28380Uploaded byFix Ingeniería
- osUploaded byJay Hidup
- Et200s 4di Dc24v Hf Manual en-USUploaded byIgor Tusjak
- X BT Leaflet en W3637Uploaded byEdson Camarena Vera
- AN-1215 - IRAM256-1067AUploaded bybetodias30
- ML620_621 User Guide AeUploaded byMiguel Carrillo
- CME200_AnswerBook_evennumberedUploaded bylukethepirate98
- BBP_150_IDEA_QM_06_Recurring Inspection.docxUploaded byKesav Boojala
- CTMS: The Seven Deadly SinsUploaded byBob Borysko
- External Connection Add-In.pdfUploaded byanon_984093298
- Beginner's Guide - MillenaireUploaded byMaxime Hernalsteen
- R150PC59Uploaded byMarcos Gomez
- Create Database in AmibrokerUploaded bymaddy_i5
- Notes on concurrency controlUploaded byAbhisek Sarkar
- IS PRIVACY DEAD LISTENING SCRIBDUploaded byAngel Angeleri-priftis.