# CHAPTER 5 FINITE STATE MACHINES

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 page of Section 5. HPTER 5 FINITE STTE MHINES SETION 5. FSMs WITH OUTPUTS a finite state machine (FSM) with outputs FSM (also called a finite automaton) with outputs is an abstract device consisting of a finite number of states (one of which is called the starting state), a finite input alphabet and a finite output alphabet. Initially the FSM is in its starting state. It receives a symbol from its input alphabet, in response emits a symbol from its input alphabet and moves to a next state. FSM is considered to have memory (as you'll see in examples) because the current output depends not only on the current input but on the present state of the machine which itself is a summary of the past history of the machine. The state diagram in Fig shows a FSM with input alphabet, and output alphabet p,q,r. The states are (the starting state), and. To see how the FSM works let's find the output corresponding to the input string. The leftmost symbol in the string is fed in first. The FSM is initially in its starting state and when input is received, it produces output p and moves to next state (i.e., stays in ). fter the next input,, the FSM produces output q and moves to next state. The table in Fig 2 lists the successive outputs and next states. ll in all, the output string is p q p r p p q input output STRT /p /q /p /q /r input output p q p r p p q next state /p FIG 2 FIG The state table in Fig 3 contains the same information as Fig, but in different form. For example the second line of the table in Fig 3 says that if the FSM is in state and the input is then the output is r and the machinemoves to next state ; if the input is the output is p and the next state is. state output next state input input input input p q r p q p FIG 3 finite state machines as recognizers Look at an input string of symbols, called a word. The FSM recognizes the word if the last output is. It's often necessary to design a FSM to recognize a class of words (e.g., the compiler in a computer must to be able to recognize inputs of a certain form).

2 page 2 of Section 5. example Suppose you want a FSM with input and output symbols, which recognizes words ending in, i.e., which outputs a final if a word ends in and outputs a final otherwise. Note that if a FSM is to recognize words ending in then it must output a after every occurrence of in an input string in case the word suddenly ends there. Fig 4 shows a sample input string with the corresponding desired outputs. input output FIG 4 Fig 5 shows the FSM recognizer. / / / / / / FIG 5 Recognizes words ending in State "remembers" that (i.e., is reached when) neither of the last two inputs were 's so that a block isn't in the making yet. The machine won't switch to another state until you do get an input, and a block starts to grow. State remembers that the last input was. The FSM stays in state until it receives an input and a starts to grow further. State remembers that the last two inputs were. If the next input is, the output is a to signal that a was completed, and the next state is since the last input may be the beginning of a new. If the next input is then the output is indicating that a was not achieved, and the FSM sends you back to to try again. PROLEMS FOR SETION 5. /p. Fill in the following table for the given FSM /p /q /r input output next state /q /p 2. Let the input and output symbols be,. esign a FSM to recognize the set of words which (a) contain an even number of 's (remember that a word with no 's, i.e., with zero 's, should be recognized since is an even number) (b) contain an odd number of 's (c) contain no 's (d) contain exactly two 's (e) contain at least two 's (f) end in

3 page of Section 5.2 SETION 5.2 FINITE STTE MHINES WITH EPTING STTES INSTE OF OUTPUTS definition of a FSM with accepting states Suppose a FSM is designed with no outputs. Instead, some of the states are called accepting states, denoted by a double circle. In Fig, states and are accepting, and are non accepting. The numbers on the edges are the inputs. FSM with outputs (preceding section) recognizes (accepts) an input word if the last output is. FSM with accepting states (this section) recognizes (accepts) a word if the machine is left in an accepting state after the word has been processed. Fig shows a FSM with accepting states instead of outputs and a table for the input string. The string is accepted because the machine ends up in, an accepting state. input next state FIG example Fig 2 shows a FSM with accepting states which accepts the set of strings ending in FIG 2 converting a FSM with accepting states to a FSM with outputs Make the output for each transition into an accepting state and for each transition in a non accepting state. Fig 3 shows the FSM with accepting states from Fig converted to a FSM with outputs. The table shows that the string is accepted because the last output is. / / / input output / next state / / / / FIG 3 The output version of Fig

4 page 2 of Section 5.2 and vice versa --- converting a FSM with outputs to a FSM with accepting states I'll illustrate how to do it with the FSM in Fig 4. When the FSM in Fig 4 enters state it emits output or, depending on the state you're coming from. To make an equivalent FSM with accepting states, replace state by non accepting and accepting state, the former to be entered only as the machine emits and the latter only as the machine emits. Similarly is replaced by non accepting state and accepting state so that the no output version will have four states, not two. The table in Fig 5 shows how pieces of the original FSM are replaced by new pieces. Fig 6 shows the new FSM with accepting states. / / / / FIG 4 FSM with outputs FSM with outputs / FSM with accepting states / / / FIG 5 Note that in the new FSM the exits from and must go to the same state, (happens to be here). nd the exits from and must go to the same state (happens to be here) accepting state version of the FSM in Fig 4 FIG 6 In general, if there are transitions into a state Z with outputs of and then Z gets split into non accepting state Z to receive the transitions with output and accepting state Z to receive the transitions that had output. nd Z and Z each have the same transitions out as the original Z.

5 page 3 of Section 5.2 recognition capabilities of FSMs with outputs vs. FSMs with accepting states For every FSM with accepting states there is a FSM with outputs that recognizes the same words. nd vice versa. So you do not lose or gain recognition capability by switching from FSMs with outputs to FSMs with accepting states. footnote Well, actually you do gain recognition capability, in particular the ability to recognize the empty string, denoted. ut don't worry about it. The advantage of FSMs with accepting states is that they are easier to prove theorems about and since the two types have the same recognition capabilities, theorems coming later about FSMs with accepting states will also hold for FSMs with outputs. the empty string The empty string, i.e., the string with no symbols in it, is denoted. If the starting state of a FSM is an accepting state then the FSM is said to recognize. choosing the starting state in the equivalent no-output FSM The starting state of the FSM with outputs in Fig 4 is, so either or should be the starting state of the FSM with accepting states in Fig 6 If you use as the starting state, the FSM with accepting state accepts the empty string, since it's in an accepting state before any symbols comes in. ut the original FSM in Fig 5 doesn't recognize (no FSM with outputs can do that). So choose as the starting state rather than. inventing a new starting state if necessary I'll find a FSM with accepting states that is equivalent to (recognizes the same strings as) the FSM in Fig 7. / / / / / / FIG 7 ll transitions into emit output so don't split into two states; just make an accepting state in the new version. Similarly all transitions into emit output so becomes a non accepting state (no splitting). ut is split into a non accepting state and an accepting state. So far you have states,, and in Fig 8. ut you don't want to make the start since it's an accepting state and you don't want to recognize (because the original FSM in Fig 7 does not recognize ). So add a new state NewStart to serve as the start. Make NewStart non-accepting, with no transitions in and with the same exits as. NewStart FIG 8

6 page 4 of Section 5.2 mathematical catechism (you should know the answers to these questions) question Why bother converting from a FSM with outputs to a FSM with accepting states and vice versa. answer The fact that we can convert proves that the two collections of FSMs have the same recognition capabilities (give or take recognizing ). question 2 Why do we care that the FSMs with outputs and the FSMs with accepting states have the same recognition capabilities. answer When we prove a theorem about FSMs with accepting states (what they can and cannot recognize) the same theorem will hold for FSMs with outputs. PROLEMS FOR SETION 5.2. Let the input alphabet be,. Find a FSM with accepting states to recognize the set of strings (a) containing at least one occurrence of (b) ending in (c) where the number of 's is a multiple of 3 2. Let the input alphabet be a, b, c. Find a FSM with accepting states to recognize (a) words ending in abc (b) words containing at least one occurrence of abc (c) just the word abc 3. For each of the following FSMs use the official method in this section to find an equivalent FSM (i.e., one which recognizes the same strings) with accepting states instead of outputs. (a) (b) / / / / /,/ / (c) / / / (d) / / /,/ / / (e) / / / / / / / /

7 page of Section 5.3 SETION 5.3 NONETERMINISTI FINITE STTE MHINES definition of a nondeterministic FSM (assuming the alphabet is, ) The FSM with accepting states from the last section is a deterministic finite state machine (FSM) meaning that the next state is uniquely determined by the present state and input. From each state there is one exit and one exit. In a nondeterministic finite state machine (NFSM) there may be more than one exit or exit from a state, i.e., there may be several next states. There may be no exit or exit from a state, i.e., the machine may shut down and be in no state at all. For the NFSM in Fig, from state the input allows any of the three next states,,. From state, any input causes a shutdown. n input string is recognized (accepted) by a NFSM if the NFSM may be left in an accepting state after the word has been processed. You have to look at all the possible tracks to see if any of them reach an accepting state. For example, try the string in the NFSM in Fig. The several possible paths are shown in Fig 2. Since the second path leads to an accepting state, the string is accepted. warning on't say that the NFSM in Fig might recognize depending on which track in Fig 2 is followed. The definition says that the NFSM does recognize because at least one of the tracks leads to an accepting state., none FIG Example of a NFSM FIG 2 Multiple tracks for input shutdowns Look at the NFSM in Fig 3 and try input. The string is not accepted since the only track leaves the machine in no state. (In fact once a string begins with it's not accepted since the machine shuts down after the initial.) Note that from state with input the next state is "none", not ; the machine shuts down and is not left in state. in next state FIG 3 shutdown still shutdown example Fig 4 is a NFSM which recognizes words containing at least one occurrence of cat. For example, if the input is xcazcatd then there is a track ending in an accepting state (Fig 5) so the string is accepted. a-z a-z c a t FIG 4 x c a z c a t d FIG 5

