Finite-State Machines Fundamental Data Structures and Algorithms Peter Lee March 11, 2003

Announcements  Homework #4 is due next week!  Monday, March 17, 11:59pm  Reading:  Handout  Midterm Exam has been graded  Get your exam at recitation

Models of Computation

Models of computation  Understanding computation – 1.What problems can be solved by computers? 2.What problems cannot? 3.What problems can be solved “quickly”? 4.Are there fundamental differences among computers with respect to the kinds of problems they can solve? (Ignoring space and time.)

Models of computation  What details of these machines do we need to understand in order to understand computation?

Models of computation  What details about these computers can be ignored in answering these questions?  In other words:  What can abstracted away?  abstrahere = to drag away

Time, code, space

Computability theory 1.What problems can be solved by computers? 2.Are there well-stated mathematical problems that cannot be solved by computers?

Computability theory  The Halting Problem:  Can a program be written that, given another program and its input, determines if that program will terminate when executed?  Can the Java compiler be enhanced to check whether programs will always terminate?

Computability theory  Note:  We can prove termination (or show a counterexample) for most programs we write.  The question is whether this can be done, in an automatic way, for all programs.

Computability theory 1.Which problems can be solved by computers? 2.Are there well-stated mathematical problems that cannot be solved by computers?

Computability theory  The Halting Problem is undecidable.  Turing, Church (1936)  This means that it is not possible to write a program to solve the Halting Problem.  Proofs of such statements are made on simplified mathematical models of computation

Other questions  Performance of algorithms  Model is surrogate for “computer time”  Which operations get counted?  What are their relative costs?  Does it matter? Why do we use big-O?  Correctness of algorithms and code  How can we be sure the programs does what it is intended to do?  If it fails, what is broken?  Computer?  Program?  Compiler?  OS?

Examples of general computational models Examples of general models of computation  CPU + Memory  Random access machine  CPU + “Tape”  Turing machine (1936)  CPU + Many counters  Minsky machine (1960s)  Functions of functions  Lambda calculus  String matching systems  Post production systems  Function programs  General recursive functions General purpose computers  laptop  cell phone  palm device  calculator ?

 Abstractly Infinite tape Finite control  Concretely The Turing Machine

 Abstractly Infinite 2D array Finite control  Concretely The Random Access Machine

The general models  These general models are essentially equivalent.  Each model can solve the same problems as any other model.  This is shown by simulating one model with another.  Example: simulating the Turing machine tape with a random access memory.

The general models  Anything that is felt to be effectively computable can be described within one of the formal models.  Church’s Thesis (1930s)

Simpler models But:  There are some simpler models that cannot compute all computable functions M 1 < M 2 < … < Computable  One class of simple models: Finite State Machines Finite control

FSMs

The FSM model  A finite-state machine is a computing machine that  takes a string as input, and  outputs a yes/no answer  When an FSM outputs “yes” for a particular input string, we say that it “accepts” or “recognizes” it Input String FSM {Yes, No}

The FSM model  Inputs:  Strings built from a fixed alphabet Alphabet: {a,b,c} Strings: aabbacabcaa aba b aaac  Machine: A directed graph  Nodes: states of the machine  Edges: transitions from one state to another  Determined by the next input character 1 0 a b

The FSM model  Special states  Start state  Final or accepting state Input String FSM {Yes, No} aa bba,b

FSM Example  Input alphabet{a, b}  States{q0, q1, q2}  Start stateq0  Final states{q2}  Transitions{ (q0,a)  q1, … } aa bba,b Which strings of as and bs are accepted?

Finite State Machines (FSMs)  Key limitation: memory size is fixed  Independent of input size.  No infinite tape or random-access memory Input String FSM {Yes, No}

What is not finite state?  There are simple string languages that cannot be recognized using FSMs  Examples (w is any string)  ww  ww R  Hint: How much memory is needed to recognize ww?  Hint: How can ww R be recognized?  Other computational models  finite state < [other models] < computable

Why study FSMs  A common algorithm design technique  Tokenization (“lexical analysis”)  Programs, web pages, text, …  Control systems  Elevators, boilers, soda machines, …  Computational model  Linear time stream processing  Simple and elegant

History  Origin: Neuronal models  McCulloch and Pitts (1943)  Reworked into finite state machines  Kleene (1954)  Related to Markov chains

The soda machine – concretely

The soda machine – abstractly  Input alphabet  $0.25  Dispense  Return-coin  States  Ready-for-coins  25  50  Empty ……

