The Timpson Lyceum · Computation Theory

Lecture 4 (Computation Theory) Finite Automata

Overview

This lecture builds the foundations of finite automata. It first fixes the basic vocabulary of formal-language theory — alphabets, symbols, strings, string length, and languages — then motivates a finite-state machine with a concrete automatic-door example before giving the formal five-tuple definition of a finite automaton. It develops a precise mathematical definition of what it means for a machine to accept a string, defines a regular language as one recognized by some finite automaton, and introduces the three regular operations (union, concatenation, and star). It closes by proving that the regular languages are closed under union via an explicit product (cross-product) construction, and shows why naively chaining two machines fails to recognize a concatenation — the motivation for nondeterminism in the next lecture.

Key Concepts

Basic terminology

Alphabet — a non-empty finite set, usually written $\Sigma$ (or $\Gamma$ ). Its members are just symbols, not numbers. Examples: $\Sigma_1 = \{a, b, \dots, z\}$ , $\Sigma_2 = \{0, 1\}$ , $\{a, b\}$ . A multi-character symbol is written in angle brackets, e.g. $\langle\text{reset}\rangle$ , and treated as one symbol.
Symbol — any member of an alphabet.
String — a finite sequence of symbols, written with no separators, e.g. $w = 11101 0$ . In this setting a string of $0$ s and $1$ s is never read as a number.
String length — the number of symbols in $w$ , written $|w|$ . For $w = 011010$ , $|w| = 6$ .
Language — a set of strings (over some alphabet).
Empty string — written $\varepsilon$ , the string with no symbols. It is not the empty set $\emptyset$ ; $\varepsilon$ is the empty list, while $\emptyset$ is the empty language (a set containing no strings).

Finite automaton (formal definition)

A finite automaton is a 5-tuple $M = (Q, \Sigma, \delta, q_0, F)$ where:

$Q$ — a finite set of states.
$\Sigma$ — the alphabet (the input symbols).
$\delta : Q \times \Sigma \to Q$ — the transition function. Given the current state and the next input symbol, it returns the next state. (Reading line 3 of this definition correctly is the heart of understanding automata.)
$q_0 \in Q$ — the start state (exactly one).
$F \subseteq Q$ — the set of accept states (possibly empty, possibly more than one).

A machine is drawn as a diagram: each state is a circle, the start state has an incoming external arrow, accept states are drawn with a double circle, and each transition is a labeled arrow. The diagram, the transition table, and the explicit set of ordered pairs for $\delta$ all carry the same information — you should be able to convert freely among them. (A finite automaton resembles a directed graph but is a different object: a graph is a 2-tuple, an automaton a 5-tuple.)

Acceptance (formal definition)

Let $M = (Q, \Sigma, \delta, q_0, F)$ and let $w = w_1 w_2 \cdots w_n$ with each $w_i \in \Sigma$ . Then $M$ accepts $w$ if there exists a sequence of states $r_0, r_1, \dots, r_n \in Q$ such that:

$r_0 = q_0$ (start in the start state),
$\delta(r_i, w_{i+1}) = r_{i+1}$ for $i = 0, 1, \dots, n-1$ (each step follows the transition function), and
$r_n \in F$ (end in an accept state).

Note there is one more state than symbols ( $n+1$ states for a string of length $n$ ), since the sequence includes the state before reading any symbol.

Regular language

A language is regular if some finite automaton recognizes it. If you can build a machine accepting exactly that language, the language is regular by definition; a single regular language can be recognized by many different machines (and has a unique minimal one). The language $A = \{0^n 1^n : n \ge 0\}$ is not regular — no finite automaton can recognize it, because tracking an arbitrary count needs unboundedly many states (this requires a more powerful model, a pushdown automaton / context-free grammar).

Regular operations (for languages $A$ and $B$ )