8 page 2 of Section 5.3 the empty string The empty string or null string, i.e., the string containing no symbols, is denoted by. ny FSM whose starting state is an accepting state recognizes since in that case the FSM is in an accepting state before there is any input at all. Note that since is an empty string, the strings,, are all the same as. NFSMs with -moves ( NFSMs) The NFSM in Fig 6 allows transitions from to, to E, to with "input", i.e., with no input. These transitions are called moves. FIG 6 E In a NFSM with moves the state Q is said to be reachable from state P if there is a sequence of moves leading from P to Q. In Fig 5, E is reachable from (see the path E), is reachable from (see the path ). Furthermore each state is considered to be reachable from itself. In a small FSM like Fig 6 you can tell by inspection which states are reachable from which other states. Here's how to do it in a large FSM. First consider the FSM as a digraph with the states as vertices and the moves as directed edges (ignore other moves). Find the adjacency matrix M in which an entry of in row P, col Q indicates a move from P to Q; by convention 's are inserted along the diagonal to indicate moves from each state to itself. Then use Warshall's algorithm to find the reachability matrix M in which an entry of in row P, col Q indicates a path of moves from P to Q, i.e., indicates that Q is reachable from P. Here are the adjacency matrix and the reachability matrix for the NFSM in Fig 6. E E. E E adjacency matrix M for Fig 6 reachability matrix M for Fig 6 how to tell whether a NFSM accepts or rejects a string In a small NFSM you can tell by looking at all the parallel tracks whether or not a string is accepted. Here's an algorithm for deciding automatically. For a NFSM without moves, keep a record of the set of next states (as opposed to the unique next state in a FSM); a string is recognized by the NFSM if you end up with a set of next states which includes an accepting state. I'll test the string in the NFSM in Fig 7. From the starting state, the input leads to possible next states, (Fig 8). With another input of, from the possible next states are, and from the only possible next state is ; so the set of next states is,,. With the input, from the possible next states are,, from the only possible next state is and from there is no next state; so the set of next states is,. Since one of them, namely, is accepting, the string is accepted.

9 page 3 of Section 5.3, input next states,,,, accept FIG 8 FIG 7 For a NFSM with moves there are extra steps because if the NFSM is in say state P then even before the next input appears the NFSM may move to any state reachable from P. So before the first input you should move from the starting state to the set of states that are reachable from the start. nd after an input, if the current state is say any of,, then before the next input you should move to the set of states that are reachable from,. This amounts to testing a string as if there were 's before and after each character in the string. I'll test in the NFSM in Fig 9. The starting state is and states,,e are reachable from so the FSM is considered to be in any of states,,e as the first input,, is processed (Fig ). Of these three states only E has a transition, namely to. Fig continues to show inputs and next states. The string leads to the possible states,,e. Since one of these, namely, is accepting, the string is recognized (in particular see path E ). E FIG 9 input 's 's 's 's next states,,e,,e,,e accept FIG The FSM in Fig 9 accepts Let's try the string in the FSM in Fig 9. Fig shows that all tracks lead to the non accepting state. So the string is not accepted input 's 's 's 's next states,,e,,e,,e reject FIG The FSM in Fig 9 rejects NFSMs versus FSMs FSM can be physically constructed by engineers so that passage from state to state actually occurs inside the device. NFSM doesn't exist as a physical device but it is realistic in that its ability to recognize strings can be simulated by a computer program, in particular by the preceding algorithm. FSM can be thought of as a special case of a NFSM, the case where the options of having no next state, more than one next state and moves are not exercised. From that point of view it would seem that the class of NFSMs is "larger" than the class of FSMs. ut I'll show: () For every NFSM there is a FSM which recognizes the same words.

10 page 4 of Section 5.3 So we gain no extra recognition capability (and lose none) by expanding from FSMs to NFSMs. The advantage of the NFSMs is that it's easier to prove theorems about NFSMs than about FSMs and since the two types have the same recognition capabilities, certain theorems coming later about NFSMs also hold for FSMs. why () holds --- how to convert a NFSM to a FSM I'll illustrate the idea by finding a FSM that recognizes the same strings as the NFSM in Fig 2 (where the starting state is ). E FIG 2 The FSM will have as its states some or all of the states named ƒ,,,,, E,,,, E,,, E,, E, E,,,...,,..., E For convenience you can think that the names correspond to subsets of {,,,,E}. Here's how to choose the particular states and transitions. In the NFSM the states that are reachable from the starting state are (every state is reachable from itself) and. So for the new FSM the starting state will be named. To get the exit from state in the new FSM look at exits from and in the old NFSM. -> none -> none hoose to have a state named ƒ in the FSM. nd use it as the exit from. To find the exit from state in the new FSM look at exits from and in the old NFSM. -> none -> -> (lambda moves) hoose to have a state named as the next state (I'm starting to get the FSM in Fig 3.) To get the exit from state in the new FSM look at exits from in the old NFSM. -> -> ( moves),, Next state is named. warning on't forget to include these moves when they exist. In other words, fter, continue from to all states, including itself, that are reachable from, namely,,. To get the exit from state in the new FSM look at exits from in the old NFSM. -> none Next state is ƒ.