FSM Example  Which strings of as and bs are accepted?  Input alphabet{a, b}  States{q0, q1, q2}  Start stateq0  Final states{q2} a a b bb

Deterministic FSMs (aka, DFAs)   Input alphabet  S State set  q0  S Initial state  F  S Final states  :S    S Transition function M = (, S, q0, F, )

Transition functions  Given a state and the next input symbol, give us the next state. :S    S This is normally extended to ’:S  *  S

Transition functions  Inductively: ’(q, ) = q ’(q, aw) = ’((q, a), w) the empty string input symbol remainder of input string

Formal languages  The language accepted by M: L(M) = {w | ’(q0,w)  F} This is the set of all strings accepted by M

Formal languages  What is the language accepted by this DFA? a a b bb

Enhancing the model  Nondeterminism  Allow the machine to be in more than one state at once  Equivalently, allow more than one transition on any given input symbol  Enable the machine to “guess” which transition is the correct one

Making the NFA model precise   Input alphabet  S State set  q0  S Initial state  F  S Final states  :S    (S) Transition function M = (, S, q0, F, )

The language of the NFA  Extend :S    P(S) to ’:S  *  P(S) ’(q, ) = {q} ’(q, aw) =  p(q, a) ’(p, w)  Language accepted by M  L(M) = {w | ’(q0,w)  F  }

The language of the NFA  Enhance :S    P(S) to ’:S  *  P(S) to ’’:P(S)  *  P(S) ’’({q1,…qn}, w) =  i ’(qi, w)

Formal languages  What is the language accepted by this NFA? a b a, b

Quiz Break

Red-green quiz AB CD x1x1 x2x2 x3x3 Consider this marble toy. 1) Model it as a FSM: marble in A is 0 input marble in B is 1 input sequence of marbles is accepted if the last marble comes out of D 2) What is the language accepted by this toy?

A Big Question  Are there languages L that can be accepted by an NFA but no DFA?

Another extension  Add  transitions  The “” represents “empty”, so a  transition means a transition without consuming any input.

Big Questions 1. Are there languages L that can be accepted by NFAs but not DFAs? 2. Are there languages L that can be accepted by NFAs but not NFAs?

Big Questions 1. Are there languages L that can be accepted by NFAs but not DFAs? No! 2. Are there languages L that can be accepted by NFAs but not NFAs? No!

Proving DFA  NFA  DFA  NFA   NFA  DFA 

Proving DFA  NFA  DFA  NFA  Obvious  NFA  DFA 

The Idea  An NFA can be in more than one state at a time  Define a DFA whose states correspond to combinations of the NFA states  In the NFA, let N = |S|  How many states will the corresponding DFA have?

Doing it  In the NFA  Suppose S = {0,1,2}  In the DFA, construct  S = {[],[0],[1],[2],[01],[02],[12],[012]}

Doing it: the subset construction  Both machines have the same input alphabet  In the NFA  Suppose S = {0,1,2}  3 states  In the DFA, construct  S = {[],[0],[1],[2],[01],[02],[12],[012]}  8 states  Modeling all possible combinations of the 3 NFA states

Doing it  In the NFA  Suppose S = {0,1,2}  In the DFA, construct  S = {[],[0],[1],[2],[01],[02],[12],[012]}  In the NFA  Suppose ({0}, a) = {0,1}  In the DFA, construct  ([0], a) = [01]

Doing it  In the NFA  Suppose S = {0,1,2}  In the DFA, construct  S = {[],[0],[1],[2],[01],[02],[12],[012]}  In the NFA  Suppose ({0}, a) = {0,1}  Suppose ({0,1}, b) = {0,2}  In the DFA, construct  ([0], a) = [01]  ([01], b) = [02]

Doing it  In the DFA, construct  Initial state [0]  In the DFA, construct  Final states [2], [02], [12], [012]

Completing the proof  Show that the two machines accept the same language Next time

Big Question, revisited  Are there languages L that can be accepted by NFAs but not DFAs? No! We sketched the proof of this by showing how, given an NFA, a DFA can be constructed that accepts the same languages

Big Questions, revisited 1. Are there languages L that can be accepted by NFAs but not DFAs? No! We sketched the proof of this by showing how, given an NFA, a DFA can be constructed that accepts the same languages 2. Are there languages L that can be accepted by NFAs but not NFAs? No! Similar proof technique…

Summary  Introduction to some big concepts  models of computation  finite state machines  deterministic and nondeterministic automata  formal languages  Next time:  what can we do with FSMs?