Union: $A \cup B = \{x : x \in A \text{ or } x \in B\}$ .
Concatenation: $A \circ B = \{xy : x \in A \text{ and } y \in B\}$ — every string of $A$ followed by every string of $B$ . Order matters: $A \circ B \neq B \circ A$ in general. This produces strings (a language), unlike the Cartesian product $A \times B$ , which produces ordered pairs.
Star (Kleene star): $A^* = \{x_1 x_2 \cdots x_k : k \ge 0 \text{ and each } x_i \in A\}$ — any number (including zero) of strings from $A$ concatenated. Because $k = 0$ is allowed, $\varepsilon \in A^*$ always; if $A$ is non-empty, $A^*$ is infinite.

Closure

An operation is closed on a set if applying it to members of the set always yields a member of the set. The natural numbers are closed under addition but not subtraction ( $3 - 10 \notin \mathbb{N}$ ); the integers are closed under multiplication but not division. A major goal of the chapter is to show the regular languages are closed under union, concatenation, and star.

Worked Example

Product construction for union. To show the regular languages are closed under union: given regular $A_1, A_2$ recognized by $M_1 = (Q_1, \Sigma, \delta_1, q_1, F_1)$ and $M_2 = (Q_2, \Sigma, \delta_2, q_2, F_2)$ , build a single machine that simulates both at once. Its states are all pairs of states (one from each machine); it accepts when either component is in an accept state.

The new machine $M = (Q, \Sigma, \delta, q_0, F)$ is defined by:

\begin{aligned} Q &= Q_1 \times Q_2 \\ \delta\bigl((r_1, r_2),\, a\bigr) &= \bigl(\delta_1(r_1, a),\, \delta_2(r_2, a)\bigr) \\ q_0 &= (q_1,\, q_2) \\ F &= \{(s, t) : s \in F_1\} \;\cup\; \{(s, t) : t \in F_2\} \end{aligned}

Then $L(M) = A_1 \cup A_2$ , so $A_1 \cup A_2$ is regular.

Concrete instance. Let $M_1$ recognize "even number of $0$ s" (states $q_0, q_1$ , start/accept $q_0$ ) and $M_2$ recognize "even number of $1$ s" (states $q_2, q_3$ , start/accept $q_2$ ). The product machine starts at $(q_0, q_2)$ . Reading symbol $1$ from that start state:

\begin{aligned} \delta\bigl((q_0, q_2),\, 1\bigr) &= \bigl(\delta_1(q_0, 1),\, \delta_2(q_2, 1)\bigr) \\ &= (q_0,\, q_3) \end{aligned}

Since the first component $q_0 \in F_1$ , the pair $(q_0, q_3)$ is an accept state, so the machine accepts a string like $10011$ (even number of $0$ s, odd number of $1$ s) — exactly because $M_1$ alone would accept it.

Why concatenation is harder. To recognize strings whose first part has an even number of $0$ s and whose second part has an even number of $1$ s, the tempting fix is to jump from $M_1$ 's accept state to $M_2$ 's start state. But the machine cannot know where to split the input — at which point the "first part" ends and the "second part" begins. On $0011001$ , splitting after the fourth symbol gives an even number of $0$ s then an even number of $1$ s (should accept), yet a deterministic machine has no way to guess that split point. This dead end motivates nondeterminism.

Summary

An alphabet is a non-empty finite set; its members are symbols, a string is a finite sequence of symbols, and a language is a set of strings. $\varepsilon$ (empty string) and $\emptyset$ (empty language) are different objects.
A finite automaton is the 5-tuple $(Q, \Sigma, \delta, q_0, F)$ ; its transition function $\delta : Q \times \Sigma \to Q$ maps a (state, symbol) pair to the next state.
$M$ accepts $w$ when there is a state sequence starting at $q_0$ , following $\delta$ on each symbol, and ending in an accept state ( $F$ ).
A language is regular iff some finite automaton recognizes it; many machines can recognize the same regular language, while $\{0^n 1^n\}$ is not regular.
The three regular operations are union, concatenation ( $A \circ B = \{xy\}$ , order-sensitive), and star ( $A^*$ , any number of concatenations, always containing $\varepsilon$ ).
The regular languages are closed under union, proved by the product construction $Q = Q_1 \times Q_2$ that runs both machines simultaneously; deterministically combining machines for concatenation fails because the split point is unknown.