11 page 5 of Section 5.3 General Rule () (how to get started) If the starting state in the NFSM is X and the states reachable from X are E, Z then the starting state in the new FSM is named EXZ. (2) (how to keep going) To find the next state from say the state PQ in the new FSM when the input is, look at next states from, P, Q in the old NFSM when the input is. If say -> -> ( moves), X, Y P -> none Q ->, Z -> ( moves), Z, then the next state in the new FSM would be named XYZ If -> none P -> none Q -> none then the next state in the new FSM would be ƒ. (3) (transitions from ƒ (if ƒ is a state in the FSM). ll exits go back to ƒ. (4) (accepting states) state in the new FSM is called accepting if at least one of the letters in its name was an accepting state in the old NFSM. Here's the rest of the construction. To find the exit from, look at exits in the NFSM: -> none -> none -> none Next state is ƒ. To get the exit from, look at exits in the NFSM: -> E -> (lambda moves) E -> none -> -> (lambda moves) Next state is E To get the exit from E: -> -> (lambda moves),, E -> -> ( moves), Next state is warning on't forget the moves. If you leave out the moves you will mistakenly think that next state is. Messes everything up. To get the exit from E: -> none E -> none Next state is ƒ. nd finally, was the only accepting state in the old NFSM so the accepting states in the new FSM state are the ones whose name contains the letter (Fig 3).

12 page 6 of Section 5.3, φ E WRNING on't forget the exits from φ nd don't forget to say which are the accepting states FIG 3 FSM equivalent to Fig 2 To illustrate that the FSM in Fig 3 recognizes the same strings as the NFSM in Fig 2, I'll test the string. Fig 4 shows the progress of the string through the NFSM in Fig 2. It's rejected because the final set of states,,e, does not include an accepting state. Fig 4 shows the progress of the same string through the FSM in Fig 3. It's rejected because the unique final state, E, is not an accepting state. Note that the name of each unique next state in the FSM is an amalgam of the names in the set of next states in the NFSM which is why the conversion works. input 's 's 's 's next states,,,,e,,e reject FIG 4 input next state E reject FIG 4 example 2 Find a FSM equivalent to (i.e., which recognizes the same strings as) the NFSM in Fig 5. FIG 5 The starting state in the NFSM is and there are no moves from so the starting state in the new FSM will be named also. To get the exit from : ->,. Next state is Note: There are no lambda moves in the whole NFSM so I can leave them out. To get the exit from : ->. Next state is

13 page 7 of Section 5.3 To get the exit from : ->, -> Next state is To get the exit from : ->, Next state is To get the exit from : -> none Next state is ƒ To get the exit from : -> none ->, Next state is To get the exit from : -> -> none Next state is To get the exit from : -> none Next state is ƒ To get the exit from : -> Next state is The FSM is in Fig 6. The accepting states are and., φ FIG 6 mathematical catechism (you should know the answers to these questions) question Why bother getting the FSM recognizer in Fig 6 when it is messier than the NFSM recognizer in Fig 5. answer The fact that we can always get a FSM recognizer proves that we don't gain any recognition capability when we allow NFSMs. question 2 Why do we care about not gaining capability. answer When we prove a theorem about NFSMs (what they can and cannot recognize) the same theorem will hold for FSMs.

14 page 8 of Section 5.3 PROLEMS FOR SETION 5.3. Look at the NFSM in the diagram below and decide by inspection whether or not the NFSM recognizes (a) (b) 2. What set of strings is accepted by the FSM in the diagram below., 3. Let the alphabet be,. Find FSMs (with accepting states) to recognize the following sets of strings. Try to make them as simple as possible by allowing them to be non deterministic but do it without using moves. (a) strings ending in (b) strings beginning with (c) just the string (d) strings containing at least one occurrence of (e) strings containing no occurrences of (f) strings containing an even number of 's (g) strings with no 's (h) strings containing exactly two 's (i) strings containing at least two 's (j) strings where the number of 's is a multiple of 3 4. Let the alphabet be a, b, c. Find FSM recognizers for (a) the set of strings containing no occurrences of abc (b) (harder) the set of strings containing exactly one occurrence of abc Start with a FSM that ends up in an accepting state after the first occurrence of abc. nd then tack on the FSM from (b) to prevent any more occurrences of abc. (c) the set of strings containing at most one occurrence of abc. Suggestion djust the FSM from part (b) 5.(a) ecide by inspection if,,, are accepted by the FSM in the diagram. (b) Find the adjacency matrix and the reachability matrix.,, 6. Keep track of all next states as in Figs 8,, to see if is accepted by the FSM in the diagram.

15 page 9 of Section (a) Keep track of all next states to see if and are accepted by the FSM in the diagram. (b) Find the adjacency matrix (c) Find the reachability matrix.,, 8. NFSM has starting state, accepting state, input alphabet a,b and the following a adjacency matrix (an entry of in row P, col Q indicates an a transition from P to Q), b adjacency matrix and adjacency matrix. a adjacency b adjacency adjacency (a) Find the reachability matrix. (b) Test to see if the string aa is accepted. 9. Find an equivalent FSM (using the converting algorithm from this section).,, (a), (b) (c), E (d) STRT

16 page of Section 5.3. If a NFSM contains a cycle then it can be simplified by inspection. See if you can do it for the NFSM in the diagram which has cycle. a d S F c b. Suppose a FSM recognizes a bunch of strings. The reverse of the FSM is a new FSM which recognizes precisely the reverse strings. For example if the first FSM recognizes cat then the reverse FSM recognizes tac. Turns out that for every FSM there always is a reverse FSM. Find the reverse of the FSM in the diagram which conveniently has only one accepting state., 2. Suppose you start with a NFSM and are going to find an equivalent FSM using the method of this section. (a) If the NFSM has states what is the maximum number of states in the FSM. (b) If the NFSM has states, no parallel tracks but does have shutdowns (i.e., there are never two possible next states but sometimes there is no next state) how many states will the FSM have. 3. It can be shown that for every FSM with more than one accepting state there is an equivalent FSM with just one accepting state. To illustrate the idea let's try to find the one accepting state version of the FSM with two accepting states in Fig below. (a) I tried to do by merging the two original accepting states (Fig ). Explain why it doesn't work. (b) o it right (pretty easily) (think ). FIG FIG

17 page of Section 5.4 SETION 5.4 REGULR SETS concatenation of strings and sets The concatenation of two strings is their juxtaposition; e.g., the concatenation of pq and abc (in that order) is pqabc. The concatenation of the empty string with abc (in either order) is just abc, since contains no symbols. If and are sets of strings then the concatenation is the set obtained by concatenating all the strings in with all the strings in (in that order). For example, let = {a,b,cb} and = {pq,r}. Then = {apq, ar, bpq, br, cbpq, cbr} = {pqa, ra, pqb, rb, pqcb, rcb} = 2 = {pqpq, pqr, rr, rpq} the union of two sets of strings The union of two sets of strings and is denoted +. If = {a, } and = {pq,c} then + = {a,, pq, c} notation I'll write aaaa as a 4 and as () 3. the closure of a set of strings If is a set of strings then the (Kleene) closure, denoted *, is the set you get by concatenating the strings in with each other as often as you like in any order you like. * always contains the empty string because the definition includes the possibility of concatenating no times nd * always contains everything that was in because the definition allows concatenating just once.. For example, if = {x} then * = {, x, x 2, x 3,... } If = {a, bc} then words in * are formed by stringing together a's and bc's in any order, as many of each as you like. So some strings in * are, a, bc, abc, bca, a 4 (bc) 7 a 5 (bc) 8, bca 7 (bc) 8 etc. notation (ambiguous but convenient) The set {} is denoted by. So stands both for the single string and also for the set containing the string. Similarly the set {} is denoted by, the set {b} is denoted by b, etc. can mean just the string. Or it can mean the set {}, the set containing the string. It can also be thought of as the concatenation of the string and the string. example + is the union of the sets {} and {} so it's the set {, } + is the union of {} and {} so it's the set {, } * = {,, 2, 3,...}. nd especially ( + )* = {,}* = set of all strings of 's and 's including the string example 2 To get the members of (a + b*)*, first get a + b* = {a,, b, b 2, b 3,...} and then do a lot of concatenating. The result is the set of all strings of a's and b's including ; i.e., (a + b*)* is the same as (a + b)*

18 page 2 of Section 5.4 example 3 (ab)* c* d is the set of strings of the form (ab) n c m d where n, m. Some of the members of the set are d, abd, (ab) 5 d, cd, c 7 d, abcd, (ab) 4 c 7 d. versus ƒ stands for the empty string. y abuse of notation it also stands for the set containing. ƒ stands for the empty set. The sets ƒ and are not the same. One way to see the difference is to look at the different recognizers for them. The FSM in Fig recognizes the string, since it's in an accepting state with no input, and recognizes nothing else,. So Fig recognizes the set. On the other hand, the FSM in Fig 2 is never in an accepting state (there are no entrances to ), it doesn't accept any strings so the set of strings accepted is ƒ. FIG Recognizes the set FIG 2 Recognizes the set ƒ Furthermore and ƒ act differently when you concatenate or add with them: = = ƒ = ƒ = ƒ + ƒ = + might or might not be (it is if and only if is in to begin with) - ƒ = - might or might not be (it is iff is not in to begin with) example 4 To get the members of (ab*)*, start with ab* = {a, ab, ab 2, ab 3,...} and then concatenate as many times as you like in any order you like. The result is the string plus all strings beginning with a. For example, the string a 5 b 7 a 4 ba is in the set since it's of the form a 4 (ab 7 ) a 3 (ab)a The set of strings beginning with a, together with the string can also be written as a(a + b)* +, i.e., (ab*)* = a(a + b)* + warning Remember that the closure of any set contains the empty string. regular sets Let the input alphabet be, (similarly for any other alphabet). If a set of strings can be expressed in terms of the sets,, and a finite number of the operations +, and concatenation then the set is called regular and the expression itself is a regular expression. Furthermore, the set ƒ is defined as regular. Equivalently, here's a recursive definition of a regular set. (I) (the basic regular sets) The sets,,, ƒ are regular. (II) (building new regular sets from old) If r and r 2 are regular then so are r + r 2, r r 2 and r. ll the sets in examples 4 are regular sets.

19 page 3 of Section 5.4 example 5 The set of strings ending in is regular since it can be written as ( + )* The set of strings containing exactly one is regular since it has the regular expression * * The set of strings containing at least one is regular because it can be written as ( + )* ( + )* [also as * ( + )* ] PROLEMS FOR SETION 5.4. Let = {ab,c,d) and = {,}. Find +,, 2, and find some members of *. 2. Let the alphabet be,. escribe in ordinary English the members of the following sets. (a) * (b) * (c) * (d) ()* (e) ( + )* (f) * (g) * * * (h) (* * *)* (i) + 3. Two sets P and Q can overlap in any of the five following ways. Q P Q P Q I II III I II P I II Q I II P P=Q FIG FIG FIG FIG FIG E Suppose the alphabet is a,b,c. Which picture holds for each of the following pairs of P,Q. nd find some strings in subregions I, II, III in each case. (a) P = abc(abc)*, Q = a*(bc)* (b) P = a* + (bc)*, Q = (a + bc)* (c) P = (abc)*, Q = a* + (bc)* 4.(a) Is in a* b* c*. (b) Is 3 3 in (* )*( + *). 5. The expression a*(a + bb)* can be simplified to (a + bb)* since the factor a* in front doesn't contribute anything extra. Simplify the following if possible (by erasing part of the expression). (a) (a + bb)* + bb + b (b) (a + bb)* bb (c) ( ()* + ) * 6. Let and be arbitrary sets of strings. Simplify if possible, (a) (*)* (b) * * (c) (* + *)* (d) * + 7. Let,, be arbitrary sets of strings. True or False? (a) * = * (b) = (c) (* *)* = ( + )* (d) * = * (e) ( + ) = + (f) = (g) ( + )* = * + *

20 page 4 of Section Let the alphabet be,. Find a regular expression for the set of strings with (a) no 's (b) exactly one (c) least one (d) at most one (e) exactly two 's (f) at least two 's (g) at most two 's (h) an even number of 's (note that is an even number) (i) length at least 2 and alternating 's and 's such as,,, (j) at least one occurrence of 9. Let the alphabet be a,b,c. Show that the following are regular by finding regular expressions for them. (a) {ab n a: n } (b) {a,b,c} (c) set of strings with at least one occurrence of cba (d) {,a, (bc) n : n } (e) set of strings beginning with a and ending with b (f) set of strings with second symbol b such as abcca, bb, ab, cbba.. (a) The set (a + bb)* contains (every closure contains ). Find a regular expression for the new set obtained by removing the. You would like to write (a + bb)* - but the definition of a regular expression does not allow minus signs. So think of some other way to do it. (b) The set a + bc* does not contain. Find a regular expression for the new set obtained by including.. Why is *( + ) *( + ) * not the set of strings containing at most two 's and how close does it come. 2. I once asked on an exam for a regular expression for the set of strings in which each is immediately followed by at least one, e.g.,,,,, but not,,. I got a lot of answers including the following. Which are correct? If one is wrong, explain (to the dope) why it's wrong. (a) ( + )* (b) [ *()* ] (c) [ * * ] (d) * + (*)* (e) *(*)* (f) *()* *

21 page of Section 5.5 SETION 5.5 KLEENE'S THEOREM PRT I Kleene's theorem Regular sets are the language of FSMs in the following sense. (y FSM I mean FSMs, in particular, deterministic FSM with accepting states.) (I) For every regular set of strings there is a FSM recognizer. (II) onversely, for every FSM, the set of strings it recognizes is a regular set. In other words, a set of strings is regular if and only if it is the set of strings recognized by some FSM. footnote Kleene's theorem almost holds for the FSMs with outputs from Section 5.. The quibble is that a FSM with outputs cannot recognize the empty string, so for example, a FSM with outputs can recognize ()()* but not ()* Kleene's construction method to prove (I) lthough the theorem is about FSMs, for the proof it's easier to find NFSM recognizers with moves allowed. This is sufficient since I showed in Section 5.3 that for every NFSM with moves there is an equivalent FSM. Furthermore, for convenience the proof will use NFSMs which have just one accepting state (which won't be the starting state). This is sufficient since for every FSM with more than one accepting state there is an equivalent NFSM with just one accepting state (Problem 4 in Section 5.3). In other words I'll show that for every regular set of strings there is a NFSM with just one accepting state (that isn't the start) that recognizes that set. I'll show how to construct such a FSM for any regular set by showing two things: () Each of the basic regular sets,,, ƒ has such a FSM recognizer. (2) Once you have such FSM recognizers for the regular sets r and r you can 2 construct such FSM recognizers for the new regular sets r + r 2, r r 2 and r *. The proof of () is in Figs -4 which show FSMs (with just one accepting state that isn't the starting state) that recognize the sets,,, ƒ. FIG FIG 2 FIG 3 FIG 4 Recognizes Recognizes Recognizes Recognizes ƒ To prove (2), assume you already have FSMs which recognize r and r 2 (Fig 5) Recognizes r Recognizes r 2 FIG 5 To make a FSM which recognizes r + r 2, change the accepting states in the r and r 2 recognizers to non accepting and then hook them up in parallel with a new starting state and a new accepting state (Fig 6).

