Finite State Machines

Emina Torlak and Kevin Zatloukal

- Finite state machines (FSMs)
- Definition and examples.
- Finite state machines with output
- Definition and examples.

Definition and examples.

- An FSM
*recognizes*(or*accepts*) a set of strings. - (1) Given a string $s$, begin at the
*start state*, denoted by an incoming arrow with no source. - (2) If $s = aw$, take the edge labeled $a$ to get to the next state.
- (3) Otherwise ($s$ is empty), stop.
- (4) Let $s$ be $w$ and repeat (2)-(4) until the machine stops.
- The FSM
*accepts*$s$ iff it stops in a*final state*, denoted by a double circle.

- Which strings are recognized by the example FSM?
- $\varepsilon$ no
- $0$ yes
- $0110$ yes
- $1011$ no
- All binary strings that end in $0$.

- Finite state machine (FSM) or deterministic finite automaton (DFA)
- A
*finite state machine*(FSM) $M = (S, \Sigma_{\textrm{in}}, f, s_0, F)$ consists of - a finite set of
*states*$S$, a finite*input alphabet*$\Sigma_{\textrm{in}}$, - a
*transition function*$f$ that maps each state in $S$ and input in $\Sigma_{\textrm{in}}$ to a state in $S$, - a
*start state*$s_0\in S$, and a set of*final states*$F\subseteq S$.

state | 0 | 1 |
---|---|---|

$s_0$ | $s_0$ | $s_1$ |

$s_1$ | $s_0$ | $s_2$ |

$s_2$ | $s_0$ | $s_3$ |

$s_3$ | $s_3$ | $s_3$ |

- What language does this FSM accept?
- The set of all binary strings that contain $111$ or end in $0$.

- Implementation of string matching.
- For example, in
`grep`

. - Algorithms for communication and cache-coherence protocols.
- Each agent runs its own FSM.
- Specifications for controllers.
- For example, device drivers.
- Specifications for reactive systems.
- Components are communicating FSMs.
- Verification.
- Is an unsafe state reachable?

- What language does this FSM recognize?
- The set of all binary strings where the numbers of 1’s and 0’s are congruent mod 2. That is, both numbers are even or both are odd.

- $M_1$: strings with an even number of 2’s
- $M_2$: strings where the sum of digits mod 3 is 0

- $M_1$ and $M_2$: strings with an even number of 2’s where digit sum mod 3 is 0

- $M_1$ or $M_2$: strings with an even number of 2’s or digit sum mod 3 is 0

Definition and examples.

- FSMs can do more than just accept or reject strings.
- So DFAs aren’t the only kind of FSM!
- Another useful kind of FSM can also return output.
- Whenever you enter specific states, the FSM produces an output.
- These FSMs (Moore machines) are used as controllers.

- Finite state machine (FSM) with output
- A
*finite state machine*(FSM) $M = (S, \Sigma_{\textrm{in}}, $ $\Sigma_{\textrm{out}}$$, f, $ $g$$, s_0)$ consists of - a finite set of
*states*$S$, a finite*input alphabet*$\Sigma_{\textrm{in}}$, - a finite
*output alphabet*$\Sigma_{\textrm{out}}$, - a
*transition function*$f$ that maps each state in $S$ and input in $\Sigma_{\textrm{in}}$ to a state in $S$, - an
*output function*$g$ that maps each state in $S$ to an output symbol in $\Sigma_{\textrm{out}}$, - and
*start state*$s_0\in S$.

- Consider a simple vending machine.
- Enter 15 cents in dimes or nickels.
- Press S (Snickers) or B (Butterfinger) for a candy bar.

Basic transitions on N (nickel), D (dime), B (Butterfinger), and S (Snickers).

Adding output to states: N (nickel), B (Butterfinger), and S (Snickers).

Add transitions to cover all symbols for each state.

- A finite state machine (FSM) consists of states and transitions.
- States include the start state and final states.
- Transitions map states and input symbols to states.
- Also known as deterministic finite automata (DFAs).
- An FSM recognizes a set of strings (language).
- These are all strings that reach a final state from the start.
- FSMs have many applications.
- Regular expression matching, cache coherence protocols.
- Verification (e.g., of OS kernels and devices).
- Controllers (FSMs with output).