22 page 2 of Section 5.5 footnote The thing in Fig 6 labeled "r recognizer" really is an "r recognizer but with its accepting state changed to a non acc state". ut that label was too long to write. The procedure is illustrated in Fig 7 which shows the recognizers for and from Figs and 2 (with their accepting states made non accepting) linked in parallel to get a FSM recognizing + (not the most efficient FSM recognizing + but who cares). r-recognizer -recognizer r2-recognizer -recognizer FIG 6 Recognizes r +r 2 FIG 7 Recognizes + To find a FSM which recognizes r r, change the accepting state in the r 2 recognizer to non accepting and hook up the two recognizers in series (Fig 8). The procedure is illustrated in Fig 9 which shows the recognizers for + and from Fig 7 and Fig hooked in series to get a recognizer for (+). r-recognizer r2-recognizer FIG 8 Recognizes r r 2 recognizer for + -recognizer FIG 9 Recognizes (+)

23 page 3 of Section 5.5 warning on't merge the "last" state of the + recognizer with the "first" state of the recognizer, like Fig 9. recognizer for + -recognizer FIG 9 In this instance, it actually does make a correct recognizer for (+) but i doesn't work in general (see problem #4) so it isn't the way Kleene did it; i.e., it isn't like Fig 8. To convert the r recognizer to a recognizer for r (Fig ) add a new start and a new accepting state connected by a move (so that is recognized) and hook up the original machine "circularly" by adding a move from the old accepting state to the old start. The procedure is illustrated in Fig which shows the recognizer for + adjusted to get a recognizer for (+)*.... r-recognizer FIG Recognizes r

24 page 4 of Section 5.5, FIG Recognizes (+)* FIG 2 These construction methods are foolproof and are the guarantee that every regular set has a FSM recognizer even though they do not necessarily produce the simplest recognizer for a regular set. Fig 2 shows a recognizer for (+)* (the set of all binary strings) that is much simpler than the one in Fig. example Figs 3-9 show the Kleene construction of a FSM to recognize (a + b*c)* starting with the FSMs for a,b,c. a b c FIG 3 Recognizes a FIG 4 Recognizes b FIG 5 Recognizes c b b c FIG 6 Recognizes b* FIG 7 Recognizes b*c b c a FIG 8 Recognizes a + b*c

25 page 5 of Section 5.5 b c a FIG 9 Recognizes (a + b*c)* mathematical catechism (you should know the answers to these questions) question What good is the Kleene construction method when you end up with a monster FSM. answer The Kleene construction is part of the proof that every regular set has a FSM recognizer. Kleene is for showing the existance of a recognizer, not for getting the best recognizer. PROLEMS FOR SETION 5.5. Use the Kleene construction method to find a FSM recognizer for each set. (a) ()* (b) ()* (c) ()* + 2. (a) Find recognizers for the following sets using the Kleene construction method and then find simpler ones by inspection. (i) * + * (ii) * + (b) What's the point of the Kleene construction when it produces such an unsimple FSM? 3. Write a regular expression for each set and, by inspection, find a FSM recognizer without moves. n (a) {() n (b) {() 2m 2m :n, m } : n, m } (c) { n m :n, m } { k : k 3}

26 page 6 of Section Fig 8 showed Kleene's recognizer for r r 2. Here's a proposed streamlined version which merges the accepting state of r with the starting state of r 2 instead of putting in a move from one to the other. oes it work? r-recognizer r2-recognizer Proposed recognizer for r r 2 5. On the left below is a hypothetical recognizer for r and on the right is Kleene's recognizer for r* (this is a repeat of Fig ).... r-recognizer... r-recognizer Here are some other, sometimes simpler, proposed recognizers for r*. o they work? If not, why not? (a) (b) (c) (d) (e) (f)......

27 page 7 of Section The set a*b + c* is a regular set so it must have a FSM recognizer. (a) What's wrong with the proposed recognizer below a b c c (b) Find a correct FSM recognizer without moves and with as few states as possible (by inspection). 7. y inspection, find a FSM recognizer without moves and with as few states as possible for (a) a*bc* (b) (ab + c)* 8. Fig 6 showed Kleene's recognizer for r + r 2. Here's a proposed streamlined version which merges the two starting states instead of putting in a new start. Show why it doesn't work. r-recognizer r2-recognizer

28 page of Section 5.6 SETION 5.6 KLEENE'S THEOREM PRT II Part II of Kleene's theorem says that the set recognized by a FSM is regular. First note that the FSM's in Figs and 2 recognize and ƒ respectively. So to keep part II true, with no exceptions, in Section 5.5 we had to (artificially) define and ƒ to be regular sets. FIG Recognizes the set FIG 2 Recognizes the set ƒ In this section. I'll give a method for actually finding a regular expression for the set recognized by a FSM which proves part II. First some preliminaries. factoring/combining rule Let,,, be sets of strings. Remember that = set of strings of the form ab where a is in and b is in + = union = set of strings in either or = set of strings of the form a where a is a string in = set of strings of the form a where a is a string in = ƒ = ƒ Then here are some algebra rules. + = ( + ) + = ( + ) ( + )( + ) = For example, + * can combine to ( + *) why the algebra rules work I'll check on one of them. Let Then = {p,q,r}, = {a,b}, = {v} = {pa, pb, qa, qb, ra, rb} = {pv, qv, rv} + = {a, b, v} Now you can see that (+) and + are both {pa, pb, pv, qa, qb, qv, ra, rb, rv}. So ( + ) = + the P*Q solving rule Let P and Q be sets of strings. Suppose P does not contain. () The equation X = PX + Q has the unique solution X = P*Q (2) (special case of () where Q is the null set) The equation X = PX has the unique solution X = P*ƒ = ƒ

29 page 2 of Section 5.6 footnote If P contains then X = P*Q is still a solution to X = PX + Q but it may not be the only solution. For example look at the equation X = *X + In this case, P = *, which does contains, and Q =. One solution is X = P*Q = ** = *. but it isn't unique. Some other solutions are X = * + *, X = * + * and more generally X = * + *w half proof of the P*Q rule where w is any word. ut don't worry about it since this won't happen in any of the equations you have to solve; you'll always find that P does not contain. I'll show that X = P*Q is a solution of X = PX + Q, whether or not P contains. The proof that X = P*Q is the unique solution is much harder so I'm leaving it out. Saying that P*Q is a solution to the equation X = PX + Q means that if we take P*Q, multiply in front by (concatenate with) P and add (take union with) Q, you are back where you started; i.e., back to P*Q. Let's keep track to see. P*Q ontains Q strings with P strings in front (as many P strings as you like) It also contains plain Q strings (using from P*). PP*Q Not much different. Nothing new is created by putting more P strings in front. ut something might be lost, namely all the plain Q strings. If P contains then you don't lose the plain Q strings. If P doesn't contain then you do lose the Q strings. PP*Q + Q In case the Q strings were lost, put them back in. Now we've got Q strings with P strings in front and plain Q strings. QE solving the state equations of a FSM to find the regular expression for the set recognized (this proves Kleene's theorem part II) I'll illustrate the procedure with the FSM in Fig 3. FIG 3

30 page 3 of Section 5.6 Let be the set of words which end up in an accepting state starting from state Let be the set of words which end up in an accepting state starting from state Let be the set of words which end up in an accepting state starting from state Let be the set of words which end up in an accepting state starting from state I want to find the set since the FSM in Fig 3 has starting state. ut I'll use the sets,, along the way. Look at an arbitrary string in the set, i.e., a string that would end up in an accepting state starting from state. If it begins with and you start in state then the next state is and the rest of the word leads to an accepting state from. So the rest of the word is in the set and the original string is in. If it begins with and you start in state then the next state is and the rest of the word leads to an accepting state from. So the rest of the word is in the set and the original string is in. Each string in begins with either or so the strings in the set are either in or in. So (3) = + Similarly (4) = + (5) = + + (6) = + + warning on't leave out the 's in (5) and (6). They are there because and are accepting states. The in (5) reflects the fact that leads from to an accepting state since itself is accepting. See problem for what happens if you do leave out 's The equations in (3)-(6) are called the state equations for the FSM in Fig 3. We want to solve for since the starting state in Fig 3 is. To do this, use substitution, factoring and the solving rule in (). Here is one solution. I'm going to substitute for and in (3) until (3) looks like = (, stuff) +, stuff and then use the P*Q rule to solve for. I'll begin by solving (6) for using the P*Q rule with P =, Q = + : = *( + ) Then substitute in (3): (7) = + *( + ) = + * + * (Note * = * ) Substitute the value from (4) into (5): = + ( + ) + ollect terms: = nd use the P*Q rule to solve for : (8) = ()*( + + ) Substitute the value from (8) into (4). (9) = ()*( + + ) +

31 page 4 of Section 5.6 Substitute (8) and (9) into (7): = [ ()*( + + ) + ] + * [ ()*( + + ) ] + * nd collect terms: () = [ ()*(+) + + * ()*(+) ] + ()* + * ()* + * Use the P*Q rule to solve for to get the final answer = [ ()*(+) + + * ()*(+) ] [ ()* + * ()* + * ] If you do the substitutions in a different order you may get a different expression for. The expression is not unique. s a partial check you can trace some strings in to see that they do reach an accepting state. The beginning of a string in the set comes from the closure of the set ()*( + ),, * ()*( + ) { } In other words a string in begins with blocks of 's ()*( + )'s * ()*( + )'s so here's a typical beginning: () n () m ( or ) j () k ( or ) Then the typical string can continue with a word in ()* or * ()* or * The table in Fig 4 traces the route of this typical string from set (allowing for three possible string endings) and shows that it does end up in an accepting state starting from state. (This is at best a partial check; it tries to show that the strings in are recognized but it doesn't check that includes all strings recognized.) ()* in () n () m or j () k or next * ()* * warning FIG 4. on't forget that the state equation corresponding to an accepting state has a term 2. Solve for the right letter, the one that was the starting state in the FSM.

32 page 5 of Section 5.6 difference of two sets If and are sets then - is the set of things in that are not also in. Fig 5 shows some pictures of - in various circumstances = null set FIG 5 corollary of Kleene's theorem: unions, intersections, complements, differences of regular sets Let r and r 2 be regular sets of strings using some fixed alphabet. Then the following sets are also regular: r r 2, r, r r 2, r - r 2 proof that the union of regular sets is regular r r 2 is the same as r + r 2 and by definition of regular sets if r and r 2 are regular then so is r + r 2 proof that the complement of regular sets is regular y Kleene's theorem part I there is a FSM recognizing the regular set r. Find a deterministic version (can always do that by Section 5.3) so that every string follows exactly one track; the words in r lead to an accepting state and the words in rı lead to a non accepting state. hange every accepting state to non accepting and every non accepting state to accepting. The new FSM recognize. Therefore by rı Kleene's theorem part II, rı is regular. s an example, Fig 6 shows a FSM recognizing and the new machine recognizing everything (including ) except.,,,, Recognizes FIG 6 Recognizes ı

33 page 6 of Section 5.6 proof that the intersection of regular sets is regular Write the interesection in terms of complements and unions: r r 2 = r r 2 (emorgan's law of set theory) r r 2 = r r 2 = r r 2 ut as already proved about complements and unions, if r and r 2 are regular then so are r and r 2 and so is r r 2 and so is r r 2. So r r 2 is regular. proof that the difference of regular sets is regular See problem 7. summary of how to show that a set is regular You now have three ways to show that a set, r, of strings is regular.. Find a reg expression for r (then the set is regular by definition). 2. Find a FSM recognizer for r (then the set is reg by Kleene part II). 3. Show that r is the complement, union, intersection or difference of regular sets (then r is regular by the corollary above). How do you know which one to use? There's no absolute rule. You might want to use method 3 if the strings in r must have two patterns (then r is an intersection) or if the strings in r must not have a certain pattern (then r is a complement) or if the strings in r have one pattern but must avoid another (then r is a difference) or if the strings in r have a choice of patterns (then r is a union/sum). example Let = set of strings ending in and containing at least two 's = set of strings containing at least two 's but not ending in = set of strings not ending in = set of strings ending in or containing at least two 's Show that they are regular sets. solution The strings in must have two patterns. So I'll think of as an intersection. In particular let E = set of strings ending in F = set of strings containing at least two 's Then = E F. E is regular since E = (+)*. lternatively, E is regular since Fig 7 shows a FSM recognizer for E. nd F is regular since F = ( + )* ( + )* ( + )*. lternatively, F is regular since Fig 8 is a FSM recognizer for F. So is regular since the intersection of regular sets is reg.,,,, FIG 7 FIG 8

34 page 7 of Section 5.6 The strings in must have one pattern but avoid a second. With the E and F as above, = F - E. E and F are regular sets, so is also reg. The strings in must avoid a pattern. In particular, = Eı. We already know that E is regular, so is also reg. The strings in have a choice of patterns. In particular, = E + F (the union of E and F). E and F are regular, so is also reg. QE clarification regular expression can't contain a minus sign or a complement sign. The set (+)* is regular because (+)* is reg and the complement of a regular set is regular. ut the expression (+)* itself is not a regular expression for the set. Similarly, the set ()* - is a regular set because the difference of two regular sets is regular but the expression ()* - itself is not a regular expression for the set. PROLEMS FOR SETION 5.6. For the following FSMs it may be possible to find a regular expression by inspection for the set of strings recognized. ut use state equations for practice (and why not try checking your answer a little). (a) (b) (c) (d) F > >, E (e) P

35 page 8 of Section Look at the state equations = = + = + an you tell which is the starting state? which are the accepting states? 3. Solving state equations is foolproof and is the guarantee that the set recognized by a FSM is regular but sometimes you can get a regular expression for the set recognized by a FSM by inspection. Try it for these FSMs. (a) (b) F E, > >, (c) Same as (b) but make the starting state accepting. (d) (e) (the alphabet is,,2) 2 2 E, 2 E 4. y inspection, find a regular expression for the set recognized by the FSM below and describe the set in words (the alphabet is d,o,g,c,a,t). d,o,g,c,a,t d,o,g,c,a,t d o g c t a

36 page 9 of Section Let the alphabet be a,b,c,d. Show that the following are regular sets. r = set of strings with at least one occurrence of abc r = set of strings with at least two occurrences of abc 2 r = set of strings with at least three occurrences of abc 3 r = set of strings with no occurrences of abc 4 r = set of strings with exactly one occurrence of abc 5 r = set of strings with exactly two occurrences of abc 6 6. Show that the following are regular sets. (a) r = set of strings containing and containing an even number of 's (b) s = set of strings containing and not containing (c) t = set of strings not ending in 7. I already proved that complements and intersections of reg sets are reg. Now give prove that the difference of reg sets is reg by writing the difference in terms of intersections and complements. 8. Let r be a set of strings and let s be the set of reversed strings. For example if adc is in r then cda is in s. Show that if r is regular then s is regular. 9. (a) What theorem does the Kleene construction stuff in the preceding section prove. (b) What theorem does the state equation stuff in this section prove.. Let r be the set of strings containing no occurrences of. Then rı is the set of strings containing at least one occurrence of and it is regular because it has the reg expression ( + )* ( + )*. So r is regular. ut I don't see how to get a regular expression for r by inspection. Outline some steps that could be implemented to get it (don't actually do the implementing) (too tedious).. y inspection, the set of strings recognized by the FSM in the diagram below is * but we're going to look at state equations anyway for practice. The correct state equations are () = (2) = + Suppose you make a mistake and leave out the in the second equation so that your (incorrect) state equations are (3) = (4) = (a) Predict (just think!) the answer you should get if you solved the wrong state equations in (3) and (4) for. (b) Now solve the wrong equations and see what you actually do get. (c) Solve the correct state equations in () and (2)

### Formal Languages and Automata Theory - Regular Expressions and Finite Automata -

Formal Languages and Automata Theory - Regular Expressions and Finite Automata - Samarjit Chakraborty Computer Engineering and Networks Laboratory Swiss Federal Institute of Technology (ETH) Zürich March

### 6.045: Automata, Computability, and Complexity Or, Great Ideas in Theoretical Computer Science Spring, 2010. Class 4 Nancy Lynch

6.045: Automata, Computability, and Complexity Or, Great Ideas in Theoretical Computer Science Spring, 2010 Class 4 Nancy Lynch Today Two more models of computation: Nondeterministic Finite Automata (NFAs)

### C H A P T E R Regular Expressions regular expression

7 CHAPTER Regular Expressions Most programmers and other power-users of computer systems have used tools that match text patterns. You may have used a Web search engine with a pattern like travel cancun

### Reading 13 : Finite State Automata and Regular Expressions

CS/Math 24: Introduction to Discrete Mathematics Fall 25 Reading 3 : Finite State Automata and Regular Expressions Instructors: Beck Hasti, Gautam Prakriya In this reading we study a mathematical model

### CHAPTER 3 Numbers and Numeral Systems

CHAPTER 3 Numbers and Numeral Systems Numbers play an important role in almost all areas of mathematics, not least in calculus. Virtually all calculus books contain a thorough description of the natural,

### Regular Languages and Finite State Machines

Regular Languages and Finite State Machines Plan for the Day: Mathematical preliminaries - some review One application formal definition of finite automata Examples 1 Sets A set is an unordered collection

### Automata and Formal Languages

Automata and Formal Languages Winter 2009-2010 Yacov Hel-Or 1 What this course is all about This course is about mathematical models of computation We ll study different machine models (finite automata,

### Theory of Computation Prof. Kamala Krithivasan Department of Computer Science and Engineering Indian Institute of Technology, Madras

Theory of Computation Prof. Kamala Krithivasan Department of Computer Science and Engineering Indian Institute of Technology, Madras Lecture No. # 31 Recursive Sets, Recursively Innumerable Sets, Encoding

### Regular Expressions. Languages. Recall. A language is a set of strings made up of symbols from a given alphabet. Computer Science Theory 2

Regular Expressions Languages Recall. A language is a set of strings made up of symbols from a given alphabet. Computer Science Theory 2 1 String Recognition Machine Given a string and a definition of

### Regular Expressions and Automata using Haskell

Regular Expressions and Automata using Haskell Simon Thompson Computing Laboratory University of Kent at Canterbury January 2000 Contents 1 Introduction 2 2 Regular Expressions 2 3 Matching regular expressions

### 4 BOOLEAN ALGEBRA AND LOGIC SIMPLIFICATION

4 BOOLEAN ALGEBRA AND LOGIC SIMPLIFICATION BOOLEAN OPERATIONS AND EXPRESSIONS Variable, complement, and literal are terms used in Boolean algebra. A variable is a symbol used to represent a logical quantity.

### Automata and Computability. Solutions to Exercises

Automata and Computability Solutions to Exercises Fall 25 Alexis Maciel Department of Computer Science Clarkson University Copyright c 25 Alexis Maciel ii Contents Preface vii Introduction 2 Finite Automata

### Inf1A: Deterministic Finite State Machines

Lecture 2 InfA: Deterministic Finite State Machines 2. Introduction In this lecture we will focus a little more on deterministic Finite State Machines. Also, we will be mostly concerned with Finite State

### a 11 x 1 + a 12 x 2 + + a 1n x n = b 1 a 21 x 1 + a 22 x 2 + + a 2n x n = b 2.

Chapter 1 LINEAR EQUATIONS 1.1 Introduction to linear equations A linear equation in n unknowns x 1, x,, x n is an equation of the form a 1 x 1 + a x + + a n x n = b, where a 1, a,..., a n, b are given

### CS103B Handout 17 Winter 2007 February 26, 2007 Languages and Regular Expressions

CS103B Handout 17 Winter 2007 February 26, 2007 Languages and Regular Expressions Theory of Formal Languages In the English language, we distinguish between three different identities: letter, word, sentence.

### An Interesting Way to Combine Numbers

An Interesting Way to Combine Numbers Joshua Zucker and Tom Davis November 28, 2007 Abstract This exercise can be used for middle school students and older. The original problem seems almost impossibly

### CAs and Turing Machines. The Basis for Universal Computation

CAs and Turing Machines The Basis for Universal Computation What We Mean By Universal When we claim universal computation we mean that the CA is capable of calculating anything that could possibly be calculated*.

### Scanner. tokens scanner parser IR. source code. errors

Scanner source code tokens scanner parser IR errors maps characters into tokens the basic unit of syntax x = x + y; becomes = + ; character string value for a token is a lexeme

### Finite Automata. Reading: Chapter 2

Finite Automata Reading: Chapter 2 1 Finite Automaton (FA) Informally, a state diagram that comprehensively captures all possible states and transitions that a machine can take while responding to a stream

### CSE 135: Introduction to Theory of Computation Decidability and Recognizability

CSE 135: Introduction to Theory of Computation Decidability and Recognizability Sungjin Im University of California, Merced 04-28, 30-2014 High-Level Descriptions of Computation Instead of giving a Turing

### Pushdown Automata. place the input head on the leftmost input symbol. while symbol read = b and pile contains discs advance head remove disc from pile

Pushdown Automata In the last section we found that restricting the computational power of computing devices produced solvable decision problems for the class of sets accepted by finite automata. But along

Exponents and Radicals (a + b) 10 Exponents are a very important part of algebra. An exponent is just a convenient way of writing repeated multiplications of the same number. Radicals involve the use of

### The Halting Problem is Undecidable

185 Corollary G = { M, w w L(M) } is not Turing-recognizable. Proof. = ERR, where ERR is the easy to decide language: ERR = { x { 0, 1 }* x does not have a prefix that is a valid code for a Turing machine

### Independent samples t-test. Dr. Tom Pierce Radford University

Independent samples t-test Dr. Tom Pierce Radford University The logic behind drawing causal conclusions from experiments The sampling distribution of the difference between means The standard error of

### Lecture 1. Basic Concepts of Set Theory, Functions and Relations

September 7, 2005 p. 1 Lecture 1. Basic Concepts of Set Theory, Functions and Relations 0. Preliminaries...1 1. Basic Concepts of Set Theory...1 1.1. Sets and elements...1 1.2. Specification of sets...2

### (IALC, Chapters 8 and 9) Introduction to Turing s life, Turing machines, universal machines, unsolvable problems.

3130CIT: Theory of Computation Turing machines and undecidability (IALC, Chapters 8 and 9) Introduction to Turing s life, Turing machines, universal machines, unsolvable problems. An undecidable problem

### CS 3719 (Theory of Computation and Algorithms) Lecture 4

CS 3719 (Theory of Computation and Algorithms) Lecture 4 Antonina Kolokolova January 18, 2012 1 Undecidable languages 1.1 Church-Turing thesis Let s recap how it all started. In 1990, Hilbert stated a

### 3515ICT Theory of Computation Turing Machines

Griffith University 3515ICT Theory of Computation Turing Machines (Based loosely on slides by Harald Søndergaard of The University of Melbourne) 9-0 Overview Turing machines: a general model of computation

### Applications of Methods of Proof

CHAPTER 4 Applications of Methods of Proof 1. Set Operations 1.1. Set Operations. The set-theoretic operations, intersection, union, and complementation, defined in Chapter 1.1 Introduction to Sets are

### Solving the Rubik's Revenge (4x4x4) Home Pre-Solution Stuff Step 1 Step 2 Step 3 Solution Moves Lists

Solving your Rubik's Revenge (4x4x4) 07/16/2007 12:59 AM Solving the Rubik's Revenge (4x4x4) Home Pre-Solution Stuff Step 1 Step 2 Step 3 Solution Moves Lists Turn this... Into THIS! To solve the Rubik's

### Computational Models Lecture 8, Spring 2009

Slides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown Univ. p. 1 Computational Models Lecture 8, Spring 2009 Encoding of TMs Universal Turing Machines The Halting/Acceptance

### Euclidean Geometry. We start with the idea of an axiomatic system. An axiomatic system has four parts:

Euclidean Geometry Students are often so challenged by the details of Euclidean geometry that they miss the rich structure of the subject. We give an overview of a piece of this structure below. We start

### MATRIX ALGEBRA AND SYSTEMS OF EQUATIONS

MATRIX ALGEBRA AND SYSTEMS OF EQUATIONS Systems of Equations and Matrices Representation of a linear system The general system of m equations in n unknowns can be written a x + a 2 x 2 + + a n x n b a

### CMPSCI 250: Introduction to Computation. Lecture #19: Regular Expressions and Their Languages David Mix Barrington 11 April 2013

CMPSCI 250: Introduction to Computation Lecture #19: Regular Expressions and Their Languages David Mix Barrington 11 April 2013 Regular Expressions and Their Languages Alphabets, Strings and Languages

### 6.080/6.089 GITCS Feb 12, 2008. Lecture 3

6.8/6.89 GITCS Feb 2, 28 Lecturer: Scott Aaronson Lecture 3 Scribe: Adam Rogal Administrivia. Scribe notes The purpose of scribe notes is to transcribe our lectures. Although I have formal notes of my

### Regular Languages and Finite Automata

Regular Languages and Finite Automata 1 Introduction Hing Leung Department of Computer Science New Mexico State University Sep 16, 2010 In 1943, McCulloch and Pitts [4] published a pioneering work on a

### INCIDENCE-BETWEENNESS GEOMETRY

INCIDENCE-BETWEENNESS GEOMETRY MATH 410, CSUSM. SPRING 2008. PROFESSOR AITKEN This document covers the geometry that can be developed with just the axioms related to incidence and betweenness. The full

### Computability Theory

CSC 438F/2404F Notes (S. Cook and T. Pitassi) Fall, 2014 Computability Theory This section is partly inspired by the material in A Course in Mathematical Logic by Bell and Machover, Chap 6, sections 1-10.

### 6.3 Conditional Probability and Independence

222 CHAPTER 6. PROBABILITY 6.3 Conditional Probability and Independence Conditional Probability Two cubical dice each have a triangle painted on one side, a circle painted on two sides and a square painted

### December 4, 2013 MATH 171 BASIC LINEAR ALGEBRA B. KITCHENS

December 4, 2013 MATH 171 BASIC LINEAR ALGEBRA B KITCHENS The equation 1 Lines in two-dimensional space (1) 2x y = 3 describes a line in two-dimensional space The coefficients of x and y in the equation

### Boolean Algebra Part 1

Boolean Algebra Part 1 Page 1 Boolean Algebra Objectives Understand Basic Boolean Algebra Relate Boolean Algebra to Logic Networks Prove Laws using Truth Tables Understand and Use First Basic Theorems

### SYSTEMS OF EQUATIONS AND MATRICES WITH THE TI-89. by Joseph Collison

SYSTEMS OF EQUATIONS AND MATRICES WITH THE TI-89 by Joseph Collison Copyright 2000 by Joseph Collison All rights reserved Reproduction or translation of any part of this work beyond that permitted by Sections

### MATRIX ALGEBRA AND SYSTEMS OF EQUATIONS. + + x 2. x n. a 11 a 12 a 1n b 1 a 21 a 22 a 2n b 2 a 31 a 32 a 3n b 3. a m1 a m2 a mn b m

MATRIX ALGEBRA AND SYSTEMS OF EQUATIONS 1. SYSTEMS OF EQUATIONS AND MATRICES 1.1. Representation of a linear system. The general system of m equations in n unknowns can be written a 11 x 1 + a 12 x 2 +

### Continued Fractions and the Euclidean Algorithm

Continued Fractions and the Euclidean Algorithm Lecture notes prepared for MATH 326, Spring 997 Department of Mathematics and Statistics University at Albany William F Hammond Table of Contents Introduction

### L1-2. Special Matrix Operations: Permutations, Transpose, Inverse, Augmentation 12 Aug 2014

L1-2. Special Matrix Operations: Permutations, Transpose, Inverse, Augmentation 12 Aug 2014 Unfortunately, no one can be told what the Matrix is. You have to see it for yourself. -- Morpheus Primary concepts:

### Compiler Construction

Compiler Construction Regular expressions Scanning Görel Hedin Reviderad 2013 01 23.a 2013 Compiler Construction 2013 F02-1 Compiler overview source code lexical analysis tokens intermediate code generation

### Fundamentele Informatica II

Fundamentele Informatica II Answer to selected exercises 1 John C Martin: Introduction to Languages and the Theory of Computation M.M. Bonsangue (and J. Kleijn) Fall 2011 Let L be a language. It is clear

### Sections 2.1, 2.2 and 2.4

SETS Sections 2.1, 2.2 and 2.4 Chapter Summary Sets The Language of Sets Set Operations Set Identities Introduction Sets are one of the basic building blocks for the types of objects considered in discrete

### NODAL ANALYSIS. Circuits Nodal Analysis 1 M H Miller

NODAL ANALYSIS A branch of an electric circuit is a connection between two points in the circuit. In general a simple wire connection, i.e., a 'short-circuit', is not considered a branch since it is known

### Theory of Computation

Theory of Computation For Computer Science & Information Technology By www.thegateacademy.com Syllabus Syllabus for Theory of Computation Regular Expressions and Finite Automata, Context-Free Grammar s

### Row Echelon Form and Reduced Row Echelon Form

These notes closely follow the presentation of the material given in David C Lay s textbook Linear Algebra and its Applications (3rd edition) These notes are intended primarily for in-class presentation

### MATH10212 Linear Algebra. Systems of Linear Equations. Definition. An n-dimensional vector is a row or a column of n numbers (or letters): a 1.

MATH10212 Linear Algebra Textbook: D. Poole, Linear Algebra: A Modern Introduction. Thompson, 2006. ISBN 0-534-40596-7. Systems of Linear Equations Definition. An n-dimensional vector is a row or a column

### Math 313 Lecture #10 2.2: The Inverse of a Matrix

Math 1 Lecture #10 2.2: The Inverse of a Matrix Matrix algebra provides tools for creating many useful formulas just like real number algebra does. For example, a real number a is invertible if there is

### The equation for the 3-input XOR gate is derived as follows

The equation for the 3-input XOR gate is derived as follows The last four product terms in the above derivation are the four 1-minterms in the 3-input XOR truth table. For 3 or more inputs, the XOR gate

### CSC4510 AUTOMATA 2.1 Finite Automata: Examples and D efinitions Definitions

CSC45 AUTOMATA 2. Finite Automata: Examples and Definitions Finite Automata: Examples and Definitions A finite automaton is a simple type of computer. Itsoutputislimitedto yes to or no. It has very primitive

### Finite Automata and Regular Languages

CHAPTER 3 Finite Automata and Regular Languages 3. Introduction 3.. States and Automata A finite-state machine or finite automaton (the noun comes from the Greek; the singular is automaton, the Greek-derived

### Mathematics for Computer Science/Software Engineering. Notes for the course MSM1F3 Dr. R. A. Wilson

Mathematics for Computer Science/Software Engineering Notes for the course MSM1F3 Dr. R. A. Wilson October 1996 Chapter 1 Logic Lecture no. 1. We introduce the concept of a proposition, which is a statement

### . 0 1 10 2 100 11 1000 3 20 1 2 3 4 5 6 7 8 9

Introduction The purpose of this note is to find and study a method for determining and counting all the positive integer divisors of a positive integer Let N be a given positive integer We say d is a

### MODULAR ARITHMETIC. a smallest member. It is equivalent to the Principle of Mathematical Induction.

MODULAR ARITHMETIC 1 Working With Integers The usual arithmetic operations of addition, subtraction and multiplication can be performed on integers, and the result is always another integer Division, on

### The Inverse of a Square Matrix

These notes closely follow the presentation of the material given in David C Lay s textbook Linear Algebra and its Applications (3rd edition) These notes are intended primarily for in-class presentation

### OA3-10 Patterns in Addition Tables

OA3-10 Patterns in Addition Tables Pages 60 63 Standards: 3.OA.D.9 Goals: Students will identify and describe various patterns in addition tables. Prior Knowledge Required: Can add two numbers within 20

### The Language of Mathematics

CHPTER 2 The Language of Mathematics 2.1. Set Theory 2.1.1. Sets. set is a collection of objects, called elements of the set. set can be represented by listing its elements between braces: = {1, 2, 3,

### Automata on Infinite Words and Trees

Automata on Infinite Words and Trees Course notes for the course Automata on Infinite Words and Trees given by Dr. Meghyn Bienvenu at Universität Bremen in the 2009-2010 winter semester Last modified:

### Edge-Triggered D-type Flip-flop

Edge-Triggered D-type Flip-flop The transparent D-type flip-flop is written during the period of time that the write control is active. However there is a demand in many circuits for a storage device (flip-flop

### Basic Concepts of Set Theory, Functions and Relations

March 1, 2006 p. 1 Basic Concepts of Set Theory, Functions and Relations 1. Basic Concepts of Set Theory...1 1.1. Sets and elements...1 1.2. Specification of sets...2 1.3. Identity and cardinality...3

### POWER SETS AND RELATIONS

POWER SETS AND RELATIONS L. MARIZZA A. BAILEY 1. The Power Set Now that we have defined sets as best we can, we can consider a sets of sets. If we were to assume nothing, except the existence of the empty

### DDBA 8438: Introduction to Hypothesis Testing Video Podcast Transcript

DDBA 8438: Introduction to Hypothesis Testing Video Podcast Transcript JENNIFER ANN MORROW: Welcome to "Introduction to Hypothesis Testing." My name is Dr. Jennifer Ann Morrow. In today's demonstration,

### Motivation. Automata = abstract computing devices. Turing studied Turing Machines (= computers) before there were any real computers

Motivation Automata = abstract computing devices Turing studied Turing Machines (= computers) before there were any real computers We will also look at simpler devices than Turing machines (Finite State

### Foundations of Geometry 1: Points, Lines, Segments, Angles

Chapter 3 Foundations of Geometry 1: Points, Lines, Segments, Angles 3.1 An Introduction to Proof Syllogism: The abstract form is: 1. All A is B. 2. X is A 3. X is B Example: Let s think about an example.

### Chapter 3. Cartesian Products and Relations. 3.1 Cartesian Products

Chapter 3 Cartesian Products and Relations The material in this chapter is the first real encounter with abstraction. Relations are very general thing they are a special type of subset. After introducing

### Study Skills in Mathematics

Study Skills in Mathematics From the Skills Team, University of Hull Studying maths Studying maths is different from studying other subjects. A very important part of learning maths is doing problems.

### Arkansas Tech University MATH 4033: Elementary Modern Algebra Dr. Marcel B. Finan

Arkansas Tech University MATH 4033: Elementary Modern Algebra Dr. Marcel B. Finan 3 Binary Operations We are used to addition and multiplication of real numbers. These operations combine two real numbers

### A Little Set Theory (Never Hurt Anybody)

A Little Set Theory (Never Hurt Anybody) Matthew Saltzman Department of Mathematical Sciences Clemson University Draft: August 21, 2013 1 Introduction The fundamental ideas of set theory and the algebra

### CS154. Turing Machines. Turing Machine. Turing Machines versus DFAs FINITE STATE CONTROL AI N P U T INFINITE TAPE. read write move.

CS54 Turing Machines Turing Machine q 0 AI N P U T IN TAPE read write move read write move Language = {0} q This Turing machine recognizes the language {0} Turing Machines versus DFAs TM can both write

### 1. True or False? A voltage level in the range 0 to 2 volts is interpreted as a binary 1.

File: chap04, Chapter 04 1. True or False? A voltage level in the range 0 to 2 volts is interpreted as a binary 1. 2. True or False? A gate is a device that accepts a single input signal and produces one

### Solving a System of Equations

11 Solving a System of Equations 11-1 Introduction The previous chapter has shown how to solve an algebraic equation with one variable. However, sometimes there is more than one unknown that must be determined

### Fractions and Decimals

Fractions and Decimals Tom Davis tomrdavis@earthlink.net http://www.geometer.org/mathcircles December 1, 2005 1 Introduction If you divide 1 by 81, you will find that 1/81 =.012345679012345679... The first

### Year 9 set 1 Mathematics notes, to accompany the 9H book.

Part 1: Year 9 set 1 Mathematics notes, to accompany the 9H book. equations 1. (p.1), 1.6 (p. 44), 4.6 (p.196) sequences 3. (p.115) Pupils use the Elmwood Press Essential Maths book by David Raymer (9H

### Just the Factors, Ma am

1 Introduction Just the Factors, Ma am The purpose of this note is to find and study a method for determining and counting all the positive integer divisors of a positive integer Let N be a given positive

### Figure 2.1(a) Bistable element circuit.

3.1 Bistable Element Let us look at the inverter. If you provide the inverter input with a 1, the inverter will output a 0. If you do not provide the inverter with an input (that is neither a 0 nor a 1),

### 1. LINEAR EQUATIONS. A linear equation in n unknowns x 1, x 2,, x n is an equation of the form

1. LINEAR EQUATIONS A linear equation in n unknowns x 1, x 2,, x n is an equation of the form a 1 x 1 + a 2 x 2 + + a n x n = b, where a 1, a 2,..., a n, b are given real numbers. For example, with x and

### Elementary Number Theory We begin with a bit of elementary number theory, which is concerned

CONSTRUCTION OF THE FINITE FIELDS Z p S. R. DOTY Elementary Number Theory We begin with a bit of elementary number theory, which is concerned solely with questions about the set of integers Z = {0, ±1,

### WRITING PROOFS. Christopher Heil Georgia Institute of Technology

WRITING PROOFS Christopher Heil Georgia Institute of Technology A theorem is just a statement of fact A proof of the theorem is a logical explanation of why the theorem is true Many theorems have this

### Chapter 7 Uncomputability

Chapter 7 Uncomputability 190 7.1 Introduction Undecidability of concrete problems. First undecidable problem obtained by diagonalisation. Other undecidable problems obtained by means of the reduction

### SAT Math Facts & Formulas Review Quiz

Test your knowledge of SAT math facts, formulas, and vocabulary with the following quiz. Some questions are more challenging, just like a few of the questions that you ll encounter on the SAT; these questions

### Automata Theory. Şubat 2006 Tuğrul Yılmaz Ankara Üniversitesi

Automata Theory Automata theory is the study of abstract computing devices. A. M. Turing studied an abstract machine that had all the capabilities of today s computers. Turing s goal was to describe the

### Sets and set operations

CS 441 Discrete Mathematics for CS Lecture 7 Sets and set operations Milos Hauskrecht milos@cs.pitt.edu 5329 Sennott Square asic discrete structures Discrete math = study of the discrete structures used

### Elementary Algebra. Section 0.4 Factors

Section 0.4 Contents: Definitions: Multiplication Primes and Composites Rules of Composite Prime Factorization Answers Focus Exercises THE MULTIPLICATION TABLE x 1 2 3 4 5 6 7 8 9 10 11 12 1 1 2 3 4 5

### Notes on Complexity Theory Last updated: August, 2011. Lecture 1

Notes on Complexity Theory Last updated: August, 2011 Jonathan Katz Lecture 1 1 Turing Machines I assume that most students have encountered Turing machines before. (Students who have not may want to look

### Markov Algorithm. CHEN Yuanmi December 18, 2007

Markov Algorithm CHEN Yuanmi December 18, 2007 1 Abstract Markov Algorithm can be understood as a priority string rewriting system. In this short paper we give the definition of Markov algorithm and also

### 26 Integers: Multiplication, Division, and Order

26 Integers: Multiplication, Division, and Order Integer multiplication and division are extensions of whole number multiplication and division. In multiplying and dividing integers, the one new issue

### 2110711 THEORY of COMPUTATION

2110711 THEORY of COMPUTATION ATHASIT SURARERKS ELITE Athasit Surarerks ELITE Engineering Laboratory in Theoretical Enumerable System Computer Engineering, Faculty of Engineering Chulalongkorn University

### Quotient Rings and Field Extensions

Chapter 5 Quotient Rings and Field Extensions In this chapter we describe a method for producing field extension of a given field. If F is a field, then a field extension is a field K that contains F.

### Mathematical Induction

Mathematical Induction (Handout March 8, 01) The Principle of Mathematical Induction provides a means to prove infinitely many statements all at once The principle is logical rather than strictly mathematical,

### Computer Graphics Prof. Sukhendu Das Dept. of Computer Science and Engineering Indian Institute of Technology, Madras Lecture 7 Transformations in 2-D

Computer Graphics Prof. Sukhendu Das Dept. of Computer Science and Engineering Indian Institute of Technology, Madras Lecture 7 Transformations in 2-D Welcome everybody. We continue the discussion on 2D

### Pythagorean Triples. Chapter 2. a 2 + b 2 = c 2

Chapter Pythagorean Triples The Pythagorean Theorem, that beloved formula of all high school geometry students, says that the sum of the squares of the sides of a right triangle equals the square of the

### -2- Reason: This is harder. I'll give an argument in an Addendum to this handout.

LINES Slope The slope of a nonvertical line in a coordinate plane is defined as follows: Let P 1 (x 1, y 1 ) and P 2 (x 2, y 2 ) be any two points on the line. Then slope of the line = y 2 y 1 change in

### Mathematical Induction

Mathematical Induction In logic, we often want to prove that every member of an infinite set has some feature. E.g., we would like to show: N 1 : is a number 1 : has the feature Φ ( x)(n 1 x! 1 x) How