Models of Computation
Jeff Erickson

December 28, 2018
http://jeffe.cs.illinois.edu/teaching/algorithms/ • http://algorithms.wtf/

© Copyright 2014–2017 Jeff Erickson. Last update December 28, 2018.

This work may be freely copied and distributed in any medium.
It may not be sold for more than the actual cost of reproduction, storage, or transmittal.
This work is available under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
For license details, see http://creativecommons.org/licenses/by-nc-sa/4.0/.
For the most recent edition, see http://jeffe.cs.illinois.edu/teaching/algorithms/.

I’m writing a book.
I’ve got the page numbers done,
so now I just have to fill in the rest.
— Stephen Wright

About These Notes
These are lecture notes that I wrote for the course “Algorithms and Models of Computation”
at the University of Illinois, Urbana-Champaign for the first time in Fall 2014, and revised in Fall2016. This course is a broad introduction to theoretical computer science, aimed at third-year
computer science and computer engineering majors, that covers both fundamental topics inalgorithms, for which I already have copious notes, and fundamental topics on formal languages
and automata, for which I wrote the notes you are reading now.
The most recent revision of these notes (or nearly so) is available online at http://jeffe.cs.
illinois.edu/teaching/algorithms/ (or at the shorter URLs http://algorithms.fyi/ and http://algorithms.wtf/) along with my algorithms notes and a near-complete archive of past homeworks
and exams from all my theoretical computer science classes. I plan to revise and reorganize
these whenever I teach this material, so you may find more recent versions on the web page ofwhatever course I am currently teaching.

About the Exercises
Each note ends with several exercises, many of which I used in homeworks, discussion sections,or exams. ? Stars indicate more challenging problems (which I have not used in homeworks,
discussion sections, or exams). Many of these exercises were contributed by my amazing teachingassistants:
Alex Steiger, Chao Xu, Charles Carlson, Connor Clark, Gail Steitz, Grant Czajkowski,
Hsien-Chih Chang, Junqing Deng, Konstantinos Koiliaris, Nick Bachmair, Spencer
Gordon, Tana Wattanawaroon, and Yipu Wang
Please do not ask me for solutions to the exercises. If you are a student, seeing the solution
will rob you of the experience of solving the problem yourself, which is the only way to learn thematerial. If you are an instructor, you shouldn’t ask your students to solve problems that you
can’t solve yourself. (I don’t always follow my own advice, so some of the problems are buggy.)

Caveat Lector!
These notes are best viewed as an unfinished first draft. You should assume the notes
contain several major errors, in addition to the usual unending supply of typos, fencepost errors,
off-by-one errors, and brain farts. Before Fall 2014, I had not taught this material in more than
two decades. Moreover, the course itself is still very new—Lenny Pitt and I developed thecourse and offered the first pilot in Spring 2014 (with Lenny presenting the formal language
material)—so even the choice of which material to emphasize, sketch, or exclude is still verymuch in flux.
I would sincerely appreciate feedback of any kind, especially bug reports.
Thanks, and enjoy!
— Jeffii

Contents
1

Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1

2 Regular Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3 Finite-State Machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4 Nondeterministic Automata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
5 Context-Free Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
6 Turing Machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7 Undecidability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
8 Universal Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
9 Nondeterministic Turing Machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

iii

Models of Computation

Lecture 1: Strings [Sp’18]

Vario, inquit [Epicurus], ordine ac positione conveniunt atomi sicut literae, quae cum sint paucae,
varie tamen collocatae innumerabilia verba conficiunt.
[Atoms, like letters, says Epicurus, come together in various orders and positions; there are few ofthem, but different combinations produce countless words.]— Gottfried Leibniz, Dissertatio de Arte Combinatoria (1666)
THOMAS GODFREY, a self-taught mathematician, great in his way, and afterward inventor of what isnow called Hadley’s Quadrant. But he knew little out of his way, and was not a pleasing companion;as, like most great mathematicians I have met with, he expected universal precision in everythingsaid, or was forever denying or distinguishing upon trifles, to the disturbance of all conversation.
He soon left us.
— Benjamin Franklin, Memoirs, Part 1 (1771)
describing one of the founding members of the Junto
If indeed, as Hilbert asserted, mathematics is a meaningless game played with meaningless marks
on paper, the only mathematical experience to which we can refer is the making of marks on paper.
— Eric Temple Bell, The Queen of the Sciences (1931)

1

Strings

Throughout this course, we will discuss dozens of algorithms and computational models thatmanipulate sequences: one-dimensional arrays, linked lists, blocks of text, walks in graphs,
sequences of executed instructions, and so on. Ultimately the input and output of any algorithm
must be representable as a finite string of symbols—the raw contents of some contiguous portionof the computer’s memory. Reasoning about computation requires reasoning about strings.
This note lists several formal definitions and formal induction proofs related to strings. These
definitions and proofs are intentionally much more detailed than normally used in practice—mostpeople’s intuition about strings is fairly accurate—but the extra precision is necessary for any
sort of formal proof. It may be helpful to think of this material as part of the “assembly language”
of theoretical computer science. We normally think about computation at a much higher levelof abstraction, but ultimately every argument must “compile” down to these (and similar)
definitions.
But the actual definitions and theorems are not the point. The point of playing with thismaterial is to get some experience working with formal/mechanical definitions and proofs,
especially inductive definitions and recursive proofs. Or should I say recursive definitions andinductive proofs? Whatever,they’re the same thing. Strings are a particularly simple andinduct
convenient playground for recurs ion; we’ll see many more examples throughout the course.
When you read this note, don’t just look at the content of the definitions and proofs; pay close
attention to their structure and the process for creating them.

1.1

Strings

Fix an arbitrary finite set Σ called the alphabet; the individual elements of Σ are called symbols
or characters. As a notational convention, I will always use lower-case letters near the start of
the English alphabet (a, b, c, . . . ) as symbol variables, and never as explicit symbols. For explicit
symbols, I will always use fixed-width upper-case letters (A, B, C, . . . ), digits (0, 1, 2, . . . ),© Copyright 2018 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms/ for the most recent revision.

1Models of Computation

Lecture 1: Strings [Sp’18]

or other symbols (, $, #, •, . . . ) that are clearly distinguishable from variables. For further
emphasis, I will almost always typeset explicit symbols in RED.
A string (or word) over Σ is a finite sequence of zero or more symbols from Σ. Formally, astring w over Σ is defined recursively as either• the empty string, denoted by the Greek letter " (epsilon), or• an ordered pair (a, x ), where a is a symbol in Σ and x is a string over Σ.
We normally write either a · x or simply ax to denote the ordered pair (a, x). Similarly, we
normally write explicit strings as sequences of symbols instead of nested ordered pairs; forexample, STRING is convenient shorthand for the formal expression (S, (T, (R, (I, (N, (G, ")))))).
As a notational convention, I will always use lower-case letters near the end of the English
alphabet (. . . , w, x, y, z) for string variables, and SHOUTY  RED  MONOSPACED  TEXT to typeset
explicit (non-empty) strings.
The set of all strings over Σ is denoted Σ∗ (pronounced “sigma star”). It is very important toremember that every element of Σ∗ is a finite string, although Σ∗ itself is an infinite set containing
strings of every possible finite length.

1.2

Two Recursive Functions

Our first several proofs about strings will involve two natural functions, one giving the length ofa string, the other gluing two strings together into a larger string. These two function behave
exactly the way you think they do, but if we actually want to prove anything about them, we firsthave to define them in a way that supports formal proofs. Because the objects on which thesefunctions act—strings–are defined recursively, the functions must also be defined recursively.
The length |w | of a string w is the number of symbols in w, defined formally as follows:¨
0
if w = ",|w| :=
1 + |x| if w = ax.

For example, the string FIFTEEN has length 7, the string SEVEN has length 5, and the string 5
has length 1. Although they are formally different objects, we do not normally distinguishbetween symbols and strings of length 1.
The concatenation of two strings x and y, denoted either x • y or simply x y, is theunique string containing the characters of x in order, followed by the characters in y inorder. For example, the string NOWHERE is the concatenation of the strings NOW and HERE;
that is, NOW • HERE = NOWHERE. (On the other hand, HERE • NOW = HERENOW.) Formally,
concatenation is defined recusively as follows:¨z
if w = ",w • z :=a · (x • z) if w = ax.

(Here I’m using a larger dot • to formally distinguish the operator that concatenates two arbitrary
strings from from the syntactic sugar · that builds a string from a single character and a string.)
When we describe the concatenation of more than two strings, we normally omit all dots
and parentheses, writing wxyz instead of (w • (x • y)) • z, for example. This simplification isjustified by the fact (which we will prove shortly) that the function • is associative.

2

Models of Computation

1.3

Lecture 1: Strings [Sp’18]

Induction on Strings

Induction is the standard technique for proving statements about recursively defined objects.
Hopefully you are already comfortable proving statements about natural numbers via induction,
but induction is actually a far more general technique. Several different variants of induction
can be used to prove statements about more general structures; here I describe the variant
that I recommend (and actually use in practice). This variant follows two primary design
considerations:• The case structure of the proof should mirror the case structure of the recursive definition. For example, if you are proving something about all strings, your proof should have
two cases: Either w = ", or w = ax for some symbol a and string x.
• The inductive hypothesis should be as strong as possible. The (strong) inductive hypothesis for statements about natural numbers is always “Assume there is no counterexample ksuch that k < n.” I recommend adopting a similar inductive hypothesis for strings: “Assume
there is no counterexample x such that |x| < |w|.” Then for the case w = a x, we have|x| = |w| − 1 < |w| by definition of |w|, so the inductive hypothesis applies to x.

Thus, string-induction proofs have the following boilerplate structure. Suppose we want to provethat every string is perfectly cromulent, whatever that means. The white boxes hide additional
proof details that, among other things, depend on the precise definition of “perfectly cromulent”.
Proof: Let w be an arbitrary string.
Assume, for every string x such that |x| < |w|, that x is perfectly cromulent.
There are two cases to consider.

• Suppose w = " .

Therefore, w is perfectly cromulent.

• Suppose w = a x for some symbol a and string x .

The induction hypothesis implies that x is perfectly cromulent.

Therefore, w is perfectly cromulent.
In both cases, we conclude that w is perfectly cromulent.



Here are three canonical examples of this proof structure. When developing proofs in thisstyle, I strongly recommend first mindlessly writing the green text (the boilerplate) with lots ofspace for each case, then filling in the red text (the actual theorem and the induction hypothesis),and only then starting to actually think.
Many students are confused (or at least bored and distracted) by the fact that we are proving
mind-bogglingly obvious facts. If you’re one of these students, try to remember that the lemmas
themselves are not the point. Pay close attention to the structure of the proofs. Notice how each
proof follows the boilerplate described above. Notice how every sentence of the proof follows
mechanically from earlier sentences, definitions, and the rules of standard logic and arithmetic.
Lemma 1.1. Adding nothing does nothing: For every string w, we have w • " = w.
3

Models of Computation

Lecture 1: Strings [Sp’18]

Proof: Let w be an arbitrary string. Assume that x • " = x for every string x such that |x| < |w|.
There are two cases to consider:• Suppose w = ".
w•" ="•"

because w = ",="by definition of concatenation,=w

because w = ".

• Suppose w = ax for some symbol a and string x.
w • " = (a · x) • "because w = ax,= a · (x • ")by definition of concatenation,=a·x

by the inductive hypothesis,=w

because w = ax.
In both cases, we conclude that w • " = w.
Lemma 1.2. Concatenation adds length: |w • x| = |w| + |x| for all strings w and x.

Proof: Let w and x be arbitrary strings. Assume that | y • x| = | y| + |x| for every string y suchthat | y| < |w|. (Notice that we are using induction only on w, not on x.) There are two cases toconsider:• Suppose w = ".
|w • x| = |" • x|

because w = "by definition of •= |x||"| = 0 by definition of | · |= |"| + |x|

because w = "= |w| + |x|• Suppose w = a y for some symbol a and string y.
|w • x| = |a y • x|

because w = a y= |a · ( y • x)|

by definition of •= 1 + | y • x|

by definition of | · |= 1 + | y| + |x|

by the inductive hypothesis= |a y| + |x|

by definition of | · |because w = a y= |w| + |x|

In both cases, we conclude that |w • x| = |w| + |x|.

Lemma 1.3. Concatenation is associative: (w • x) • y = w • (x • y) for all strings w, x, and y.
Proof: Let w, x, and y be arbitrary strings. Assume that (z • x) • y = z • (x • y) for every stringz such that |z| < |w|. (Again, we are using induction only on w.) There are two cases to consider.
4Models of Computation

Lecture 1: Strings [Sp’18]• Suppose w = ".
(w • x) • y = (" • x) • ybecause w = "=x•yby definition of •= " • (x • y)by definition of •= w • (x • y)because w = "• Suppose w = az for some symbol a and some string z.
(w • x) • y = (az • x) • ybecause w = az

= (a · (z • x)) • y

by definition of •= a · (z • (x • y))by the inductive hypothesis= a · ((z • x) • y)by definition of •= az • (x • y)by definition of •= w • (x • y)because w = az
In both cases, we conclude that (w • x) • y = w • (x • y).

1.4

More Than One Path up the Mountain

This is not the only boilerplate that one can use for induction proofs on strings. For example,
we can model our case analysis on the following observation, whose easy proof we leave as an
exercise (hint, hint): A string w ∈ Σ∗ is non-empty if and only if either• w = a for some symbol a ∈ Σ, or• w = x • y for some non-empty strings x and y.

In the latter case, Lemma 1.2 implies that |x| < |w| and | y| < |w|, so in an inductive proof, we
can apply the inductive hypothesis to either x or y (or even both).
Here is a proof of Lemma 1.3 that uses this alternative recursive structure:
Proof: Let w, x, and y be arbitrary strings. Assume that (z • x 0 ) • y 0 = z • (x 0 • y 0 ) for all strings
x 0 , y 0 , and z such that |z| < |w|. (We need a stronger induction hypothesis here than in theprevious proofs!) There are three cases to consider.
• Suppose w = ".
(w • x) • y = (" • x) • ybecause w = "=x•yby definition of •= " • (x • y)by definition of •= w • (x • y)because w = "• Suppose w is equal to some symbol a.
(w • x) • y = (a • x) • ybecause w = a= (a · x) • ybecause a • z = a · z by definition of •= a • (x • y)because a • z = a · z by definition of •= a · (x • y)by definition of •= w • (x • y)because w = a5Models of Computation

Lecture 1: Strings [Sp’18]• Suppose w = u • v for some nonempty strings u and v.
(w • x) • y = ((u • v) • x) • ybecause w = u • v= (u • (v • x)) • yby the inductive hypothesis, because |u| < |w|= u • ((v • x) • y)= u • (v • (x • y))= (u • v) • (x • y)
= w • (x • y)by the inductive hypothesis, because |u| < |w|by the inductive hypothesis, because |v| < |w|by the inductive hypothesis, because |u| < |w|
because w = u • v

In all three cases, we conclude that (w • x) • y = w • (x • y).

1.5Indices, Substrings, and Subsequences

Finally, I’ll conclude this note by formally defining several other common functions and terms
related to strings.
For any string w and any integer 1 ≤ i ≤ |w|, the expression wi denotes the ith symbol in w,
counting from left to right. More formally, w i is recursively defined as follows:¨aif w = ax and i = 1,
w i :=
x i−1 if w = ax and i > 1.
As one might reasonably expect, w i is formally undefined if i < 1 or w = ", and therefore (byinduction) if i > |w|. The integer i is called the index of w i .
We sometimes write strings as a concatenation of their constituent symbols using this subscript
notation: w = w1 w2 · · · w|w| . While completely standard, this notation is slightly misleading,because it incorrectly suggests that the string w contains at least three symbols, when in fact w
could be a single symbol or even the empty string.
In actual code, subscripts are usually expressed using the bracket notation w [i]. Brackets
were introduced as a typographical convention over a hundred years ago because subscripts andsuperscripts1 were difficult or impossible to type.2 We sometimes write strings as explicit arraysw[1 .. n], with the understanding that n = |w|. Again, this notation is potentially misleading;always remember that n might be zero; the string/array could be empty.
A substring of a string w is another string obtained from w by deleting zero or more symbols
from the beginning and from the end. Formally, a string y is a substring of w if and only ifthere are strings x and z such that w = x yz. Extending the array notation for strings, we write
w [i .. j ] to denote the substring of w starting at w i and ending at w j . More formally, we define¨"
if j < i,w[i .. j] :=w i · w[i + 1 .. j] otherwise.
1The same bracket notation is also used for bibliographic references, instead of the traditional footnote/endnote
superscripts, for exactly the same reasons.
2A typewriter is an obsolete mechanical device loosely resembling a computer keyboard. Pressing a key on a
typewriter moves a lever (called a “typebar”) that strikes a cloth ribbon full of ink against a piece of paper, leaving theimage of a single character. Many historians believe that the ordering of letters on modern keyboards (QWERTYUIOP)
evolved in the late 1800s, reaching its modern form on the 1874 Sholes & Glidden Type-WriterTM , in part to separate
many common letter pairs, to prevent typebars from jamming against each other; this is also why the keys on mostmodern keyboards are arranged in a slanted grid. (The common folk theory that the ordering was deliberately
intended to slow down typists doesn’t withstand careful scrutiny.) A more recent theory suggests that the ordering
was influenced by telegraph3 operators, who found older alphabetic arrangements confusing, in part because of
ambiguities in American Morse Code.

6

Models of Computation

Lecture 1: Strings [Sp’18]

A proper substring of w is any substring other than w itself. For example, LAUGH is a proper
substring of SLAUGHTER. Whenever y is a (proper) substring of w, we also call w a (proper)
superstring of y.
A prefix of w[1 .. n] is any substring of the form w[1 .. j]. Equivalently, a string p is a prefixof another string w if and only if there is a string x such that px = w. A proper prefix of w isany prefix except w itself. For example, DIE is a proper prefix of DIET.
Similarly, a suffix of w[1 .. n] is any substring of the form w[i .. n]. Equivalently, a string s is asuffix of a string w if and only if there is a string x such that xs = w. A proper suffix of w is
any suffix except w itself. For example, YES is a proper suffix of EYES, and HE is both a proper
prefix and a proper suffix of HEADACHE.
A subsequence of a string w is a string obtained by deleting zero or more symbols fromanywhere in w. More formally, z is a subsequence of w if and only if• z = ", or• w = a x for some symbol a and some string x such that z is a subsequence of x.
• w = a x and z = a y for some symbol a and some strings x and y, and y is a subsequenceof x.
A proper subsequence of w is any subsequence of w other than w itself. Whenever z is a (proper)
subsequence of w, we also call w a (proper) supersequence of z.
Substrings and subsequences are not the same objects; don’t confuse them! Every substringof w is also a subsequence of w, but not every subsequence is a substring. For example, METAL isa subsequence, but not a substring, of MEATBALL. To emphasize the distinction, we sometimes
redundantly refer to substrings of w as contiguous substrings, meaning all their symbols appear
together in w.

Exercises
Most of the following exercises ask for proofs of various claims about strings. Here “prove” means
give a complete, self-contained, formal proof by inductive definition-chasing, using the boilerplate
structure recommended in Section 1.3. Feel free to use Lemmas 1.1, 1.2, and 1.3 without proof,
but don’t assume any other facts about strings that you have not actually proved. (Some later
exercises rely on results proved in earlier exercises.) Do not appeal to intuition, and do not use
the words “obvious” or “clearly” or “just”. Most of these claims are in fact obvious; the real
exercise is understanding and formally expressing why they’re obvious.

3A telegraph is an obsolete electromechanical communication device consisting of an electrical circuit with aswitch at one end and an electromagnet at the other. The sending operator would press and release a key, closing andopening the circuit, originally causing the electromagnet to push a stylus onto a moving paper tape, leaving marksthat could be decoded by the receiving operator. (Operators quickly discovered that they could directly decode theclicking sounds made by the electromagnet, and so the paper tape became obsolete almost immediately.) The mostcommon scheme within the US to encode symbols, developed by Alfred Vail and Samuel Morse in 1837, used (mostly)
short (·) and long (−) marks—now called “dots” and “dashes”, or “dits” and “dahs”—separated by gaps of various
lengths. American Morse code (as it became known) was ambiguous; for example, the letter Z and the string SE wereboth encoded by the sequence · · · · (“di-di-dit, dit”). This ambiguity has been blamed for the S key’s position on thetypewriter keyboard near E and Z.
Vail and Morse were of course not the first people to propose encoding symbols as strings of bits. That honor
apparently falls to Francis Bacon, who devised a five-bit binary encoding of the alphabet (except for the letters J and U)
in 1605 as the basis for a steganographic code—a method or hiding secret message in otherwise normal text.

7Models of Computation

Lecture 1: Strings [Sp’18]

Note to instructors: Do not assign any of these problems before solving themyourself, especially on exams. It’s very easy to underestimate the difficulty of these
problems, or at least the lengths of their solutions, which for exams is a reasonable proxyfor difficulty. Also, several later exercises rely implicitly on identities like #(a, x • y) =#(a, x) + #(a, y) that are only proved in earlier exercises. It’s unfair to assign these problems
to students without telling them which earlier results they can use.

Useful Facts About Strings
1. Let w be an arbitrary string, and let n = |w|. Prove each of the following statements.
(a) w has exactly n + 1 prefixes.

(b) w has exactly n proper suffixes.
(c) w has at most n(n + 1)/2 distinct substrings. (Why “at most”?)(d) w has at most 2n − 1 distinct proper subsequences. (Why “at most”?)
2. Prove the following useful identities for all strings w, x, y, and z directly from the definitionof •, without referring to the length of any string.
(a) If x • y = x, then y = ".
(b) If x • y = y, then x = ".
(c) If x • z = y • z, then x = y.
(d) If x • y = x • z, then y = z.
3. Prove the following useful fact about substrings. An arbitrary string x is a substring ofanother arbitrary string w = u • v if and only if at least one of the following conditions
holds:• x is a substring of u.
• x is a substring of v.
• x = yz where y is a suffix of u and z is a prefix of v.
4. Let w be an arbitrary string, and let n = |w|. Prove the following statements for all indices1 ≤ i ≤ j ≤ k ≤ n.
(a) |w[i .. j]| = j − i + 1(b) w[i .. j] • w[ j + 1 .. k] = w[i .. k](c) wR [i .. j] = (w[i 0 .. j 0 ])R where i 0 + j = j 0 + i = |w| + 1.
Recursive Functions
5. For any symbol a and any string w, let #(a, w ) denote the number of occurrences of ain w. For example, #(A, BANANA) = 3 and #(X, FLIBBERTIGIBBET) = 0.
(a) Give a formal recursive definition of the function #: Σ × Σ∗ → N.
8

Models of Computation

Lecture 1: Strings [Sp’18](b) Prove that #(a, x y) = #(a, x) + #(a, y) for every symbol a and all strings x and y.
Your proof must rely on both your answer to part (a) and the formal recursive
definition of string concatenation.
(c) Prove the following identity for all alphabets Σ and all strings w ∈ Σ∗ :X
|w| =#(a, w)a∈Σ[Hint: Don’t try to use induction on Σ.]

6. The reversal w R of a string w is defined recursively as follows:("
if w = "wR :=x R • a if w = a · x(a) Prove that (wR )R = w for every string w.
(b) Prove that |wR | = |w| for every string w.

(c) Prove that (w • x)R = x R • wR for all strings w and x.

(d) Prove that #(a, wR ) = #(a, w) for every string w and every symbol a. (See Exercise 5.)

7. For any string w and any non-negative integer n, let w n denote the string obtained byconcatenating n copies of w; more formally, we define("
if n = 0
wn :=
n−1
w•w
otherwise
For example, (BLAH)5 = BLAHBLAHBLAHBLAHBLAH and " 374 = ".
(a) Prove that wm • wn = wm+n for every string w and all non-negative integers n and m.
(b) Prove that #(a, wn ) = n · #(a, w) for every string w, every symbol a, and every
non-negative integer n. (See Exercise 5.)(c) Prove that (wR )n = (wn )R for every string w and every non-negative integer n.
(d) Prove that for all strings x and y that if x • y = y • x, then x = wm and y = wn forsome string w and some non-negative integers m and n. [Hint: Careful with "!]8. The complement w c of a string w ∈ {0, 1}∗ is obtained from w by replacing every 0 in w
with a 1 and vice versa. The complement function can be defined recursively as follows:
if w = ""ccw := 1 · x if w = 0 x
0 · x c if w = 1 x(a) Prove that |w| = |wc | for every string w.
9Models of Computation

Lecture 1: Strings [Sp’18](b) Prove that (x • y)c = x c • y c for all strings x and y.
(c) Prove that #(1, w) = #(0, wc ) for every string w.

(d) Prove that (wR )c = (wc )R for every string w.

(e) Prove that (wn )c = (wc )n for every string w and every non-negative integer n.

9. For any string w ∈ {0, 1, 2}∗ , let w + denote the string obtained from w by replacing eachsymbol a in w by the symbol corresponding to (a + 1) mod 3. for example, 0102101+ =1210212. This function can be defined more formally as follows:
"
if w = "



+
1· x
if w = 0 x
w+ :=
+

2· x
if w = 1 x



+
0· x
if w = 2 x(a) Prove that |w| = |w+ | for every string w ∈ {0, 1, 2}∗ .

(b) Prove that (x • y)+ = x + • y + for all strings x, y ∈ {0, 1, 2}∗ .
(c) Prove that #(1, w+ ) = #(0, w) for every string w ∈ {0, 1, 2}∗ .

(d) Prove that (w+ )R = (wR )+ for every string w ∈ {0, 1, 2}∗ .

10. For any string w ∈ {0, 1}∗ , let swap(w) denote the string obtained from w by swapping thefirst and second symbols, the third and fourth symbols, and so on. For example:
swap(101) = 011

swap(100111) = 011011

swap(10 11 00 01 10 1) = 01 11 00 10 01 1.
The swap function can be formally defined as follows:
if w = ""swap(w) := w
if w = 0 or w = 1
 ba • swap(x) if w = ab x for some a, b ∈ {0, 1} and x ∈ {0, 1}∗(a) Prove that |swap(w)| = |w| for every string w.

(b) Prove that swap(swap(w)) = w for every string w.

(c) Prove that swap(wR ) = (swap(w))R for every string w such that |w| is even. [Hint: Your
proof must invoke four different recursive definitions: reversal wR , concatenation •,length |w|, and the swap function!]

11. For any string w ∈ {0, 1}∗ , let sort(w) denote the string obtained by sorting the charactersin w. For example, sort(010101) = 000111. The sort function can be defined recursively
as follows:
if w = ""sort(w) :=0 · sort(x) if w = 0 x
sort(x) • 1 if w = 1 x

Prove the following for all strings w, x, y ∈ {0, 1}∗ :10Models of Computation

Lecture 1: Strings [Sp’18](a) Prove that sort(w) ∈ 0∗ 1∗ for every string w ∈ {0, 1}∗ .

(b) Prove that #(0, w) = #(0, sort(w)) for every string w ∈ {0, 1}∗ .
(c) Prove that |w| = |sort(w)|, for every string w ∈ {0, 1}∗ .

(d) Prove that sort(w) = 0#(0,w) 1#(1,w) , for every string w ∈ {0, 1}∗ . (In other words,
prove that our recursive definition is correct.)(e) Prove that sort(wR ) = sort(w), for every string w ∈ {0, 1}∗ .
12. Consider the following recursively defined function:
y
if x = "if y = "xmerge(x, y) := 0 · merge(w, y) if x = 0w


0 · merge(x, z) if y = 0z
1 · merge(w, y) if x = 1w and y = 1z
For example:

merge(10, 10) = 1010

merge(10, 010) = 01010

merge(010, 0001100) = 0000101100(a) Prove that merge(x, y) ∈ 0∗ 1∗ for all strings x, y ∈ 0∗ 1∗ . (The regular expression0∗ 1∗ is shorthand for the language {0a 1 b | a, b ≥ 0}.)(b) Prove that sort(x • y) = merge(sort(x), sort( y)) for all strings x, y ∈ {0, 1}∗ . (Thesort function is defined in the previous exercise.)
13. Consider the following pair of mutually recursive functions on strings:(("
if w = ""if w = "evens(w) :=odds(w) :=odds(x) if w = a x
a · evens(x) if w = ax

For example, evens(MISSISSIPPI) = ISSIP and odds(MISSISSIPPI) = MSISPI.
(a) Prove the following identity for all strings w and x:(
evens(w) • evens(x) if |w| is even,evens(w • x) =evens(w) • odds(x) if |w| is odd.

(b) State and prove a similar identity for odds(w • x).

(c) Prove that every string w is a shuffle of evens(w) and odds(w).
14. Consider the following recursively defined function:¨"
if w = "stutter(w) :=aa • stutter(x) if w = ax
For example, stutter(MISSISSIPPI) = MMIISSSSIISSSSIIPPPPII.
11

Models of Computation

Lecture 1: Strings [Sp’18](a) Prove that |stutter(w)| = 2|w| for every string w.

(b) Prove that evens(stutter(w)) = w for every string w.
(c) Prove that odds(stutter(w)) = w for every string w.
(d) Prove that stutter(w) is a shuffle of w and w, for every string w.
(e) Prove that w is a palindrome if and only if stutter(w) is a palindrome, for every
string w.
15. Consider the following recursive function:¨
z
if w = "faro(w, z) :=a · faro(z, x) if w = ax

For example, faro(0011, 0101) = 00011011. (A "faro shuffle" splits a deck of cards into
two equal piles and then perfectly interleaves them.)(a) Prove that |faro(x, y)| = |x| + | y| for all strings x and y.

(b) Prove that faro(w, w) = stutter(w) for every string w.

(c) Prove that faro(odds(w), evens(w)) = w for every string w.
16. For any string w, let declutter(w) denote the string obtained from w by deleting any symbolthat equals its immediate successor. For example, declutter(MISSISSIPPI) = MISISIPI,
and declutter(ABBCCCAAAACCCBBA) = ABCACBA.
(a) Given a recursive definition for the function declutter.
(b) Using your recursive definition, prove that declutter(stutter(w)) = declutter(w) for
every string w.
(c) Using your recursive definition, prove that declutter(wR ) = (declutter(w))R for every
string w.
(d) Using your recursive definition, prove that w is a palindrome if and only if declutter(w)is a palindrome, for every string w.
17. Consider the following recursively defined function¨"
if w = "hanoi(w) =hanoi(x) • a • hanoi(x) if w = ax
Prove that |hanoi(w)| = 2|w| − 1 for every string w.
18. Consider the following recursively defined function¨"
if w = "slog(w) =a · slog(evens(w)) if w = axProve that |slog(w)| = log2 (|w| + 1) for every string w.
12Models of Computation

Lecture 1: Strings [Sp’18]

19. Consider the following recursively defined function¨
w
if |w| ≤ 1
bitrev(w) =bitrev(odds(w)) • bitrev(evens(w)) otherwise(a) Prove that |bitrev(w)| = |w| for every string w.

? (b)Prove that bitrev(bitrev(w)) = w for every string w such that |w| is a power of 2.

20. The binary value of any string w ∈ {0, 1}∗ is the integer whose binary representation(possibly with leading 0s) is w. The value function can be defined recursively as follows:
if w = "0value(w) := 2 · value(x)if w = x • 02 · value(x) + 1 if w = x • 1(a) Prove that value(w) + value(wc ) = 2|w| − 1 for every string w ∈ {0, 1}∗ .

(b) Prove that value(x • y) = value(x) · 2| y| + value( y) for all strings x, y ∈ {0, 1}∗ .

? (c)Prove that value(x) is divisible by 3 if and only if value(x R ) is divisible by 3.

Recursively Defined Sets
20. Recursively define a set L of strings over the alphabet {0, 1} as follows:• The empty string " is in L.

• For any two strings x and y in L, the string 0 x 1 y 0 is also in L.
• These are the only strings in L.
(a) Prove that the string 000010101010010100 is in L.
(b) Prove by induction that every string in L has exactly twice as many 0s as 1s. (You may
assume the identity #(a, x y) = #(a, x) + #(a, y) for any symbol a and any strings x
and y; see Exercise 5(b).)(c) Give an example of a string with exactly twice as many 0s as 1s that is not in L.
21. Recursively define a set L of strings over the alphabet {0, 1} as follows:• The empty string " is in L.

• For any two strings x and y in L, the string 0 x 1 y is also in L.
• For any two strings x and y in L, the string 1 x 0 y is also in L.
• These are the only strings in L.
(a) Prove that the string 01000110111001 is in L.
(b) Prove by induction that every string in L has exactly the same number of 0s and 1s.
(You may assume the identity #(a, x y) = #(a, x) + #(a, y) for any symbol a and any
strings x and y; see Exercise 5(b).)
13Models of Computation

Lecture 1: Strings [Sp’18](c) Prove by induction that L contains every string with the same number of 0s and 1s.

22. Recursively define a set L of strings over the alphabet {0, 1} as follows:• The empty string " is in L.

• For any strings x in L, the strings 0 x 1 and 1 x 0 are also in L.
• For any two strings x and y in L, the string x • y is also in L.
• These are the only strings in L.
(a) Prove that the string 01000110111001 is in L.
(b) Prove by induction that every string in L has exactly the same number of 0s and 1s.
(You may assume the identity #(a, x y) = #(a, x) + #(a, y) for any symbol a and any
strings x and y; see Exercise 5(b).)(c) Prove by induction that every string with the same number of 0s and 1s is in L.

23. Recursively define a set L of strings over the alphabet {0, 1, 2} as follows:• The empty string " is in L.

• For any string x in L, the string 0 x is also in L.
• For any strings x and y in L, the strings 1 x 2 y and 2 x 1 y are also in L.
• These are the only strings in L.
(a) Prove that the string 001201110220121220 is in L.
(b) For any string w ∈ {0, 1, 2}∗ , let ModThree(w ) denote the sum of the digits of w
modulo 3. This function can be defined recursively as follows:
0
if w = "ModThree(x)if w = 0 x
ModThree(w) =(ModThree(x) + 1) mod 3 if w = 1 x(ModThree(x) + 2) mod 3 if w = 2 x
For example, ModThree(2211) = 0 and ModThree(001201110220121220) = 0.
Prove that ModThree(w) = 0 for every string in w ∈ L.

(c) Find a string w ∈ {0, 1, 2}∗ such that ModThree(w) = 0 but w 6∈ L. Prove that youranswer is correct.
(d) Prove that #(1, w) = #(2, w) for every string w ∈ L.

(e) Find a string w ∈ {0, 1, 2}∗ such that #(1, w) = #(2, w) but w 6∈ L. Prove that youranswer is correct.
(f) Prove that L = w ∈ {0, 1, 2}∗ ModThree(w) = 0 and #(1, w) = #(2, w) .

24. A palindrome is a string that is equal to its reversal.
14Models of Computation

Lecture 1: Strings [Sp’18](a) Give a recursive definition of a palindrome over the alphabet Σ.
(b) Prove that any string p meets your recursive definition of a palindrome if and only if
p = pR .
(c) Using your recursive definition, prove that the strings w • wR and w • a • wR are
palindromes, for every string w and symbol a.
(d) Using your recursive definition, prove that p n is a palindrome for every palindrome pand every natural number n. (See Exercise 7.)(e) Using your recursive definition, prove that for every palindrome p, there is at mostone symbol a such that #(a, p) is odd. (See Exercise 5.)

25. A string w ∈ Σ∗ is called a shuffle of two strings x, y ∈ Σ∗ if at least one of the following
recursive conditions is satisfied:• w = x = y = ".
• w = aw0 and x = a x 0 and w0 is a shuffle of x 0 and y, for some a ∈ Σ and some
w0 , x 0 ∈ Σ∗ .

• w = aw0 and y = a y 0 and w0 is a shuffle of x and y 0 , for some a ∈ Σ and some
w0 , y 0 ∈ Σ∗ .

For example, the string BANANANANASA is a shuffle of the strings BANANA and ANANAS.
(a) Prove that if w is a shuffle of x and y, then |w| = |x| + | y|.

(b) Prove that w is a shuffle of x and y if and only if wR is a shuffle of x R and y R .

26. For any positive integer n, the Fibonacci string Fn is defined recursively as follows:
if n = 1,
0
Fn = 1
if n = 2,F•Fotherwise.
n−2

n−1

For example, F6 = 10101101 and F7 = 0110110101101.
(a) Prove that for every integer n ≥ 2, the string Fn can also be obtained from Fn−1 byreplacing every occurrence of 0 with 1 and replacing every occurrence of 1 with 01.
More formally, prove that Fn = Finc(Fn−1 ), where
if w = ""
Finc(w) = 1 · Finc(x)if w = 0 x01 • Finc(x) if w = 1 x[Hint: First prove that Finc(x • y) = Finc(x) • Finc( y).](b) Prove that the Fibonacci string Fn begins with 1 if and only if n is even.
(c) Prove that 00 is not a substring of any Fibonacci string Fn .
(d) Prove that 111 is not a substring of any Fibonacci string Fn .
15

Models of Computation

Lecture 1: Strings [Sp’18]? (e)Prove that 01010 is not a substring of any Fibonacci string Fn .

? (f)Find another string w that is not a substring of any Fibonacci string Fn , such that 00
and 111 and 01010 are not substrings of w.

Æ(g) Find a set of strings F with the following properties:• No string in F is a substring of any Fibonacci string Fn .
• No string in F is a proper substring of any other string in F .
• For all strings x ∈ {0, 1}∗ , if x has no substrings in F , then x is a substring ofsome Fibonacci string Fn .

Æ

? 27.

(h) Prove that the reversal of each Fibonacci string is a substring of another Fibonacci
string. More formally, prove that for every integer n ≥ 0, the string FnR is a substringof Fm for some integer m ≥ n.

Prove that the following three properties of strings are in fact identical.
• A string w ∈ {0, 1}∗ is balanced if it satisfies one of the following conditions:– w = ",
– w = 0 x 1 for some balanced string x, or– w = x y for some balanced strings x and y.

• A string w ∈ {0, 1}∗ is erasable if it satisfies one of the following conditions:– w = ", or– w = x 01 y for some strings x and y such that x y is erasable. (The strings x andy are not necessarily erasable.)• A string w ∈ {0, 1}∗ is conservative if it satisfies both of the following conditions:– w has an equal number of 0s and 1s, and– no prefix of w has more 0s than 1s.

(a) Prove that every balanced string is erasable.
(b) Prove that every erasable string is conservative.
(c) Prove that every conservative string is balanced.
[Hint: To develop intuition, it may be helpful to think of 0s as left brackets and 1s asright brackets, but don’t invoke this intuition in your proofs.]? 28.

A string w ∈ {0, 1}∗ is equitable if it has an equal number of 0s and 1s.

(a) Prove that a string w is equitable if and only if it satisfies one of the following
conditions:• w = ",
• w = 0 x 1 for some equitable string x,• w = 1 x 0 for some equitable string x, or• w = x y for some equitable strings x and y.
16Models of Computation

Lecture 1: Strings [Sp’18](b) Prove that a string w is equitable if and only if it satisfies one of the following
conditions:• w = ",
• w = x 01 y for some strings x and y such that x y is equitable, or• w = x 10 y for some strings x and y such that x y is equitable.
In the last two cases, the individual strings x and y are not necessarily equitable.
(c) Prove that a string w is equitable if and only if it satisfies one of the following
conditions:• w = ",
• w = x y for some balanced string x and some equitable string y, or• w = x R y for some for some balanced string x and some equitable string y.
(See the previous exercise for the definition of “balanced”.)© Copyright 2018 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms/ for the most recent revision.

17

Models of Computation

Lecture 2: Regular Languages [Sp’18]

But the Lord came down to see the city and the tower the people were building. The Lordsaid, “If as one people speaking the same language they have begun to do this, then nothing
they plan to do will be impossible for them. Come, let us go down and confuse their language
so they will not understand each other.”— Genesis 11:6–7 (New International Version)
Soyez réglé dans votre vie et ordinaire comme un bourgeois,
afin d’être violent et original dans vos œuvres.
[Be regular and orderly in your life like a bourgeois,
so that you may be violent and original in your work.]— Gustave Flaubert, in a letter to Gertrude Tennant (December 25, 1876)
Some people, when confronted with a problem, think "I know, I’ll use regular expressions."
Now they have two problems.
— Jamie Zawinski, alt.religion.emacs (August 12, 1997)
As far as I am aware this pronunciation is incorrect in all known languages.
— Kenneth Kleene, describing his father Stephen’s pronunciation of his last name

2 Regular Languages
2.1

Languages

A formal language (or just a language) is a set of strings over some finite alphabet Σ, orequivalently, an arbitrary subset of Σ∗ . For example, each of the following sets is a language:• The empty set ∅.1• The set {"}.

• The set {0, 1}∗ .

• The set {THE, OXFORD, ENGLISH, DICTIONARY}.

• The set of all subsequences of THE  OXFORD  ENGLISH  DICTIONARY.

• The set of all words in The Oxford English Dictionary.

• The set of all strings in {0, 1}∗ with an odd number of 1s.

• The set of all strings in {0, 1}∗ that represent a prime number in base 13.

• The set of all sequences of turns that solve the Rubik’s cube (starting in some fixed
configuration)• The set of all python programs that print “Hello World!”
As a notational convention, I will always use italic upper-case letters (usually L, but also A, B, C,
and so on) to represent languages.
Formal languages are not “languages” in the same sense that English, Klingon, and Python
are “languages”. Strings in a formal language do not necessarily carry any “meaning”, nor
are they necessarily assembled into larger units (“sentences” or “paragraphs” or “packages”)
according to some “grammar”.
1The empty set symbol ∅ was introduced in 1939 by André Weil, as a member of the pseudonymous mathematicalcollective Nicholai Bourbaki. The symbol derives from the Norwegian letter Ø, which pronounced like a German ö ora sound of disgust, and not from the Greek letter φ. Calling the empty set “fie” or “fee” makes the baby Jesus cry.
© Copyright 2018 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms/ for the most recent revision.

1Models of Computation

Lecture 2: Regular Languages [Sp’18]

It is very important to distinguish between three “empty” objects. Many beginning students
have trouble keeping these straight.
• ∅ is the empty language, which is a set containing zero strings. ∅ is not a string.
• {"} is a language containing exactly one string, which has length zero. {"} is not empty,
and it is not a string.
• " is the empty string, which is a sequence of length zero. " is not a language.

2.2

Building Languages

Languages can be combined and manipulated just like any other sets. Thus, if A and B are
languages over Σ, then their union A ∪ B, intersection A ∩ B, difference A \ B, and symmetricdifference A ⊕ B are also languages over Σ, as is the complement A := Σ∗ \ A. However, there are
two more useful operators that are specific to sets of strings.
The concatenation of two languages A and B, again denoted A • B or just AB, is the set of
all strings obtained by concatenating an arbitrary string in A with an arbitrary string in B:
A • B := {x y | x ∈ A and y ∈ B}.

For example, if A = {HOCUS, ABRACA} and B = {POCUS, DABRA}, thenA • B = {HOCUSPOCUS, ABRACAPOCUS, HOCUSDABRA, ABRACADABRA}.

In particular, for every language A, we have∅ • A = A• ∅ = ∅and{"} • A = A • {"} = A.

The Kleene closure or Kleene star2 of a language L, denoted L∗ , is the set of all strings obtainedby concatenating a sequence of zero or more strings from L. For example, {0, 11}∗ = {", 0, 00, 11,000, 011, 110, 0000, 0011, 0110, 1100, 1111, 00000, 00011, 011110011011, . . .}. Moreformally, L ∗ is defined recursively as the set of all strings w such that either• w = ", or• w = x y, for some strings x ∈ L and y ∈ L ∗ .

This definition immediately implies that∅∗ = {"}∗ = {"}.

For any other language L, the Kleene closure L ∗ is infinite and contains arbitrarily long (butfinite!) strings. Equivalently, L ∗ can also be defined as the smallest superset of L that contains theempty string " and is closed under concatenation (hence “closure”). The set of all strings Σ∗ is,just as the notation suggests, the Kleene closure of the alphabet Σ (where each symbol is viewed
as a string of length 1).
A useful variant of the Kleene closure operator is the Kleene plus, defined as L + := L • L ∗ .
Thus, L + is the set of all strings obtained by concatenating a sequence of one or more strings
from L.
The following identities, which we state here without (easy) proofs, are useful for designing,
simplifying, and understanding languages.
2named after logician Stephen Cole Kleene, who actually pronounced his last name “clay-knee”, not “clean” or“cleanie” or “claynuh” or “dimaggio”.

2Models of Computation

Lecture 2: Regular Languages [Sp’18]

Lemma 2.1. The following identities hold for all languages A, B, and C:(a) A ∪ B = B ∪ A.

(b) (A ∪ B) ∪ C = A ∪ (B ∪ C).
(c) ∅ • A = A • ∅ = ∅.

(d) {"} • A = A • {"} = A.

(e) (A • B) • C = A • (B • C).
(f) A • (B ∪ C) = (A • B) ∪ (A • C).

(g) (A ∪ B) • C = (A • C) ∪ (B • C).
Lemma 2.2. The following identities hold for every language L:(a) L ∗ = {"} ∪ L + = L ∗ • L ∗ = (L ∪ {"})∗ = (L \ {"})∗ = {"} ∪ L ∪ (L + • L + ).

(b) L + = L • L ∗ = L ∗ • L = L + • L ∗ = L ∗ • L + = L ∪ (L + • L + ).
(c) L + = L ∗ if and only if " ∈ L.

Lemma 2.3 (Arden’s Rule). For any languages A, B, and L such that L = A • L ∪ B, we haveA∗ • B ⊆ L. Moreover, if A does not contain the empty string, then L = A • L ∪ B if and only if
L = A∗ • B.

2.3

Regular Languages and Regular Expressions

Intuitively, a language is regular if it can be constructed from individual strings using any
combination of union, concatenation, and unbounded repetition. More formally, a language L isregular if and only if it satisfies one of the following (recursive) conditions:• L is empty;• L contains exactly one string (which could be the empty string ");• L is the union of two regular languages;• L is the concatenation of two regular languages; or• L is the Kleene closure of a regular language.
Regular languages are normally described using a compact notation called regular expressions, which omit braces around one-string sets, use + to represent union instead of ∪, andjuxtapose subexpressions to represent concatenation instead of using an explicit operator •. By
convention, in the absence of parentheses, the ∗ operator has highest precedence, followed bythe (implicit) concatenation operator, followed by +.
For example, the regular expression 10∗ is shorthand for the language {1} • {0}∗ (containing
all strings consisting of a 1 followed by zero or more 0s), and not the language {10}∗ (containing
all strings of even length that start with 1 and alternate between 1 and 0). As a larger example,
the regular expression0∗ 0 + 0∗ 1(10∗ 1 + 01∗ 0)∗ 10∗
represents the language({0}∗ • {0}) ∪ {0}∗ • {1} • ({1} • {0}∗ • {1}) ∪ ({0} • {1}∗ • {0})3∗
• {1} • {0}∗ .

Models of Computation

Lecture 2: Regular Languages [Sp’18]

Most of the time we do not distinguish between regular expressions and the languages they
represent, for the same reason that we do not normally distinguish between the arithmetic
expression “2+2” and the integer 4, or the symbol π and the area of the unit circle. However, wesometimes need to refer to regular expressions themselves as strings. In those circumstances, wewrite L(R) to denote the language represented by the regular expression R. String w matches
regular expression R if and only if w ∈ L(R).
Here are several more examples of regular expressions and the languages they represent.
• 0∗ — the set of all strings of 0s, including the empty string.
• 00000∗ — the set of all strings consisting of at least four 0s.
• (00000)∗ — the set of all strings of 0s whose length is a multiple of 5.
• (0 + 1)∗ — the set of all binary strings.
• (" + 1)(01)∗ (" + 0) — the set of all strings of alternating 0s and 1s, or equivalently, theset of all binary strings that do not contain the substrings 00 or 11.
• (0 + 1)∗ 0000(0 + 1)∗ — the set of all binary strings that contain the substring 0000.
• ((" + 0 + 00 + 000)1)∗ (" + 0 + 00 + 000) — the set of all binary strings that do not containthe substring 0000.
• ((0 + 1)(0 + 1))∗ — the set of all binary strings whose length is even.
• 1∗ (01∗ 01∗ )∗ — the set of all binary strings with an even number of 0s.
• 0 + 1(0 + 1)∗ 00 — the set of all non-negative binary numerals divisible by 4 and with noredundant leading 0s.
• 0∗ 0 + 0∗ 1(10∗ 1 + 01∗ 0)∗ 10∗ — the set of all non-negative binary numerals divisible by 3,
possibly with redundant leading 0s.
The last example should not be obvious. It is straightforward, but really tedious, to proveby induction that every string in 0∗ 0 + 0∗ 1(10∗ 1 + 01∗ 0)∗ 10∗ is the binary representation of a
non-negative multiple of 3. It is similarly straightforward, but even more tedious, to prove thatthe binary representation of every non-negative multiple of 3 matches this regular expression. In
a later note, we will see a systematic method for deriving regular expressions for some languages
that avoids (or more accurately, automates) this tedium.
Two regular expressions R and R0 are equivalent if they describe the same language. For
example, the regular expressions (0 + 1)∗ and (1 + 0)∗ are equivalent, because the union
operator is commutative. More subtly, the regular expressions (0 + 1)∗ and (0∗ 1∗ )∗ and(00 + 01 + 10 + 11)∗ (0 + 1 + ") are all equivalent; intuitively, these three expressions represent
different ways of thinking about the language {0, 1}∗ . In fact, almost every regular language canbe represented by infinitely many distinct but equivalent regular expressions, even if we ignore
ultimately trivial equivalences like L = (L∅)∗ L" + ∅.

ÆÆÆGive some examples of designing regular expressions via Arden’s rule. For example: Allstrings that don’t contain the substring 0011.

4Models of Computation

2.4

Lecture 2: Regular Languages [Sp’18]

Things What Ain’t Regular Expressions

Many computing environments and programming languages support patterns called regexen(singular regex, pluralized like ox) that are considerably more general and powerful than regularexpressions. Regexen include special symbols representing negation, character classes (forexample, upper-case letters, or digits), contiguous ranges of characters, line and word boundaries,
limited repetition (as opposed to the unlimited repetition allowed by ∗ ), back-references to earlier
subexpressions, and even local variables. Despite its obvious etymology, a regex is not necessarilya regular expression, and it does not necessarily describe a regular language!3
Another type of pattern that is often confused with regular expression are globs, which
are patterns used in most Unix shells and some scripting languages to represent sets filenames. Globs include symbols for arbitrary single characters (?), single characters from a
specified range ([a-z]), arbitrary substrings (*), and substrings from a specified finite set({foo,ba{r,z}}). Globs are significantly less powerful than regular expressions.

2.5

Regular Expression Trees

Regular expressions are convenient notational shorthand for a more explicit representation ofregular languages called regular expression trees. A regular expression tree is formally definedas one of the following:• A leaf node labeled ∅.
• A leaf node labeled with a string in Σ∗ .
• A node labeled + with two children, each of which is the root of a regular expression tree.
• A node labeled • with two children, each of which is the root of a regular expression tree.
• A node labeled ∗ with one child, which is the root of a regular expression tree.

These cases mirror the definition of regular language exactly. A leaf labeled ∅ represents theempty language; a leaf labeled with a string represents the language containing only that string;a node labeled + represents the union of the languages represented by its two children; a nodelabeled • represents the concatenation of the languages represented by its two children; and anode labeled ∗ represents the Kleene closure of the languages represented by its child.
+
•
*
0

•
0

*

•

0

1

•
*

•

+

1

•
1

•
•

*

0
1

0

*
0

•
*

0

1

A regular expression tree for 0∗ 0 + 0∗ 1(10∗ 1 + 01∗ 0)∗ 10∗

3However, regexen are not all-powerful, either; see http://stackoverflow.com/a/1732454/775369.

5Models of Computation

Lecture 2: Regular Languages [Sp’18]

The size of a regular expression is the number of nodes in its regular expression tree. The sizeof a regular expression could be either larger or smaller than its length as a raw string. On the
one hand, concatenation nodes in the tree are not represented by symbols in the string; on theother hand, parentheses in the string are not represented by nodes in the tree. For example, theregular expression 0∗ 0 + 0∗ 1(10∗ 1 + 01∗ 0)∗ 10∗ has size 29, but the corresponding raw string
0*0+0*1(10*1+01*0)*10* has length 22.
A subexpression of a regular expression R is another regular expression S whose regularexpression tree is a subtree of some regular expression tree for R. A proper subexpression of R
is any subexpression except R itself. Every subexpression of R is also a substring of R, but not
every substring is a subexpression. For example, the substring 10∗ 1 is a proper subexpressionof 0∗ 0 + 0∗ 1(10∗ 1 + 01∗ 0)∗ 10∗ . However, the substrings 0∗ 0 + 0∗ 1 and 0∗ 1 + 01∗ are notsubexpressions of 0∗ 0 + 0∗ 1(10∗ 1 + 01∗ 0)∗ 10∗ , even though they are well-formed regularexpressions.

2.6 Proofs about Regular Expressions
The standard strategy for proving properties of regular expressions, just as for any other recursively
defined structure, to argue inductively on the recursive structure of the expression, rather thanconsidering the regular expression as a raw string.
Induction proofs about regular expressions follow a standard boilerplate that mirrors therecursive definition of regular languages. Suppose we want to prove that every regular expression
is perfectly cromulent, whatever that means. The white boxes hide additional proof details that,among other things, depend on the precise definition of “perfectly cromulent”. The boilerplate
structure is longer than the boilerplate for string induction proofs, but don’t be fooled into thinking
it’s harder. The five cases in the proof mirror the five cases in the recursive definition of regular
language.
Proof: Let R be an arbitrary regular expression.
Assume that every proper subexpression of R is perfectly cromulent.
There are five cases to consider.

• Suppose R = ∅.

Therefore, R is perfectly cromulent.

• Suppose R is a single string.

Therefore, R is perfectly cromulent.

• Suppose R = S + T for some regular expressions S and T .

The induction hypothesis implies that S and T are perfectly cromulent.

Therefore, R is perfectly cromulent.

• Suppose R = S • T for some regular expressions S and T .

The induction hypothesis implies that S and T are perfectly cromulent.

6Models of Computation

Lecture 2: Regular Languages [Sp’18]

Therefore, R is perfectly cromulent.

• Suppose R = S ∗ for some regular expression. S .

The induction hypothesis implies that S is perfectly cromulent.

Therefore, R is perfectly cromulent.
In all cases, we conclude that w is perfectly cromulent.



Students uncomfortable with structural induction can instead induct on the size of the regularexpression (defined as the number of nodes in the corresponding regular expression tree). Thisvariant changes only the statement of inductive hypothesis, not the structure of the proof itself;
the rest of the boilerplate is utterly identical.
Proof: Let R be an arbitrary regular expression.
Assume that every regular expression smaller than R is perfectly cromulent.
There are five cases to consider.
..
.
In all cases, we conclude that w is perfectly cromulent.


Here is an example of the structural induction boilerplate in action. Again, this proof is longer
than a typical induction proof about strings or integers, but each individual case is still just a
short exercise in definition-chasing.
Lemma 2.4. Every regular expression that does not use the symbol ∅ represents a non-empty
language.
Proof: Let R be an arbitrary regular expression that does not use the symbol ∅. Assume thatevery proper subexpression of R that does not use the symbol ∅ represents a non-empty language.
There are five cases to consider, mirroring the definition of R.
• If R = ∅, we have a contradiction; we can ignore this case.
• If R is a single string w, then L(R) contains the string w. (In fact, L(R) = {w}.)• Suppose R = S + T for some regular expressions S and T .
S does not use the symbol ∅, because otherwise R would.
Thus, the inductive hypothesis implies that L(S) is non-empty.
Choose an arbitrary string x ∈ L(S).
Then L(R) = L(S + T ) = L(S) ∪ L(T ) also contains the string x.

• Suppose R = S • T for some regular expressions S and T .
Neither S nor T uses the symbol ∅, because otherwise R would.
Thus, the inductive hypothesis implies that both L(S) and L(T ) are non-empty.
Choose arbitrary strings x ∈ L(S) and y ∈ L(T ).
Then L(R) = L(S • T ) = L(S) • L(T ) contains the string x y.
• Suppose R = S ∗ for some regular expression S.
Then L(R) contains the empty string ".
In every case, the language L(R) is non-empty.

7Models of Computation

Lecture 2: Regular Languages [Sp’18]

Similarly, most algorithms that accept regular expressions as input actually require regularexpression trees, rather than regular expressions as raw strings. Fortunately, it is possible to parse
any regular expression of length n into an equivalent regular expression tree in O(n) time. (Thedetails of the parsing algorithm are beyond the scope of this chapter.) Thus, when we see analgorithmic problem that starts “Given a regular expression. . . ”, we can assume without loss ofgenerality that we are actually given a regular expression tree.

2.7

Proofs about Regular Languages

The same boilerplate also applies to inductive arguments about properties of regular languages.
Languages themselves are just unadorned sets; they don’t have any recursive structure that webuild an inductive proof around. In particular, proper subsets of an infinite language L are notnecessarily “smaller” than L! Rather than trying to argue directly about an arbitrary regular
language L, we choose an arbitrary regular expression that represents L, and then build our
inductive argument around the recursive structure of that regular expression.
Lemma 2.5. Every non-empty regular language is represented by a regular expression that does
not use the symbol ∅.
Proof: Let R be an arbitrary regular expression; we need to prove that either L(R) = ∅ or
L(R) = L(R0 ) for some ∅-free regular expression R0 . For every proper subexpression S of R,
assume that either L(S) = ∅ or L(S) = L(S 0 ) for some ∅-free regular expression S 0 . There are
five cases to consider, mirroring the definition of R.
• If R = ∅, then L(R) = ∅.
• If R is a single string w, then R is already ∅-free.
• Suppose R = S + T for some regular expressions S and T . There are four subcases toconsider:– If L(S) = L(T ) = ∅, then L(R) = L(S) ∪ L(T ) = ∅.

– Suppose L(S) 6= ∅ and L(T ) = ∅. The inductive hypothesis implies that there is a∅-free regular expression S 0 such that L(S 0 ) = L(S) = L(S) ∪ L(T ) = L(R).

– Suppose L(S) = ∅ and L(T ) 6= ∅. The inductive hypothesis implies that there is a∅-free regular expression T 0 such that L(T 0 ) = L(T ) = L(S) ∪ L(T ) = L(R).

– Finally, suppose L(S) 6= ∅ and L(T ) 6= ∅. The inductive hypothesis implies that thereare ∅-free regular expressions S 0 and T 0 such that L(S 0 ) = L(S) and L(T 0 ) = L(T ).
The regular expression S 0 +T 0 is ∅-free and L(S 0 +T 0 ) = L(S 0 )∪ L(T 0 ) = L(S)∪ L(T ) =L(S + T ) = L(R).

• Suppose R = S • T for some regular expressions S and T . There are two subcases toconsider.
– If either L(S) = ∅ or L(T ) = ∅ then L(R) = L(S) • L(T ) = ∅.
– Otherwise, the inductive hypothesis implies that there are ∅-free regular expressions S 0
and T 0 such that L(S 0 ) = L(S) and L(T 0 ) = L(T ). The regular expression S 0 • T 0 is∅-free and equivalent to R.
• Suppose R = S ∗ for some regular expression S. There are two subcases to consider.
8Models of Computation

Lecture 2: Regular Languages [Sp’18]– If L(S) = ∅, then L(R) = ∅∗ = {"}, so R is represented by the ∅-free regularexpression ".
– Otherwise, The inductive hypothesis implies that there is a ∅-free regular expression S 0such that L(S 0 ) = L(S). The regular expression (S 0 )∗ is ∅-free and equivalent to R.
In all cases, either L(R) = ∅ or R is equivalent to some ∅-free regular expression R0 .

2.8

Not Every Language is Regular

You may be tempted to conjecture that all languages are regular, but in fact, the following
cardinality argument almost all languages are not regular. To make the argument concrete, let’s
consider languages over the single-symbol alphabet {}.

• Every regular expression over the one-symbol alphabet {} is itself a string over theseven-symbol alphabet {, +, (, ), *, 3, Ø}. By interpreting these symbols as the digits 1
through 7, we can interpret any string over this larger alphabet as the base-8 representationof some unique integer. Thus, the set of all regular expressions over {} is at most as large
as the set of integers, and is therefore countably infinite. It follows that the set of all regular
languages over {} is also countably infinite.
• On the other hand, for any real number 0 ≤ α < 1, we can define a corresponding languageLα =  n α2n mod 1 ≥ 1/2 .

In other words, Lα contains the string  n if and only if the (n + 1)th bit in the binary
representation of α is equal to 1. For any distinct real numbers α 6= β, the binary
representations of α and β must differ in some bit, so Lα 6= Lβ . We conclude that the setof all languages over {} is at least as large as the set of real numbers between 0 and 1,
and is therefore uncountably infinite.

We will see several explicit examples of non-regular languages in later lectures. In particular, theset of all regular expressions over the alphabet {0, 1} is itself a non-regular language over thealphabet {0, 1, +, (, ), *, 3, Ø}!

Exercises
1. (a) Prove that ∅ • L = L • ∅ = ∅, for every language L.
(b) Prove that {"} • L = L • {"} = L, for every language L.

(c) Prove that (A • B) • C = A • (B • C), for all languages A, B, and C.

(d) Prove that |A• B| ≤ |A| · |B|, for all languages A and B. (The second · is multiplication!)i. Describe two languages A and B such that |A • B| < |A| · |B|.
ii. Describe two languages A and B such that |A • B| = |A| · |B|.

(e) Prove that L ∗ is finite if and only if L = ∅ or L = {"}.

(f) Prove that if A • B = B • C, then A∗ • B = B • C ∗ = A∗ • B • C ∗ , for all languages A, B,
and C.

(g) Prove that (A ∪ B)∗ = (A∗ • B ∗ )∗ , for all languages A and B.
9Models of Computation

Lecture 2: Regular Languages [Sp’18]

2. Recall that the reversal wR of a string w is defined recursively as follows:("
if w = "wR :=R
x • a if w = a · x
The reversal L R of any language L is the set of reversals of all strings in L:
L R := wR w ∈ L .
(a) Prove that (A • B)R = B R • AR for all languages A and B.

(b) Prove that (L R )R = L for every language L.
(c) Prove that (L ∗ )R = (L R )∗ for every language L.
3. Prove that each of the following regular expressions is equivalent to (0 + 1)∗ .
(a) " + 0(0 + 1)∗ + 1(1 + 0)∗(b) 0∗ + 0∗ 1(0 + 1)∗(c) ((" + 0)(" + 1))∗(d) 0∗ (10∗ )∗(e) (1∗ 0)∗ (0∗ 1)∗
4. For each of the following languages in {0, 1}∗ , describe an equivalent regular expression.
There are infinitely many correct answers for each language. (This problem will become
significantly simpler after we’ve seen finite-state machines.)(a) Strings that end with the suffix 09 = 000000000.
(b) All strings except 010.
(c) Strings that contain the substring 010.
(d) Strings that contain the subsequence 010.
(e) Strings that do not contain the substring 010.
(f) Strings that do not contain the subsequence 010.
(g) Strings that contain an even number of occurrences of the substring 010.
? (h)Strings that contain an even number of occurrences of the substring 000.

(i) Strings in which every occurrence of the substring 00 appears before every occurrenceof the substring 11.
(j) Strings w such that in every prefix of w, the number of 0s and the number of 1s differ
by at most 1.
? (k)Strings w such that in every prefix of w, the number of 0s and the number of 1s differ
by at most 2.

? (l)Strings in which the number of 0s and the number of 1s differ by a multiple of 3.

? (m)
Æ

Strings that contain an even number of 1s and an odd number of 0s.

(n) Strings that represent a number divisible by 5 in binary.
10Models of Computation

Lecture 2: Regular Languages [Sp’18]

5. For any string w, define stutter(w) as follows:¨"
if w = "stutter(w) :=aa • stutter(x) if w = ax for some symbol a and string x
Let L be an arbitrary regular language.
(a) Prove that the language stutter(L) = {stutter(w) | w ∈ L} is also regular.

? (b)Prove that the language stutter−1 (L) = {w | stutter(w) ∈ L} is also regular.

6. Recall that the reversal w R of a string w is defined recursively as follows:¨"
if w = "wR =x • a if w = ax for some symbol a and some string x
The reversal L R of a language L is defined as the set of reversals of all strings in L:
L R := wR w ∈ L(a) Prove that (L ∗ )R = (L R )∗ for every language L.

(b) Prove that the reversal of any regular language is also a regular language. (You may
assume part (a) even if you haven’t proved it yet.)
You may assume the following facts without proof:• L ∗ • L ∗ = L ∗ for every language L.
• (wR )R = w for every string w.
• (x • y)R = y R • x R for all strings x and y.
[Hint: Yes, all three proofs use induction, but induction on what? And yes, all three
proofs.]7. This problem considers two special classes of regular expressions.
• A regular expression R is plus-free if and only if it never uses the + operator.
• A regular expression R is top-plus if and only if either– R is plus-free, or– R = S + T , where S and T are top-plus.
For example, 1((0∗ 10)∗ 1)∗ 0 is plus-free and (therefore) top-plus; 01∗ 0 + 10∗ 1 + " istop-plus but not plus-free, and 0(0 + 1)∗ (1 + ") is neither top-plus nor plus-free.
Recall that two regular expressions R and S are equivalent if they describe exactly thesame language: L(R) = L(S).
(a) Prove that for any top-plus regular expressions R and S, there is a top-plus regularexpression that is equivalent to RS.
(b) Prove that for any top-plus regular expression R, there is a plus-free regular expression S such that R∗ and S ∗ are equivalent.
11Models of Computation

Lecture 2: Regular Languages [Sp’18](c) Prove that for any regular expression, there is an equivalent top-plus regular expression.
You may assume the following facts without proof, for all regular expressions A, B, and C:• A(B + C) is equivalent to AB + AC.
• (A + B)C is equivalent to AC + BC.
• (A + B)∗ is equivalent to (A∗ B ∗ )∗ .
8. (a) Describe and analyze an efficient algorithm to determine, given a regular expression R,
whether L(R) = ∅.
(b) Describe and analyze an efficient algorithm to determine, given a regular expression R,
whether L(R) = {"}. [Hint: Use part (a).](c) Describe and analyze an efficient algorithm to determine, given a regular expression R,
whether L(R) is finite. [Hint: Use parts (a) and (b).]In each problem, assume you are given R as a regular expression tree, not just a raw string.

12Models of Computation

Lecture 3: Finite-State Machines [Sp’18]
Life only avails, not the having lived. Power ceases in the instant of repose;
it resides in the moment of transition from a past to a new state,in the shooting of the gulf, in the darting to an aim.
— Ralph Waldo Emerson, “Self Reliance”, Essays, First Series (1841)
O Marvelous! what new configuration will come next?
I am bewildered with multiplicity.
— William Carlos Williams, “At Dawn” (1914)

3

Finite-State Machines

3.1

Intuition

Suppose we want to determine whether a given string w[1 .. n] of bits represents a multiple of 5
in binary. After a bit of thought, you might realize that you can read the bits in w one at a time,from left to right, keeping track of the value modulo 5 of the prefix you have read so far.
MultipleOf5(w[1 .. n]):rem ← 0for i ← 1 to nrem ← (2 · rem + w[i]) mod 5
if rem = 0
return True
else
return False

Aside from the loop index i, which we need just to read the entire input string, this algorithm
has a single local variable rem, which has only four different values: 0, 1, 2, 3, or 4.
This algorithm already runs in O(n) time, which is the best we can hope for—after all, we
have to read every bit in the input—but we can speed up the algorithm in practice. Let’s define achange or transition function δ : {0, 1, 2, 3, 4} × {0, 1} → {0, 1, 2, 3, 4} as follows:δ(q, a) = (2q + a) mod 5.
(Here I’m implicitly converting the symbols 0 and 1 to the corresponding integers 0 and 1.) Since
we already know all values of the transition function, we can store them in a precomputed table,
and then replace the computation in the main loop of MultipleOf5 with a simple array lookup.
We can also modify the return condition to check for different values modulo 5. To becompletely general, we replace the final if-then-else lines with another array lookup, using anarray A[0 .. 4] of booleans describing which final mod-5 values are “acceptable”.
After both of these modifications, our algorithm looks like one of the following, depending onwhether we want something iterative or recursive (with q = 0 in the initial call):
DoSomethingCool(w[1 .. n]):q←0
for i ← 1 to nq ← δ[q, w[i]]return A[q]DoSomethingCool(q, w):
if w = "return A[q]elsedecompose w = a · x
return DoSomethingCool(δ(q, a), x)© Copyright 2018 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms/ for the most recent revision.

1Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

If we want to use our new DoSomethingCool algorithm to implement MultipleOf5, we
simply give the arrays δ and A the following hard-coded values:δ[q, 0]
0
2
4
1
3

q
0
1
2
3
4

δ[q, 1]
1
3
0
2
4

A[q]
True
False
False
False
False

We can also visualize the behavior of DoSomethingCool by drawing a directed graph, whose
vertices represent possible values of the variable q—the possible states of the algorithm—and
whose edges are labeled with input symbols to represent transitions between states. Specifically,athe graph includes the labeled directed edge p−→q if and only if δ(p, a) = q. To indicate theproper return value, we draw the “acceptable” final states using doubled circles. Here is theresulting graph for MultipleOf5:

1
0

0

1

0

3

1

0

0

4

1

1

1

0

2

State-transition graph for MultipleOf5

If we run the MultipleOf5 algorithm on the string 00101110110 (representing the number
374 in binary), the algorithm performs the following sequence of transitions:
0

0

1

0

1

1

1

0

1

1

0

0 −→ 0 −→ 0 −→ 1 −→ 2 −→ 0 −→ 1 −→ 3 −→ 1 −→ 3 −→ 2 −→ 4

Because the final state is not the “acceptable” state 0, the algorithm correctly returns False.
We can also think of this sequence of transitions as a walk in the graph, which is completely
determined by the start state 0 and the sequence of edge labels; the algorithm returns True if
and only if this walk ends at an “acceptable” state.

3.2

Formal Definitions

The object we have just described is an example of a finite-state machine. A finite-state machineis a formal model of any system/machine/algorithm that can exist in a finite number of states
and that transitions among those states based on sequence of input symbols.
Finite-state machines are also known as deterministic finite-state automata, abbreviatedDFAs. The word “deterministic” means that the behavior of the machine is completely determinedby the input string; we’ll discuss nondeterministic automata in the next lecture. The word
“automaton” (the singular of “automata”) comes from ancient Greek αὐτόματος meaning “selfacting”, from the roots αὐτό- (“self”) and -ματος (“thinking, willing”, the root of Latin mentus).
Formally, every finite-state machine consists of five components:• An arbitrary finite set Σ, called the input alphabet.
2Models of Computation

Lecture 3: Finite-State Machines [Sp’18]• Another arbitrary finite set Q, whose elements are called states.1• An arbitrary transition function δ : Q × Σ → Q.
• A start state s ∈ Q.

• A subset A ⊆ Q of accepting states.

The behavior of a finite-state machine is governed by an input string w, which is a finite
sequence of symbols from the input alphabet Σ. The machine reads the symbols in w one at atime in order (from left to right). At all times, the machine has a current state q; initially q is
the machine’s start state s. Each time the machine reads a symbol a from the input string, its
current state transitions from q to δ(q, a). After all the characters have been read, the machine
accepts w if the current state is in A and rejects w otherwise. In other words, every finite statemachine runs the algorithm DoSomethingCool!
More formally, we extend the transition function δ : Q × Σ → Q of any finite-state machine toa function δ∗ : Q × Σ∗ → Q that transitions on strings as follows:(q
if w = ",δ∗ (q, w) :=δ∗ (δ(q, a), x) if w = ax.
Finally, a finite-state machine accepts a string w if and only if δ∗ (s, w) ∈ A, and rejects w
otherwise. (Compare this definition with the recursive formulation of DoSomethingCool!)
For example, our final MultipleOf5 algorithm is a DFA with the following components:• input alphabet: Σ = {0, 1}• state set: Q = {0, 1, 2, 3, 4}• transition function: δ(q, a) = (2q + a) mod 5• start state: s = 0• accepting states: A = {0}This machine rejects the string 00101110110, becauseδ∗ (0, 00101110110) = δ∗ (δ(0, 0), 0101110110)= δ∗ (0, 0101110110) = δ∗ (δ(0, 0), 101110110)= δ∗ (0, 101110110) = δ∗ (δ(0, 1), 01110110) = · · ·..
.
· · · = δ∗ (1, 110) = δ∗ (δ(1, 1), 10)= δ∗ (3, 10) = δ∗ (δ(3, 1), 0)= δ∗ (2, 0) = δ∗ (δ(3, 0), ")= δ∗ (4, ") = 4 6∈ A.

1It’s unclear why we use the letter Q to refer to the state set, and lower-case q to refer to a generic state, but thatis now the firmly-established notational standard. Although the formal study of finite-state automata began muchearlier, its modern formulation was established in a 1959 paper by Michael Rabin and Dana Scott, for which they won
the Turing award. Rabin and Scott called the set of states S, used lower-case s for a generic state, and called the start
state s0 . On the other hand, in the 1936 paper for which the Turing award was named, Alan Turing used q1 , q2 , . . . , qR
to refer to states (or “m-configurations”) of a generic Turing machine. Turing may have been mirroring the standard
notation Q for configuration spaces in classical mechanics, also of uncertain origin.

3

Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

We have already seen a more graphical representation of this entire sequence of transitions:
0

0

1

0

1

1

1

0

1

1

0

0 −→ 0 −→ 0 −→ 1 −→ 2 −→ 0 −→ 1 −→ 3 −→ 1 −→ 3 −→ 2 −→ 4

The arrow notation is easier to read and write for specific examples, but surprisingly, most people
actually find the more formal functional notation easier to use in formal proofs. Try them both!
We can equivalently define a DFA as a directed graph whose vertices are the states Q, whoseedges are labeled with symbols from Σ, such that every vertex has exactly one outgoing edge
with each label. In our drawings of finite state machines, the start state s is always indicatedby an incoming arrow, and the accepting states A are always indicted by doubled circles. By
induction, for any string w ∈ Σ∗ , this graph contains a unique walk that starts at s and whoseedges are labeled with the symbols in w in order. The machine accepts w if this walk ends at an
accepting state. This graphical formulation of DFAs is incredibly useful for developing intuitionand even designing DFAs. For proofs, it’s largely a matter of taste whether to write in terms ofextended transition functions or labeled graphs, but (as much as I wish otherwise) I actually findit easier to write correct proofs using the functional formulation.

3.3

Another Example

The following drawing shows a finite-state machine with input alphabet Σ = {0, 1}, state set
Q = {s, t}, start state s, a single accepting state t, and the transition function
δ(s, 0) = s,δ(s, 1) = t,

1

s

0

δ(t, 0) = t,t

1

δ(t, 1) = s.

0

A simple finite-state machine.

For example, the two-state machine M at the top of this page accepts the string 00101110100
after the following sequence of transitions:
0

0

1

0

1

1

1

0

1

0

0

s −→ s −→ s −→ t −→ t −→ s −→ t −→ s −→ s −→ t −→ t −→ t.

The same machine M rejects the string 11101101 after the following sequence of transitions:
1

1

1

0

1

1

0

1

s −→ t −→ s −→ t −→ t −→ s −→ t −→ t −→ s.

Finally, M rejects the empty string, because the start state s is not an accepting state.
From these examples and others, it is easy to conjecture that the language of M is the set of
all strings of 0s and 1s with an odd number of 1s. So let’s prove it!
Proof (tedious case analysis): Let #(a, w) denote the number of times symbol a appears instring w. We will prove the following stronger claims by induction, for any string w.
¨¨
s if #(1, w) is event if #(1, w) is even∗∗
δ (s, w) =and
δ (t, w) =t if #(1, w) is odd
s if #(1, w) is odd
Let’s begin. Let w be an arbitrary string. Assume that for any string x that is shorter than w,
we have δ∗ (s, x) = s and δ∗ (t, x) = t if x has an even number of 1s, and δ∗ (s, x) = t andδ∗ (t, x) = s if x has an odd number of 1s. There are five cases to consider.
4Models of Computation

Lecture 3: Finite-State Machines [Sp’18]• If w = ", then w contains an even number of 1s and δ∗ (s, w) = s and δ∗ (t, w) = t bydefinition.
• Suppose w = 1 x and #(1, w) is even. Then #(1, x) is odd, which impliesδ∗ (s, w) = δ∗ (δ(s, 1), x)

by definition of δ∗= δ∗ (t, x)

by definition of δ=sby the inductive hypothesisδ∗ (t, w) = δ∗ (δ(t, 1), x)

by definition of δ∗= δ∗ (s, x)

by definition of δ=Tby the inductive hypothesis

Since the remaining cases are similar, I’ll omit the line-by-line justification.
• If w = 1 x and #(1, w) is odd, then #(1, x) is even, so the inductive hypothesis impliesδ∗ (s, w) = δ∗ (δ(s, 1), x) = δ∗ (t, x) = tδ∗ (t, w) = δ∗ (δ(t, 1), x) = δ∗ (s, x) = s• If w = 0 x and #(1, w) is even, then #(1, x) is even, so the inductive hypothesis impliesδ∗ (s, w) = δ∗ (δ(s, 0), x) = δ∗ (s, x) = sδ∗ (t, w) = δ∗ (δ(t, 0), x) = δ∗ (t, x) = t• Finally, if w = 0 x and #(1, w) is odd, then #(1, x) is odd, so the inductive hypothesis
impliesδ∗ (s, w) = δ∗ (δ(s, 0), x) = δ∗ (s, x) = tδ∗ (t, w) = δ∗ (δ(t, 0), x) = δ∗ (t, x) = s



Notice that this proof contains |Q|2 · |Σ| + |Q| separate inductive arguments. For every pair ofstates p and q, we must argue about the language of all strings w such that δ∗ (p, w) = q, andwe must consider every possible first symbol in w. We must also argue about δ(p, ") for every
state p. Each of those arguments is typically straightforward, but it’s easy to get lost in the delugeof cases.
For this particular proof, however, we can reduce the number of cases by switching from tailrecursion to head recursion. The following identity holds for all strings x ∈ Σ∗ and symbolsa ∈ Σ:
δ∗ (q, x a) = δ(δ∗ (q, x), a)
We leave the inductive proof of this identity as a straightforward exercise (hint, hint).
Proof (clever renaming, head induction): Let’s rename the states with the integers 0 and 1
instead of s and t. Then the transition function can be described concisely as δ(q , a) =(q + a) mod 2. We claim that for every string w, we have δ∗ (0, w) = #(1, w) mod 2.
Let w be an arbitrary string, and assume that for any string x that is shorter than w thatδ∗ (0, x) = #(1, x) mod 2. There are only two cases to consider: either w is empty or it isn’t.
• If w = ", then δ∗ (0, w) = 0 = #(1, w) mod 2 by definition.
5Models of Computation

Lecture 3: Finite-State Machines [Sp’18]• Otherwise, w = x a for some string x and some symbol a, and we haveδ∗ (0, w) = δ(δ∗ (0, x), a)

by definition of δ∗= δ(#(1, x) mod 2, a)by the inductive hypothesis= (#(1, x) mod 2 + a) mod 2= (#(1, x) + a) mod 2

by definition of δ
by definition of mod 2= (#(1, x) + #(1, a)) mod 2= (#(1, x a)) mod 2

because #(1, 0) = 0 and #(1, 1) = 1
by definition of #= (#(1, w)) mod 2

because w = x aHmmm. This “clever” proof is certainly shorter than the earlier brute-force proof, but is it
actually better? Simpler? More intuitive? Easier to understand? I’m skeptical. Sometimes brute
force really is more effective.

3.4

Real-World Examples

Finite-state machines were first formally defined in the mid-20th century, but people have beenbuilding automata for centuries, if not millennia. Many of the earliest records about automata
are clearly mythological—for example, the brass giant Talus created by Hephaestus to guard
Crete against intruders—but others are more believable, such as King-Shu’s construction of aflying magpie from wood and bamboo in China around 500bce.
Perhaps the most common examples of finite-state automata are clocks. For example, theSwiss railway clock designed by Hans Hilfiker in 1944 has hour and minute hands that can
indicate any time between 1:00 and 12:59. The minute hands advance discretely once per minutewhen they receive an electrical signal from a central master clock.2 Thus, a Swiss railway clock isa finite-state machine with 720 states, one input symbol, and a simple transition function:
Q = {(h, m) | 0 ≤ h11 and 0 ≤ m ≤ 59}

Σ = {tick}(h, m + 1) if m < 59
δ((h, m), tick) = (h + 1, 0) if h < 11 and m = 59(0, 0)if h = 11 and m = 59
This clock doesn’t quite match our abstraction, because there’s no “start” state or “accepting”
states, unless perhaps you consider the “accepting” state to be the time when your train arrives.
A more playful example of a finite-state machine is the Rubik’s cube, a well-known mechanicalpuzzle invented independently by Ernő Rubik in Hungary and Terutoshi Ishigi in Japan in the mid1970s. This puzzle has precisely 519,024,039,293,878,272,000 distinct configurations. In the uniquesolved configuration, each of the six faces of the cube shows exactly one color. We can change theconfiguration of the cube by rotating one of the six faces of the cube by 90 degrees, either clockwise
or counterclockwise. The cube has six faces (front, back, left, right, up, and down), so there areexactly twelve possible turns, typically represented by the symbols R, L, F, B, U, D, R̄, L̄, F̄, B̄, Ū, D̄,
where the letter indicates which face to turn and the presence or absence of a bar over the letter
2A second hand was added to the Swiss Railway clocks in the mid-1950s, which sweeps continuously around theclock in approximately 58½ seconds and then pauses at 12:00 until the next minute signal “to bring calm in the last
moment and ease punctual train departure”. Let’s ignore that.

6Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

indicates turning counterclockwise or clockwise, respectively. Thus, we can represent a Rubik’s
cube as a finite-state machine with 519,024,039,293,878,272,000 states and an input alphabet
with 12 symbols; or equivalently, as a directed graph with 519,024,039,293,878,272,000 vertices,each with 12 outgoing edges. In practice, the number of states is far too large for us to actually
draw the machine or explicitly specify its transition function; nevertheless, the number of statesis still finite. If we let the start state s and the sole accepting state be the solved state, thenthe language of this finite state machine is the set of all move sequences that leave the cube
unchanged.

Three finite-state machines.

3.5

A Brute-Force Design Example

As usual in algorithm design, there is no purely mechanical recipe—no automatic method—noalgorithm—for building DFAs in general. Here I’ll describe one systematic approach that works
reasonably well, although it tends to produce DFAs with many more states than necessary.
3.5.1

DFAs are Algorithms

The basic approach is to try to construct an algorithm that looks like MultipleOf5: A simple
for-loop through the symbols, using a constant number of variables, where each variable (except
the loop index) has only a constant number of possible values. Here, “constant” means an actual
number that is not a function of the input size n. You should be able to compute the number ofpossible values for each variable at compile time.
For example, the following algorithm determines whether a given string in Σ = {0, 1}
contains the substring 11.
Contains11(w[1 .. n]):found ← False
for i ← 1 to n
if i = 1
last2 ← w[1]else
last2 ← w[i − 1] · w[i]if last2 = 11
found ← True
return found

Aside from the loop index, this algorithm has exactly two variables.

7Models of Computation

Lecture 3: Finite-State Machines [Sp’18]• A boolean flag found indicating whether we have seen the substring 11. This variable has
exactly two possible values: True and False.
• A string last2 containing the last (up to) three symbols we have read so far. This variable
has exactly 7 possible values: ", 0, 1, 00, 01, 10, and 11.
Thus, altogether, the algorithm can be in at most 2 × 7 = 14 possible states, one for each possible
pair (found, last2). Thus, we can encode the behavior of Contains11 as a DFA with fourteenstates, where the start state is (False, ") and the accepting states are all seven states of the form
(True, ∗). The transition function is described in the following table (split into two parts to save
space):
δ[q, 0]q(False, 0)(False, 00)(False, 10)(False, ")(False, 0)(False, 1)(False, 00)(False, 01)(False, 10)(False, 11)(False, 00)(False, 10)(False, 00)(False, 10)δ[q, 1]δ[q, 0]q(False, 1)(False, 01)(True, 11)(True, 0)(True, 00)(True, 10)(True, ")(True, 0)(True, 1)(False, 01)(True, 11)(False, 01)(True, 11)δ[q, 1](True, 00)(True, 01)(True, 10)(True, 11)(True, 1)(True, 01)(True, 11)(True, 00)(True, 10)(True, 00)(True, 10)(True, 01)(True, 11)(True, 01)(True, 11)

For example, given the input string 1001011100, this DFA performs the following sequence oftransitions and then accepts.
1

0

0

1

(False, ") −→ (False, 1) −→ (False, 10) −→ (False, 00) −→0

1

1(False, 01) −→ (False, 10) −→ (False, 01) −→1

0

0(True, 11) −→ (True, 11) −→ (True, 10) −→ (True, 00)

3.5.2. . . but Algorithms can be WastefulYou can probably guess that the brute-force DFA we just constructed has considerably more states
than necessary, especially after seeing its transition graph:
F,ε
0

Τ,1
1

0

F,0

F,10
1

0

0

0
0

F,1

1

0

F,00

1

1

F,11

1
1

Τ,11
1

1

F,01

Τ,ε

1
0

Τ,10

0
0

1

Τ,01

0

0

Τ,0
1
0

1
1

Τ,00

0

Our brute-force DFA for strings containing the substring 11

For example, the state (False, 11) has no incoming transitions, so we can just delete it. (Thisstate would indicate that we’ve never read 11, but the last two symbols we read were 11, which
8Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

is impossible!) More significantly, we don’t need actually to remember both of the last two
symbols, but only the penultimate symbol, because the last symbol is the one we’re currently
reading. This observation allows us to reduce the number of states from fourteen to only six.
1

F,1

1

Τ,1

1

1

F,ε

1

0

Τ,ε

1

0

0

0

F,0

Τ,0

0

0

A less brute-force DFA for strings containing the substring 11

But even this DFA has more states than necessary. Once the flag part of the state is set toTrue, we know the machine will eventually accept, so we might as well merge all the accepting
states together. More subtly, because both transitions out of (False, 0) and (False, ") lead to thesame states, we can merge those two states together as well. After all these optimizations, we
obtain the following DFA with just three states:• The start state, which indicates that the machine has not read the substring 11 and did
not just read the symbol 1.
• An intermediate state, which indicates that the machine has not read the substring 11 but
just read the symbol 1.
• A unique accept state, which indicates that the machine has read the substring 11.
This is the smallest possible DFA for this language.
0,1

0
0

1

1

A minimal DFA for superstrings of 11

While it is important not to use an excessive number of states when we design DFAs—toomany states makes a DFA hard to understand—there is really no point in trying to reduce DFAs
by hand to the absolute minimum number of states. Clarity is much more important than brevity(especially in this class), and DFAs with too few states can also be hard to understand. At the endof this note, I’ll describe an efficient algorithm that automatically transforms any given DFA into
an equivalent DFA with the fewest possible states.

3.6 Combining DFAs: The Product Construction
Now suppose we want to accept all strings that contain both 00 and 11 as substrings, in either
order. Intuitively, we’d like to run two DFAs in parallel—the DFA M00 to detect superstrings of
00 and a similar DFA M11 obtained from M00 by swapping 0 ↔ 1 everywhere—and then accept
the input string if and only if both of these DFAs accept.
In fact, we can encode precisely this “parallel computation” into a single DFA using thefollowing product construction first proposed by Edward Moore in 1956:
9Models of Computation

Lecture 3: Finite-State Machines [Sp’18]• The states of the new DFA are all ordered pairs (p, q), where p is a state in M00 and q is astate in M11 .
• The start state of the new DFA is the pair (s, s0 ), where s is the start state of M00 and s0 is
the start state of M11 .
a• The new DFA includes the transition (p, q) −→ (p0 , q0 ) if and only if M00 contains theaatransition p −→ p0 and M11 contains the transition q −→ q0 .

• Finally, (p, q) is an accepting state of the new DFA if and only if p is an accepting state in
M00 and q is an accepting state in M11 .
The resulting nine-state DFA is shown on the next page, with the two factor DFAs M00 and
M11 shown in gray for reference. (The state (a, a) can be removed, because it has no incomingtransition, but let’s not worry about that now.)
0

s

0,1

0
1

a

1

b
1

1

0,1

s

s,s

1

1 0

0

0

a

a,s

0

0

0

b

b,s

0
1

0

s,a

1

1

s,b

1

0 1

a,b

a,a

0

b,a

1

b,b
0,1

Building a DFA for the language of strings containing both 00 and 11.

More generally, let M1 = (Σ, Q 1 , δ1 , s1 , A1 ) be an arbitrary DFA that accepts some language L1 ,and let M2 = (Σ, Q 2 , δ2 , s2 , A2 ) be an arbitrary DFA that accepts some language L2 (over thesame alphabet Σ). We can construct a third DFA M = (Σ, Q, δ, s, A) that accepts the intersection
language L1 ∩ L2 as follows.

Q := Q 1 × Q 2 = (p, q) p ∈ Q 1 and q ∈ Q 2
δ((p, q), a) := δ1 (p, a), δ2 (q, a)s := (s1 , s2 )A := A1 × A2 = (p, q) p ∈ A1 and q ∈ A2

To convince ourselves that this product construction is actually correct, let’s consider theextended transition function δ∗ : (Q × Q0 ) × Σ∗ → (Q × Q0 ), which acts on strings instead ofindividual symbols. Recall that this function is defined recursively as follows:((p, q)
if w = ",δ∗ (p, q), w :=∗δ δ((p, q), a), x
if w = ax.
This function behaves exactly as we should expect:10Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

Lemma 3.1. δ∗ ((p, q), w) = δ1∗ (p, w), δ2∗ (q, w) for any string w.

Proof: Let w be an arbitrary string. Assume δ∗ ((p, q), x) = δ1∗ (p, x), δ2∗ (q, x) for every string xthat is shorter than w. As usual, there are two cases to consider.
• First suppose w = ":δ∗ (p, q), " = (p, q)= δ1∗ (p, "), q

by the definition of δ∗= δ1∗ (p, e), δ2∗ (q, ")by the definition of δ1∗
by the definition of δ2∗• Now suppose w = ax for some symbol a and some string x:δ∗ (p, q), ax = δ∗ δ((p, q), a), x
by the definition of δ∗= δ∗ (δ1 (p, a), δ2 (q, a)), x
by the definition of δ
= δ1∗ ((δ1 (p, a), x), δ2∗ (δ2 (q, a), x)
by the induction hypothesis∗∗= δ1 (p, ax), δ2 (q, ax)
by the definitions of δ1∗ and δ2∗ .
In both cases, we conclude that δ∗ ((p, q), w) = δ1∗ (p, w), δ2∗ (q, w) .

An immediate consequence of this lemma is that for every string w, we have δ∗ (s, w) ∈ A if
and only if both δ1∗ (s1 , w) ∈ A1 and δ2∗ (s2 , w) ∈ A2 . In other words, M accepts w if and only if
both M1 accepts w and M2 accept w, as required.
As usual, this construction technique does not necessarily yield minimal DFAs. For example,
in our first example of a product DFA, illustrated above, the central state (a, a) cannot be reached
by any other state and is therefore redundant. Whatever.
Similar product constructions can be used to build DFAs that accept any other boolean
combination of languages; in fact, the only part of the construction that changes is the choice of
accepting states. For example:
• To accept the union L1 ∪ L2 , define A = (p, q) p ∈ A1 or q ∈ A2 .
• To accept the difference L1 \ L2 , define A = (p, q) p ∈ A1 but q 6∈ A2 .
• To accept the symmetric difference L1 ⊕ L2 , define A = (p, q) p ∈ A1 xor q ∈ A2 .

Examples of these constructions are shown on the next page.
Moreover, by cascading this product construction, we can construct DFAs that accept arbitrary
boolean combinations of arbitrary finite collections of regular languages.

3.7

Automatic Languages and Closure Properties

The language of a finite state machine M , denoted L(M), is the set of all strings in Σ∗ that M
accepts. More formally, if M = (Σ, Q, δ, s, A), thenL(M ) := w ∈ Σ∗ δ∗ (s, w) ∈ A .

We call a language automatic if it is the language of some finite state machine. Our productconstruction examples let us prove that the set of automatic languages is closed under simple
boolean operations.
11Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

1

s,s

1

0

0

1

b,s
0

s,b

s,s

1

1

0 1

0

0

a,b

a,s

0

0

b,b

b,s

0
0
1

b,a

(a)

1

1

a,a

a,s
0

s,a

1

0,1

0

s,a

1

s,b

s,s

1

1

0 1

0

0

a,b

a,s

0

0

b,b

b,s

a,a
0
0
1

b,a

(b)

1

1

1

0,1

0

s,a

1

1

s,b

1

0 1

a,b

a,a

0

0
0
1

b,a

1

b,b

(c)

0,1

DFAs for (a) strings that contain 00 or 11, (b) strings that contain either 00 or 11 but not both, and (c) strings that
contain 11 if they contain 00. These DFAs are identical except for their choices of accepting states.

Theorem 3.2. Let L and L 0 be arbitrary automatic languages over an arbitrary alphabet Σ.
• L = Σ∗ \ L is automatic.
• L ∪ L 0 is automatic.
• L ∩ L 0 is automatic.
• L \ L 0 is automatic.
• L ⊕ L 0 is automatic.

Eager students may have noticed that a Google search for the phrase “automatic language”
turns up no results that are relevant for this class, except perhaps this lecture note. That’s
because “automatic” is just a synonym for “regular”! This equivalence was first observed by
Stephen Kleene (the inventor of regular expressions) in 1956.
Theorem 3.3 (Kleene). For any regular expression R, there is a DFA M such that L(R) = L(M ).
For any DFA M , there is a regular expression R such that L(M ) = L(R).
Unfortunately, we don’t yet have all the tools we need to prove Kleene’s theorem; we’ll
return to the proof in the next lecture note, after we have introduced nondeterministic finite-statemachines. The proof is actually constructive—there are explicit algorithms that transformarbitrary DFAs into equivalent regular expressions and vice versa.3
This equivalence between regular and automatic languages implies that the set of regular
languages is also closed under simple boolean operations. The union of two regular languages
is regular by definition, but it’s much less obvious that every boolean combination of regular
languages can also be described by regular expressions.
Corollary 3.4. Let L and L 0 be arbitrary regular languages over an arbitrary alphabet Σ.
• L = Σ∗ \ L is regular.
• L ∩ L 0 is regular.
• L \ L 0 is regular.
• L ⊕ L 0 is regular.

Conversely, because concatenations and Kleene closures of regular languages are regular bydefinition, we can immediately conclude that concatenations and Kleene closures of automatic
languages are automatic.
3These conversion algorithms run in exponential time in the worst case, but that’s unavoidable. There are regular
languages whose smallest accepting DFA is exponentially larger than their smallest regular expression, and there areregular languages whose smallest regular expression is exponentially larger than their smallest accepting DFA.

12

Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

Corollary 3.5. Let L and L 0 be arbitrary automatic languages.
• L • L 0 is automatic.
• L ∗ is automatic.
These results give us several options to prove that a given languages is regular or automatic.
We can either (1) build a regular expression that describes the language, (2) build a DFA that
accepts the language, or (3) build the language from simpler pieces from other regular/automatic
languages. (Later we’ll see a fourth option, and possibly even a fifth.)

3.8

Proving a Language is Not Regular

But now suppose we’re faced with a language L where none of these techniques seem to work.
How would we prove L is not regular? By Theorem ??, it suffices to prove that there is no
finite-state automaton that accepts L. Equivalently, we need to prove that any automaton that
accepts L requires infinitely many states. That may sound tricky, what with the “infinitely many”,
but there’s actually a fairly simple technique to prove exactly that.
3.8.1

Distinguishing Suffixes

Perhaps the single most important feature of DFAs is that they have no memory other than thecurrent state. Once a DFA enters a particular state, all future transitions depend only on thatstate and future input symbols; past input symbols are simply forgotten.
For example, consider our very first DFA, which accepts the binary representations of integers
divisible by 5.

1
0

0

1

0

0
1

3

1

0

4

1

2

1

0

DFA accepting binary multiples of 5.

The strings 0010 and 11011 both lead this DFA to state 2, although they follow different
transitions to get there. Thus, for any string z, the strings 0010z and 11011z also lead to thesame state in this DFA. In particular, 0010z leads to the accepting state if and only if 11011z
leads to the accepting state. It follows that 0010z is divisible by 5 if and only if 11011z isdivisible by 5.
More generally, any DFA M = (Σ, Q, s, A, δ) defines an equivalence relation over Σ∗ , where
two strings x and y are equivalent if and only if they lead to the same state, or more formally, ifδ∗ (s, x) = δ∗ (s, y). If x and y are equivalent strings, then for any string z, the strings xz andyz are also equivalent. In particular, M accepts xz if and only if M accepts yz. Thus, if L is
the language accepted by M , then xz ∈ L if and only if yz ∈ L. In short, if the machine can’t
distinguish between x and y, then the language can’t distinguish between xz and yz for any
suffix z.
Now let’s turn the previous argument on its head. Let L be an arbitrary language, and let x
and y be arbitrary strings. A distinguishing suffix for x and y (with respect to L) is a third
string z such that exactly one of the strings xz and yz is in L. If x and y have a distinguishing13

Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

suffix z, then in any DFA that accepts L, the strings xz and yz must lead to different states, andtherefore the strings x and y must lead to different states!
For example, let L5 denote the the set of all strings over {0, 1} that represent multiples of 5
in binary. Then the strings x = 01 and y = 0011 are distinguished by the suffix z = 01:xz = 01 • 01 = 0101 ∈ L5

(because 01012 = 5)yz = 0011 • 01 = 001101 6∈ L5(because 0011012 = 13)

It follows that in every DFA that accepts L5 , the strings 01 and 0011 lead to different states.
Moreover, since neither 01 nor 0011 belong to L5 , every DFA that accepts L5 must have at least
two non-accepting states, and therefore at least three states overall.
3.8.2

Fooling Sets

A fooling set for a language L is a set F of strings such that every pair of strings in F has adistinguishing suffix. For example, F = {0, 1, 10, 11, 100} is a fooling set for the language L5 ofbinary multiples of 5, because each pair of strings in F has a distinguishing suffix:• 0 distinguishes 0 and 1;• 0 distinguishes 0 and 10;• 0 distinguishes 0 and 11;• 0 distinguishes 0 and 100;
• 1 distinguishes 1 and 10;• 01 distinguishes 1 and 11;• 01 distinguishes 1 and 100;
• 1 distinguishes 10 and 11;• 1 distinguishes 10 and 100;
• 11 distinguishes 11 and 100.
Each of these five strings leads to a different state, for any DFA M that accepts L5 . Thus,
every DFA that accepts the language L5 has at least five states. And hey, look, we already have a
DFA for L5 with five states, so that’s the best we can do!
More generally, for any language L, and any fooling set F for L, every DFA that accepts L musthave at least |F | states. In particular, if the fooling set F is infinite, then every DFA that accepts L
must have an infinite number of states. But there’s no such thing as a finite-state machine withan infinite number of states!
If L has an infinite fooling set, then L is not regular.
This is arguably both the simplest and most powerful method for proving that a language is
non-regular. Here are a few canonical examples of the fooling-set technique in action.
Lemma 3.6. The language L = {0n 1n | n ≥ 0} is not regular.

Proof: Consider the infinite set F = {0n | n ≥ 0}, or more simply F = 0∗ .
Let x and y be arbitrary distinct strings in F .
The definition of F implies x = 0i and y = 0 j for some integers i 6= j.
14

Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

The suffix z = 1i distinguishes x and y, because xz = 0i 1i ∈ L, but yz = 0 j 1i 6∈ L.
Thus, every pair of distinct strings in F has a distinguishing suffix.
In other words, F is a fooling set for L.
Because F is infinite, L cannot be regular.



Lemma 3.7. The language L = {wwR | w ∈ Σ∗ } of even-length palindromes is not regular.
Proof: Let F denote the set 0∗ 1, and let x and y be arbitrary distinct strings in F . Then wemust have x = 0i 1 and y = 0 j 1 for some integers i 6= j. The suffix z = 10i distinguishes x
and y, because xz = 0i 110i ∈ L, but yz = 0i 110 j 6∈ L. We conclude that F is a fooling set for L.
Because F is infinite, L cannot be regular.
nLemma 3.8. The language L = {02 | n ≥ 0} is not regular.

i

Proof (F = L): Let x and y be arbitrary distinct strings in L. Then we must have x = 02ji
and y = 02 for some integers i 6= j. The suffix z = 02 distinguishes x and y, because
i
i
i+1
i
j
xz = 02 +2 = 02 ∈ L, but yz = 02 +2 6∈ L. We conclude that L itself is a fooling set for L.
Because L is infinite, L cannot be regular.
Proof (F = 0∗ ): Let x and y be arbitrary distinct strings in 0∗ . Then we must have x = 0i andy = 0 j for some integers i 6= j; without loss of generality, assume i < j. Let k be any positivekkk
integer such that 2k > j. Consider the suffix z = 02 −i . We have xz = 0i+(2 −i) = 02 ∈ L, butkkyz = 0 j+(2 −i) = 02 −i+ j 6∈ L, because
2k < 2k − i + j < 2k + j < 2k + 2k = 2k+1 .

Thus, z is a distinguishing suffix for x and y. We conclude that 0∗ is a fooling set for L. Because
L is infinite, L cannot be regular.
Proof (F = 0∗ again): Let x and y be arbitrary distinct strings in 0∗ . Then we must have x = 0i
and y = 0 j for some integers i 6= j; without loss of generality, assume i < j. Let k be any positivekkk
integer such that 2k−1 > j. Consider the suffix z = 02 − j . We have xz = 0i+(2 − j) = 02 − j+i 6∈ L,
because2k−1 < 2k − 2k−1 + i < 2k − j + i < 2k .
kk

On the other hand, yz = 0 j+(2 − j) = 02 ∈ L. Thus, z is a distinguishing suffix for x and y. We
conclude that 0∗ is a fooling set for L. Because L is infinite, L cannot be regular.
The previous examples show the flexibility of this proof technique; a single non-regular
language can have many different infinite fooling sets,⁴ and each pair of strings in any foolingset can have many different distinguishing suffixes. Fortunately, we only have to find one infinite
set F and one distinguishing suffix for each pair of strings in F .
Lemma 3.9. The language L = {0 p | p is prime} is not regular.

⁴At some level, this observation is trivial. If F is an infinite fooling set for L, then every infinite subset of F is also
an infinite fooling set for L!

15

Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

Proof (F = 0∗ ): Again, we use 0∗ as our fooling set, but but the actual argument is somewhat
more complicated than in our earlier examples.
Let x and y be arbitrary distinct strings in 0∗ . Then we must have x = 0i and y = 0 j forsome integers i 6= j; without loss of generality, assume that i < j. Let p be any prime number
larger than i. Because p + 0( j − i) is prime and p + p( j − i) > p is not, there must be a positive
integer k ≤ p such that p + (k − 1)( j − i) is prime but p + k( j − i) is not. Then I claim that thesuffix z = 0 p+(k−1) j−ki distinguishes x and y:xz = 0i 0 p+(k−1) j−ki = 0 p+(k−1)( j−i) ∈ L
jyz = 0 0p+(k−1) j−ki=0p+k( j−i)because p + (k − 1)( j − i) is prime;

6∈ L

because p + k( j − i) is not prime.

(Because i < j and i < p, the suffix 0 p+(k−1) j−ki = 0(p−i)+(k−1)( j−i) has positive length andtherefore actually exists!) We conclude that 0∗ is indeed a fooling set for L, which implies that L
is not regular.
Proof (F = L): Let x and y be arbitrary distinct strings in L. Then we must have x = 0 p and
y = 0q for some primes p 6= q; without loss of generality, assume p < q.
Now consider strings of the form 0 p+k(q−p) . Because p +0(q − p) is prime and p + p(q − p) > p
is not prime, there must be a non-negative integer k < p such that p + k(p − q) is prime but
p + (k + 1)(p − q) is not prime. I claim that the suffix z = 0k(q−p) distinguishes x and y:xz = 0 p 0k(q−p) = 0 p+k(p−q) ∈ L
qyz = 0 0k(q−p)=0

p+(k+1)(q−p)

because p + k(p − q) is prime;

6∈ L

because p + (k + 1)(p − q) is not prime.

We conclude that L is a fooling set for itself!! Because L is infinite, L cannot be regular!

Obviously the most difficult part of this technique is coming up with an appropriate foolingset. Fortunately, most languages L—in particular, almost all languages that students are asked toprove non-regular on homeworks or exams—fall into one of two categories:• Some simple regular language like 0∗ or 10∗ 1 or (01)∗ is a fooling set for L. In particular,
the fooling set is a regular language with one Kleene star and no +.
• The language L itself is a fooling set for L.
The most important point to remember is that you choose the fooling set F , and you can use thatfooling set to effectively impose additional structure on the language L.

ÆÆÆ

16

Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

I’m not sure yet how to express this effectively, but here is some more intuition aboutchoosing fooling sets and distinguishing suffixes.
As a sanity check, try to write an algorithm to recognize strings in L , as described at thestart of this note, where the only variable that can take on an unbounded number of values
is the loop index i . (I should probably rewrite that template as a while-loop or tail recursion,
but anyway. . . .) If you succeed, the language is regular. But if you fail, it’s probably because
there are counters of string variables that you can’t get rid of. One of those unavoidable
counters is the basis for your fooling set.
For example, any algorithm that recognizes the language {0n 1n 2n | n ≥ 0} “obviously”
has to count 0s and 1s in the input string. (We can avoid counting 2s by decrementing the 0
counter.) Because the 0s come first in the string, this intuition suggests using strings of theform 0n as our fooling set and matching strings of the form 1n 2n as distinguishing suffixes.
(This is a rare example of an “obvious” fact that is actually true.)
It’s also important to remember that when you choose the fooling set, you can effectively
impose additional structure that isn’t present in the language already. For example, to provethat the language L = {w ∈ (0 + 1)∗ | #(0, w) = (1, w)} is not regular, we can use strings ofthe form 0n as our fooling set and matching strings of the form 1n as distinguishing suffixes,
exactly as we did for {0n 1n | n ≥ 0}. The fact that L contains strings that start with 1 isirrelevant. There may be more equivalence classes that our proof doesn’t find, but since wefound an infinite set of equivalence class, we don’t care.
At some level, this fooling set proof is implicitly considering the simpler language L ∩ 0∗ 1∗ =n n
{0 1 | n ≥ 0}. If L were regular, then L ∩ 0∗ 1∗ would also be regular, because regular
languages are closed under intersection.

?

3.9

The Myhill-Nerode Theorem

The fooling set technique implies a necessary condition for a language to be accepted by a
DFA—the language must have no infinite fooling sets. In fact, this condition is also sufficient.
The following powerful theorem was first proved by Anil Nerode in 1958, strengthening a 1957
result of John Myhill.⁵ We write x ≡ L y if xz ∈ L ⇐⇒ yz ∈ L for all strings z.
The Myhill-Nerode Theorem. For any language L, the following are equal:(a) the minimum number of states in a DFA that accepts L,(b) the maximum size of a fooling set for L, and(c) the number of equivalence classes of ≡ L .
In particular, L is accepted by a DFA if and only if every fooling set for L is finite.
Proof: Let L be an arbitrary language.
We have already proved that the size of any fooling set for L is at most the number of states
in any DFA that accepts L, so (a)≥(b). It also follows directly from the definitions that F ⊆ Σ∗ isa fooling set for L if and only if F contains at most one string in each equivalence class of ≡ L ;thus, (b)=(c). We complete the proof by showing that (a)≤(c).
We have already proved that if ≡ L has an infinite number of equivalence classes, there is no
DFA that accepts L, so assume that the number of equivalence classes is finite. For any string w,
⁵Myhill considered the finer equivalence relation x ∼ L y, meaning wxz ∈ L if and only if w yz ∈ L for all strings
w and z, and proved that L is regular if and only if ∼ L defines a finite number of equivalence classes. Like mostof Myhill’s early automata research, this result appears in an unpublished Air Force technical report. The modern
Myhill-Nerode theorem appears (in an even more general form) as a minor lemma in Nerode’s 1958 paper, which (notsurprisingly) does not cite Myhill.

17Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

let [w] denote its equivalence class. We define a DFA M≡ = (Σ, Q, s, A, δ) as follows:
Q := [w] w ∈ Σ∗s := ["]
A := [w] w ∈ L

δ([w], a) := [w • a]

We claim that this DFA accepts the language L; this claim completes the proof of the theorem.
But before we can prove anything about this DFA, we first need to verify that it is actuallywell-defined. Let x and y be two strings such that [x] = [ y]. By definition of L-equivalence,
for any string z, we have xz ∈ L if and only if yz ∈ L. It immediately follows that for any
symbol a ∈ Σ and any string z 0 , we have x az 0 ∈ L if and only if y az 0 ∈ L. Thus, by definition ofL-equivalence, we have [x a] = [ y a] for every symbol a ∈ Σ. We conclude that the function δ isindeed well-defined.
An easy inductive proof implies that δ∗ (["], x) = [x] for every string x. Thus, M accepts
string x if and only if [x] = [w] for some string w ∈ L. But if [x] = [w], then by definition(setting z = "), we have x ∈ L if and only if w ∈ L. So M accepts x if and only if x ∈ L. In otherwords, M accepts L, as claimed, so the proof is complete.

?

3.10

Minimal Automata

Given a DFA M = (Σ, Q, s, A, δ), suppose we want to find another DFA M 0 = (Σ, Q0 , s0 , A0 , δ0 ) withthe fewest possible states that accepts the same language. In this final section, we describe
an efficient algorithm to minimize DFAs, first described (in slightly different form) by Edward
Moore in 1956. We analyze the running time of Moore’s in terms of two parameters: n = |Q| andσ = |Σ|.
In the preprocessing phase, we find and remove any states that cannot be reached from thestart state s; this filtering can be performed in O(nσ) time using any graph traversal algorithm.
So from now on we assume that all states are reachable from s.
Now we recursively define two states p and q in the remaining DFA to be distingushable,
written p 6∼ q , if at least one of the following conditions holds:• p ∈ A and q 6∈ A,• p 6∈ A and q ∈ A, or• δ(p, a) 6∼ δ(q, a) for some a ∈ Σ.

Equivalently, p 6∼ q if and only if there is a string z such that exactly one of the states δ∗ (p, z)
and δ∗ (q, z) is accepting. (Sound familiar?) Intuitively, the main algorithm assumes that allstates are equivalent until proven otherwise, and then repeatedly looks for state pairs that can beproved distinguishable.
The main algorithm maintains a two-dimensional table, indexed by the states, where
Dist[p, q] = True indicates that we have proved states p and q are distinguishable. Initially, for allstates p and q, we set Dist[p, q] ← True if p ∈ A and q 6∈ A or vice versa, and Dist[p, q] = False
otherwise. Then we repeatedly consider each pair of states and each symbol to find more
distinguishable pairs, until we make a complete pass through the table without modifying it. The
table-filling algorithm can be summarized as follows:18Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

MinDFATable(Σ, Q, s, A, δ):for all p ∈ Q
for all q ∈ Q
if (p ∈ A and q 6∈ A) or (p 6∈ A and q ∈ A)
Dist[p, q] ← Trueelse
Dist[p, q] ← False
notdone ← True
while notdone
notdone ← False
for all p ∈ Q
for all q ∈ Q
if Dist[p, q] = False
for all a ∈ Σ
if Dist[δ(p, a), δ(q, a)]Dist[p, q] ← True
notdone ← True
return DistThe algorithm must eventually halt, because there are only a finite number of entries in thetable that can be marked. In fact, the main loop is guaranteed to terminate after at most niterations, which implies that the entire algorithm runs in O(σn 3 ) time. Once the table is filled,⁶
any two states p and q such that Dist(p, q) = False are equivalent and can be merged into asingle state. The remaining details of constructing the minimized DFA are straightforward.

ÆÆÆNeed to prove that the main loop terminates in at most n iterations.

With more care, Moore’s minimization algorithm can be modified to run in O(σn2 ) time. A
faster DFA minimization algorithm, due to John Hopcroft, runs in O(σn log n) time.
ExampleTo get a better idea how this algorithm works, let’s visualize its execution on our earlier brute-force
DFA for strings containing the substring 11. This DFA has four unreachable states: (False, 11),
(True, "), (True, 0), and (True, 1). We remove these states, and relabel the remaining states foreasier reference. (In an actual implementation, the states would almost certainly be represented
by indices into an array anyway, not by mnemonic labels.)
The main algorithm initializes (the bottom half of) a 10×10 table as follows. (In the following
figures, cells marked × have value True and blank cells have value False.)
⁶More experienced readers should be enraged by the mere suggestion that any algorithm merely fills in a table, as
opposed to evaluating a recurrence. This algorithm is no exception. Consider the boolean function Dist(p, q, k), whichequals True if and only if p and q can be distinguished by some string of length at most k. This function obeys thefollowing recurrence:
if k = 0,
(p ∈ A) ⊕ (q ∈ A)_
Dist(p, q, k) =Dist δ(p, a), δ(q, a), k − 1 otherwise.
Dist(p, q, k − 1) ∨a∈ΣMoore’s “table-filling” algorithm is just a space-efficient dynamic programming algorithm to evaluate this recurrence.

19Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

0
0

1

0

1

5
1

0

0
0

2

1

3

9
01

1

1

1

8

0
0

1

4

7

0
1
1

6

0

Our brute-force DFA for strings containing the substring 11, after removing all four unreachable states

0 1 2 3 4 5 6 7 8

1
2
3
4
5
6 × × × × × ×
7 × × × × × ×
8 × × × × × ×
9 × × × × × ×In the first iteration of the main loop, the algorithm discovers several distinguishable pairsof states. For example, the algorithm sets Dist[0, 2] ← True because Dist[δ(0, 1), δ(2, 1)] =Dist[2, 9] = True. After the iteration ends, the table looks like this:0 1 2 3 4 5 6 7 8
1
2 × ×
3
×
4 × ×
×
5
×
×
6 × × × × × ×
7 × × × × × ×
8 × × × × × ×
9 × × × × × ×

The second iteration of the while loop makes no further changes to the table—We got lucky!—so
the algorithm terminates.
The final table implies that the 10 states of our DFA fall into exactly three equivalence classes:{0, 1, 3, 5}, {2, 4}, and {6, 7, 8, 9}. Replacing each equivalence class with a single state gives us
the three-state DFA that we already discovered.

Exercises
1. For each of the following languages in {0, 1}∗ , describe a deterministic finite-state machinethat accepts that language. There are infinitely many correct answers for each language.
“Describe” does not necessarily mean “draw”.
(a) Only the string 0110.
20Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

0

2

1

1

0
0

1

1

5
1

9
1

0

0

1

0

3

1

0
1

1

0
0

8

0

4

7

1

6

0

0,1

0
1

1

0

Equivalence classes of states in our DFA, and the resulting minimal equivalent DFA.

(b) Every string except 0110.
(c) Strings that contain the substring 0110.
(d) Strings that do not contain the substring 0110.
? (e)Strings that contain an even number of occurrences of the substring 0110. (Forexample, this language contains the strings 0110110 and 01011.)(f) Strings that contain the subsequence 0110.
(g) Strings that do not contain the subsequence 0110.
? (h)Strings that contain an even number of occurrences of the subsequence 0110.

(i) Strings that contain an even number of 1s and an odd number of 0s.
(j) Every string that represents a number divisible by 7 in binary.
(k) Every string whose reversal represents a number divisible by 7 in binary.
(l) Strings in which the substrings 01 and 10 appear the same number of times.
(m) Strings such that in every prefix, the number of 0s and the number of 1s differ by atmost 1.
(n) Strings such that in every prefix, the number of 0s and the number of 1s differ by atmost 4.
(o) Strings that end with 010 = 0000000000.
(p) All strings in which the number of 0s is even if and only if the number of 1s is notdivisible by 3.
(q) All strings that are both the binary representation of an integer divisible by 3 and theternary (base-3) representation of an integer divisible by 4.
(r) Strings in which the number of 1s is even, the number of 0s is divisible by 3, theoverall length is divisible by 5, the binary value is divisible by 7, the binary value ofthe reversal is divisible by 11, and does not contain thirteen 1s in a row. [Hint: Thisis more tedious than difficult.]? (s) Strings w such that |w| mod 6 = 4.
221Models of Computation? (t)Lecture 3: Finite-State Machines [Sp’18]

Strings w such that F#(10,w) mod 10 = 4, where #(10, w) denotes the number oftimes 10 appears as a substring of w, and as usual Fn is the nth Fibonacci number:
if n = 0
0Fn = 1
if n = 1F+Fotherwise
n−1

Æ

n−2

(u) Strings w such that F#(1···0,w) mod 10 = 4, where #(1 · · · 0, w) denotes the number oftimes 10 appears as a subsequence of w, and as usual Fn is the nth Fibonacci number:
if n = 0
0
Fn =

1

F
n−1 + Fn−2

if n = 1otherwise

2. (a) Let L ⊆ 0∗ be an arbitrary unary language. Prove that L ∗ is regular.

(b) Prove that there is a binary language L ⊆ (0 + 1)∗ such that L ∗ is not regular.

3. Prove that none of the following languages is automatic.
 2(a) 0n n ≥ 0
 3(b) 0n n ≥ 0(c) 0 f (n) n ≥ 0 , where f (n) is any fixed polynomial in n with degree at least 2.
(d) 0n n is composite
(e) 0n 10n n ≥ 0(f) {0m 1n | m 6= n}(g) {0m 1n | m < 3n}(h) 02n 1n n ≥ 0(i) {w ∈ (0 + 1)∗ | #(0, w) = #(1, w)}(j) {w ∈ (0 + 1)∗ | #(0, w) < #(1, w)}(k) {0m 1n | m/n is an integer}(l) {0m 1n | m and n are relatively prime}(m) {0m 1n | n − m is a perfect square}(n) {w#w | w ∈ (0 + 1)∗ }(o) {ww | w ∈ (0 + 1)∗ }(p) w#0|w| w ∈ (0 + 1)∗
(q) w0|w| w ∈ (0 + 1)∗(r) {x y | x, y ∈ (0 + 1)∗ and |x| = | y| but x 6= y}(s) 0m 1n 0m+n m, n ≥ 0(t) {0m 1n 0mn | m, n ≥ 0}(u) Strings in which the substrings 00 and 11 appear the same number of times.
22Models of Computation

Lecture 3: Finite-State Machines [Sp’18](v) Strings of the form w1 #w2 # · · · #w n for some n ≥ 2, where w i ∈ {0, 1}∗ for every
index i, and w i = w j for some indices i 6= j.

(w) The set of all palindromes in (0 + 1)∗ whose length is divisible by 7.
Æ(x) {w ∈ (0 + 1)∗ | w is the binary representation of a perfect square}(y) {w ∈ (0 + 1)∗ | w is the binary representation of a prime number}

4. For each of the following languages over the alphabet Σ = {0, 1}, either prove that thelanguage is regular (by constructing an appropriate DFA or regular expression) or provethat the language is not regular (using fooling sets). Recall that Σ+ denotes the set of all
nonempty strings over Σ. [Hint: Believe it or not, most of these languages are actually
regular.](a) 0n w1n w ∈ Σ∗ and n ≥ 0(b) 0n 1n w w ∈ Σ∗ and n ≥ 0(c) w0n 1n x w, x ∈ Σ∗ and n ≥ 0(d) 0n w1n x w, x ∈ Σ∗ and n ≥ 0(e) 0n w1 x 0n w, x ∈ Σ∗ and n ≥ 0(f) 0n w0n w ∈ Σ+ and n > 0(g) w0n w w ∈ Σ+ and n > 0(h) wx w w, x ∈ Σ∗(i) wx w w, x ∈ Σ+(j) wx wR w, x ∈ Σ+(k) wwx w, x ∈ Σ+(l) wwR x w, x ∈ Σ+(m) wx w y w, x, y ∈ Σ+(n) wx wR y w, x, y ∈ Σ+(o) x ww y w, x, y ∈ Σ+(p) x wwR y w, x, y ∈ Σ+(q) wx x w w, x ∈ Σ+
? (r) wx wR x w, x ∈ Σ+(s) All strings w such that no prefix of w is a palindrome.

(t) All strings w such that no prefix of w with length at least 3 is a palindrome.
(u) All strings w such that no substring of w with length at least 3 is a palindrome.
(v) All strings w such that no prefix of w with positive even length is a palindrome.
(w) All strings w such that no substring of w with positive even length is a palindrome.
(x) Strings in which the substrings 00 and 11 appear the same number of times.
(y) Strings in which the substrings 01 and 10 appear the same number of times.

23Models of Computation

Lecture 3: Finite-State Machines [Sp’18]

5. Let F and L be arbitrary infinite languages in {0, 1}∗ .

(a) Suppose for any two distinct strings x, y ∈ F , there is a string w ∈ Σ∗ such thatwx ∈ L and w y 6∈ L. (We can reasonably call w a distinguishing prefix for x and y.)
Prove that L cannot be regular. [Hint: The reversal of a regular language is regular.]? (b)Suppose for any two distinct strings x, y ∈ F , there are two (possibly equal) strings
w, z ∈ Σ∗ such that wxz ∈ L and w yz 6∈ L. Prove that L cannot be regular.

24Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]
The art of art, the glory of expression
and the sunshine of the light of letters is simplicity.
Nothing is better than simplicity . . . .
nothing can make up for excess or for the lack of definiteness.
— Walt Whitman, Preface to Leaves of Grass (1855)
Freedom of choice
Is what you got.
Freedom from choice
Is what you want.
— Devo, “Freedom of Choice”, Freedom of Choice (1980)

4

Nondeterminism

4.1

Nondeterministic State Machines

The following diagram shows something that looks like a finite-state machine over the alphabet{0, 1}, but on closer inspection, it is not consistent with our earlier definitions. On one hand,
there are two transitions out of s for each input symbol. On the other hand, states a and b areeach missing an outgoing transition.
a
0

0
1,0

s

c
1

1,0

1

b
A nondeterministic finite-state automaton

Nevertheless, there is a sense in which this machine “accepts” the set of all strings that containeither 00 or 11 as a substring. Imagine that when the machine reads a symbol in state s, it
makes a choice about which transition to follow. If the input string contains the substring 00,
then it is possible for the machine to end in the accepting state c, by choosing to move into
state a when it reads a 0 immediately before another 0. Similarly, if the input string contains
the substring 11, it is possible for the machine to end in the accepting state c. On the other hand,
if the input string does not contain either 00 or 11—or in other words, if the input alternates
between 0 and 1—there are no choices that lead the machine to the accepting state. If themachine incorrectly chooses to transition to state a and then reads a 1, or transitions to b andthen reads 0, it explodes; the only way to avoid an explosion is to stay in state s.
This object is an example of a nondeterministic finite-state automaton, or NFA, so named
because its behavior is not uniquely determined by the input string. Formally, every NFA has fivecomponents:• An arbitrary finite set Σ, called the input alphabet.
• Another arbitrary finite set Q, whose elements are called states.
• An arbitrary transition function δ : Q × Σ → 2Q .
• A start state s ∈ Q.

© Copyright 2018 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms/ for the most recent revision.

1Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]• A subset A ⊆ Q of accepting states.

The only difference from the formal definition of deterministic finite-state automata is the domainof the transition function. In a DFA, the transition function always returns a single state; in an
NFA, the transition function returns a set of states, which could be empty, or all of Q, or anything
in between.
Just like DFAs, the behavior of an NFA is governed by an input string w ∈ Σ∗ , which themachine reads one symbol at a time, from left to right. Unlike DFAs, however, an NFA does not
maintain a single current state, but rather a set of current states.
S Whenever the NFA reads asymbol a, its set of current states changes from C to δ(C, a) := q∈C δ(q, a). After all symbols
have been read, the NFA accepts w if its current state set contains at least one accepting state
and rejects w otherwise. In particular, if the set of current states ever becomes empty, it will stay
empty forever, and the NFA will reject.
More formally, we define the function δ∗ : Q × Σ∗ → 2Q that transitions on strings as follows:{q}[δ∗ (q, w) :=

if w = ",r∈δ(q,a)δ∗ (r, x) if w = ax.

The NFA (Q, Σ, δ, s, A) accepts w ∈ Σ∗ if and only if δ∗ (s, w) ∩ A 6= ∅.
We can equivalently define an NFA as a directed graph whose vertices are the states Q, whoseedges are labeled with symbols from Σ. We no longer require that every vertex has exactly one
outgoing edge with each label; it may have several such edges or none. An NFA accepts a string w
if the graph contains at least one walk from the start state to an accepting state whose label is w.

ÆÆÆ

It’s arguably more natural to an arbitrary set of start states S ⊆ Q instead of just one. Thenan NFA accepts a string w if and only if there is a sequence of transitions consistent with w
from some start state to some accepting state, or more formally if δ∗ (S, q) ∩ A 6= ∅. Change
the definition and chase through all the theorems? Or prove equivalence and bounce backand forth, like we already do for " -transitions?

4.2

Intuition

There are at least three useful ways to think about non-determinism.
Clairvoyance. Whenever an NFA reads symbol a in state q, it chooses the next state from theset δ(q, a), always magically choosing a state that leads to the NFA accepting the input string,unless no such choice is possible. As the BSD fortune file put it, “Nondeterminism means never
having to say you’re wrong.”1 Of course real machines can’t actually look into the future; that’s
why I used the word “magic”.
Parallel threads. An arguably more “realistic” view is that when an NFA reads symbol a instate q, it spawns an independent execution thread for each state in δ(q, a). In particular, ifδ(q, a) is empty, the current thread simply dies. The NFA accepts if at least one thread is in an
accepting state after it reads the last input symbol.
1This sentence is a riff on a horrible aphorism that was (sadly) popular in the US in the 70s and 80s. Fortunately,
everyone seems to have forgotten the original saying, except maybe for that one time it was mocked on The Simpsons.
Ah, who am I kidding? Nobody remembers The Simpsons either.

2

Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]

Equivalently, we can imagine that when an NFA reads symbol a in state q, it branches into
several parallel universes, one for each state in δ(q, a). If δ(q, a) is empty, the NFA destroys theuniverse (including itself). Similarly, if the NFA finds itself in a non-accepting state when the
input ends, the NFA destroys the universe. Thus, when the input is gone, only universes in which
the NFA somehow chose a path to an accept state still exist. One slight disadvantage of thismetaphor is that if an NFA reads a string that is not in its language, it destroys all universes.
Proofs/oracles. Finally, we can treat NFAs not as a mechanism for computing something, but asa mechanism for verifying proofs. If we want to prove that a string w contains one of the suffixes
00 or 11, it suffices to demonstrate a single walk in our example NFA that starts at s and ends
at c, and whose edges are labeled with the symbols in w. Equivalently, whenever the NFA faces a
nontrivial choice, the prover can simply tell the NFA which state to move to next.
This intuition can be formalized as follows. Consider a deterministic finite state machine
whose input alphabet is the product Σ × Ω of an input alphabet Σ and an oracle alphabet Ω.
Equivalently, we can imagine that this DFA reads simultaneously from two strings of the samelength: the input string w and the oracle string ω. In either formulation, the transition function
has the form δ : Q × (Σ × Ω) → Q. As usual, this DFA accepts the pair (w, ω) ∈ (Σ × Ω)∗ if andonly if δ∗ (s, (w, ω)) ∈ A. Finally, M nondeterministically accepts the string w ∈ Σ∗ if there isan oracle string ω ∈ Ω∗ with |ω| = |w| such that (w, ω) ∈ L(M ).

4.3 "-Transitions
It is fairly common for NFAs to include so-called "-transitions, which allow the machine tochange state without reading an input symbol. An NFA with "-transitions accepts a string w
a1

a3

a2

a`

if and only if there is a sequence of transitions s −→ q1 −→ q2 −→ · · · −→ q` where the final
state q` is accepting, each ai is either " or a symbol in Σ, and a1 a2 · · · a` = w.
For example, consider the following NFA with "-transitions. (For this example, we indicate
the "-transitions using large red arrows; we won’t normally do that.) This NFA deliberately has
more "-transitions than necessary.
0

a

b

0

c
ε

1,0

s

ε

ε
ε

d

1

e

g

ε
ε

1,0

f

1

A (rather silly) NFA with " -transitions

The NFA starts as usual in state s. If the input string is 100111, the the machine might
non-deterministically choose the following transitions and then accept.
"

1

"

"

0

0

"

1

1

"

1

"

"

s −→ s −→ s −→ d −→ a −→ b −→ c −→ d −→ e −→ f −→ e −→ f −→ c −→ gMore formally, the transition function in an NFA with "-transitions has a slightly larger
domain δ : Q × (Σ ∪ {"}) → 2Q . The "-reach of a state q ∈ Q consists of all states r that satisfy
one of the following conditions:• either r = q,3Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]• or r ∈ δ(q0 , ") for some state q0 in the "-reach of q.

In other words, r is in the "-reach of q if there is a (possibly empty) sequence of "-transitions
leading from q to r. For example, in the example NFA above, the "-reach of state f is {a, c, d, f , g}.
Now we redefine the extended transition function δ∗ : Q × Σ∗ → 2Q , which transitions onarbitrary strings, as follows:"-reach(p)[[∗δ (p, w) :=r∈"-reach(p) q∈δ(r,a)

if w = ",δ∗ (q, x) if w = ax.

SS
If we abuse notation by writing δ(S, a) = q∈S δ(q, a) and δ∗ (S, w) = q∈S δ∗ (q, w) andS"-reach(S) = q∈S "-reach(q) for any subset of states S ⊆ Q, this definition simplifies as follows:¨∗δ (p, w) :=if w = ","-reach(p)∗δ (δ("-reach(p), a), x) if w = a x.

Finally, as usual, an NFA with "-transitions accepts a string w if and only if δ∗ (s, w) contains atleast one accepting state.
Although it may appear at first that "-transitions give us a more powerful set of machines,
NFAs with and without "-transitions are actually equivalent. Given an NFA M = (Σ, Q, s, A, δ)
with "-transitions, we can construct an equivalent NFA M 0 = (Σ, Q0 , s0 , A0 , δ0 ) without "-transitions
as follows:
Q0 := Qs0 = s
A0 = q ∈ Q "-reach(q) ∩ A 6= ∅

δ0 (q, a) = δ("-reach(q), a)

Straightforward definition-chasing now implies that M and M 0 accept exactly the same language.
Thus, whenever we reason about or design NFAs, we are free to either allow or forbid "-transitions,whichever is more convenient for the task at hand.
For example, our previous NFA with "-transitions can be transformed into an equivalent NFA
without "-transitions, as shown in the figure below. The NFA on the right has two unreachable
states a and d, but whatever.
0

a

b

0

c
ε

1,0

s

ε

ε
ε

d

1

e

ε
ε
1

0

a
g

1,0

1,0

f

s
d

b

0

c

0

0

1

1

0

1,0

g

1

e

1
1

f
1

A (rather silly) NFA with " -transitions, and an equivalent NFA without " -transitions

ÆÆÆ
4

1,0

1,0

Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]

This reduction might be easier to understand incrementally.
"aa• For every transition pair p −→ q −→ r , add a direct transition p −→ r . This addition
does not change the accepted language.
"• For each transition p −→ q where q is an accepting state, make p an accepting state.
This modification does not change the accepted language.

• When no more of the previous modifications are possible, delete all " -transitions. This
modification does not change the accepted language.

4.4

Kleene’s Theorem

We are now finally in a position to prove the following fundamental fact, first observed by Steven
Kleene in 1951:
Theorem 4.1. A language L can be described by a regular expression if and only if L is thelanguage accepted by a DFA.
We will prove Kleene’s fundamental theorem in four stages:• Every DFA can be transformed into an equivalent NFA.
• Every NFA can be transformed into an equivalent DFA.
• Every regular expression can be transformed into an equivalent NFA.
• Every NFA can be transformed into an equivalent regular expression.
The first of these four transformations is completely trivial; a DFA is just a special type of NFA
where the transition function always returns a single state. Unfortunately, the other threetransformations require a bit more work.

4.5

NFA to DFA: The Subset Construction

In the parallel-thread model of NFA execution, an NFA does not have a single current state, butrather a set of current states. The evolution of this set of states isSdetermined by a modified
transition function δ0 : 2Q × Σ → 2Q , defined by setting δ0 (P, a) := p∈P δ(p, a) for any set ofstates P ⊆ Q and any symbol a ∈ Σ. When the NFA finishes reading its input string, it accepts if
and only if the current set of states intersects the set A of accepting states.
This formulation makes the NFA completely deterministic! We have just shown that any NFA
M = (Σ, Q, s, A, δ) is equivalent to a DFA M 0 = (Σ, Q0 , s0 , A0 , δ0 ) defined as follows:
Q0 := 2Q

s0 := {s}A0 := S ⊆ Q S ∩ A 6= ∅[
δ0 (q0 , a) :=δ(p, a)for all q0 ⊆ Q and a ∈ Σ.
p∈q0

Similarly, any NFA with "-transitions is equivalent to a DFA defined as follows:
Q0 := 2Q

s0 := {s}5Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]
A0 := S ⊆ Q "-reach(S) ∩ A 6= ∅[[δ(r, a)for all q0 ⊆ Q and a ∈ Σ.
δ0 (q0 , a) :=p∈q0 r∈"-reach(p)This conversion from NFA to DFA is often called the subset construction, but that name issomewhat misleading; it’s not a “construction” so much as a change in perspective.
For example, the subset construction converts the 4-state NFA on the first page of this note
into the following 16-state DFA. To simplify notation, I’ve named each DFA state using a simple
string, omitting the braces and commas from the corresponding subset of NFA states; for example,
DFA state sbc corresponds to the subset {s, b, c} of NFA states.
1

sb
1

s

sbc

1

sc

1

sa

0

ab

0,1

1

sac
0

1

sabc

1

0

c

0

0

0

a

0

1
0

sab

bc

0

1
0

abc

1

1

0,1

Ø
1

0,1

0

b

ac

0
The 16-state DFA obtained from our first 4-state NFA by the subset construction.
Only the five yellow states are reachable from the start state.

An obvious disadvantage of this “construction” is that it (usually) leads to DFAs with far morestates than necessary, in part because many states cannot even be reached from the start state.
In the example above, there are eleven unreachable states; only five states are reachable from s.
Incremental Subset Construction
Instead of building the entire subset DFA and then discarding the unreachable states, we can avoid
the unreachable states from the beginning by constructing the DFA incrementally, essentially by
performing a breadth-first search of the DFA graph.
To execute this algorithm by hand, we prepare a table with |Σ| + 3 columns, with one row foreach DFA state we discover. In order, these columns record the following information:• The DFA state (as a subset of NFA states)• The "-reach of the corresponding subset of NFA states• Whether the DFA state is accepting (that is, whether the "-reach intersects A)• The output of the transition function for each symbol in Σ.
We start with DFA-state {s} in the first row and first column. Whenever we discover an unexploredstate in one of the last |Σ| columns, we copy it to the left column in a new row. To reduce
notational clutter, we write all subsets of NFA states without braces or commas.
For example, given the NFA with "-transitions from Section 4.3, the standard subset construction would produce a DFA with 256 states, but the incremental subset construction produces annine-state DFA, described by the following table and illustrated on the next page. We would fillin the first row, for the starting DFA state s, as follows:6Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]• The "-reach of NFA state s is {s, a, d}, so we write sad in the first column.

• None of the NFA states {s, a, d} is an accepting state, so {s} is not an accepting state of theDFA, so we do not check the second column.
• Next, δ0 ({s, a, d}, 0) = δ(s, 0) ∪ δ(a, 0) ∪ δ(d, 0) = {s} ∪ {b} ∪ ∅ = {s, b}, so we write sb
in the third column. Because sb does not already appear in the first column in any existing
row, we have discovered a new DFA state! We start a new row for DFA state sb.
• Finally, δ0 ({s, a, d}, 1) = δ(s, 1) ∪ δ(a, 1) ∪ δ(d, 1) = {s} ∪ ∅ ∪ {e} = {s, e}, so we write sein the fourth column, and we start a new row for the new DFA state se.
We now have two new rows to fill in, corresponding to states sb and se. The algorithm continues
filling in rows (and discovering new rows) until all rows are filled, ending with the following
table:
q0
s
sb
se
sbc
sef
sbcg
seg
sbg
sefg

"-reach(q0 )
sad
sabd
sade
sabcdgsacdefg
sabcdgsadeg
sabdg
sacdefg

q0 ∈ A0 ?

Ø
Ø
Ø
Ø
Ø
Ø

δ0 (q0 , 0)
sb
sbc
sb
sbcg
sbg
sbcg
sbg
sbcg
sbg

δ0 (q0 , 1)
se
se
sef
seg
sefg
seg
sefg
seg
sefg
0

sbc
0
0

a

b

0

c

sb

ε
1,0

s

ε

ε
ε

d

1

e

ε
ε
1

1

seg

0

g

1,0

s

0

1

0

1

f

sef

sefg

1

1

0
0

0

1

0

1

sbg

se

sbcg
1

1

An eight-state NFA with " -transitions, and the output of the incremental subset construction for that NFA.

Although it avoids unreachable states, the incremental subset algorithm still gives us a DFA
with far more states than necessary, intuitively because it keeps looking for 00 and 11 substrings
even after it’s already found one. After all, after the NFA finds both 00 and 11 as substrings, it
doesn’t kill all the other parallel execution threads, because it can’t. NFAs often have significantly
fewer states than equivalent DFAs, but that efficiency also makes them kind of stupid.

4.6 Regular Expression to NFA: Thompson’s Algorithm
We now turn to the core of Kleene’s theorem, which claims that regular languages (described byregular expressions) and automatic languages (accepted by finite-state automata) are the same.
7

Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]

Lemma 4.2. Every regular language is accepted by a nondeterministic finite-state automaton.
Proof: In fact, we will prove the following stronger claim: Every regular language is acceptedby an NFA with exactly one accepting state, which is different from its start state. The following
construction was first described by Ken Thompson in 1968. Thompson’s algorithm actually provesa stronger statement: For any regular language L, there is an NFA that accepts L that has exactly
one accepting state t, which is distinct from the starting state s.
Let R be an arbitrary regular expression over an arbitrary finite alphabet Σ. Assume that forany sub-expression S of R, the language described by S is accepted by an NFA with one acceptingSstate distinct from its start state, which we denote pictorially by. There are six cases
to consider—three base cases and three recursive cases—mirroring the recursive definition of aregular expression.
• If R = ∅, then L(R) = ∅ is accepted by the trivial NFA.

• If R = ", then L(R) = {"} is accepted by a different trivial NFAε.

a• If R = a for some symbol a ∈ Σ, then L(R) = {a} is accepted by the NFA. (Thecase where R is a single string with length greater than 1 reduces to the single-symbol caseby concatenation, as described in the next case.)• Suppose R = ST for some regular expressions S and T . The inductive hypothesis implies
S
T
that the languages L(S) and L(T ) are accepted by NFAs
and, respectively.
Then L(R) = L(S T ) = L(S) • L(T ) is accepted by the NFA
connecting the two component NFAs in series.

Sε, built byT• Suppose R = S + T for some regular expressions S and T . The inductive hypothesis
ST
implies that the language L(S) and L(T ) are accepted by NFAs
and,respectively. Then L(R) = L(S + T ) = L(S) ∪ L(T ) is accepted by the NFA

ε

S

ε

ε

T

ε

,

built by connecting the two component NFAs in parallel with new start and accept states.
• Finally, suppose R = S ∗ for some regular expression S. The inductive hypothesis implies thatS
the language L(S) is accepted by an NFA. Then the language L(R) = L(S ∗ ) = L(S)∗εis accepted by the NFA

ε

S

ε

.

ε

In all cases, the language L(R) is accepted by an NFA with one accepting state, which is different
from its start state, as claimed.
As an example, given the regular expression (0 + 10∗ 1)∗ of strings containing an even numberof 1s, Thompson’s algorithm produces a 14-state NFA shown on the next page. As this example
shows, Thompson’s algorithm tends to produce NFAs with many redundant states. Fortunately,
just as there are for DFAs, there are algorithms that can reduce any NFA to an equivalent NFA
with the smallest possible number of states.
Interestingly, applying the incremental subset algorithm to Thompson’s NFA tends to yielda DFA with relatively few states, in part because the states in Thompson’s NFA tend to havelarge "-reach, and in part because relatively few of those states are the targets of non-"transitions. Starting with the Thompson’s NFA for (0 + 10∗ 1)∗ , for example, the incremental
subset construction yields a DFA with just five states.
8Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]

ε
ε
1

b

c

ε

ε

d

0

e

ε
ε

s

f

ε

ε

g

1

h

i

ε

ε

a

ε

l

ε

m

ε
0

j

k

ε

The NFA constructed by Thompson’s algorithm for the regular expression (0 + 10∗ 1)∗ .
The four non-" -transitions are drawn with with bold red arrows for emphasis.

q0
s
k
c
f
i

"-reach(q0 )sabjm
sabjklmcdegh
defgh
sabjilmδ0 (q0 , 0)
k
k
f
f
k

q0 ∈ A0 ?
Ø
Ø

Ø

1
0

δ0 (q0 , 1)
c
c
i
i
c

0

c

1

f

i

1

s

1

1

0

0

k

0
The DFA computed by the incremental subset algorithm from Thompson’s NFA for (0 + 10∗ 1)∗ .

This DFA can be further simplified to just two states, by observing that all three accepting
states are equivalent, and that both non-accepting states are equivalent. But still, five states ispretty good, especially compared with the 214 = 16384 states that the naïve subset construction
would yield!

4.7

Another Example

Here is another example of all the algorithms we’ve seen so far, starting with the regularexpression (0 + 1)∗ (00 + 11)(0 + 1)∗ , which describes the language accepted by our very firstexample NFA. Thompson’s algorithm constructs the following 18-state monster:
ε

s

ε

ε

b

0

ε

c

ε

f

a
ε

d

1

e

ε

ε

g

ε

ε

i

0

ε

j

k

0

l

ε

q

h
ε

m

1

ε

n

o

1

p

ε

ε

r

ε

u

ε

0

v

ε

y

t
ε

w

ε

1

x

ε

z

ε

ε

Thompson’s NFA for the regular expression (0 + 1)∗ (00 + 11)(0 + 1)∗ ,with the " -reach of the start state s highlighted.

Given this NFA as input, the incremental subset construction computes the following table,
leading to a DFA with just nine states. Yeah, the "-reaches get a bit ridiculous; unfortunately, thisis typical for Thompson’s NFA. As usual, the resulting DFA has far more states than necessary.

9Models of Computation

q0
s
cj
en
cjl
enp
cjlv
enx
cjv
enpx

Lecture 4: Nondeterministic Automata [Sp’18]"-reach(q0 )sabdghimsabdfghijkm
sabdfghmno
sabdfghijklmqrtuwz
sabdfghmnopqrtuwz
sabdfghijklmqrtuvwyz
sabdfghmnopqrtuwxyz
sabdfghijkmrtuvwyz
sabdfghmnopqrtuwxyz0cj

q0 ∈ A0 ?

Ø
Ø
Ø
Ø
Ø
Ø

cjl

0

s

δ0 (q0 , 0)
cj
cjl
cj
cjlv
cjv
cjlv
cjv
cjlv
cjv

δ0 (q0 , 1)
en
en
enp
enx
enpx
enx
enpx
enx
enpx

0

0
0

cjv

1

1
1

0

1

0
0

1

en

enp

1

cjlv

0

enx

1

1

enpx
0

The DFA computed by the incremental subset algorithm from Thompson’s NFA for (0 + 1)∗ (00 + 11)(0 + 1)∗ .

Finally, the DFA-minimization algorithm from the previous lecture note correctly discovers
that all six accepting states of the incremental-subset DFA are equivalent, and thus reduces the
DFA to just four states.

0

0
0

1

0,1

1

1

The minimal DFA that accepts the language (0 + 1)∗ (00 + 11)(0 + 1)∗ .

?

4.8

NFA to Regular Expression: Han and Wood’s Algorithm

The only component of Kleene’s theorem left to prove is that every language accepted by an NFA
is regular. I’ll describe a relatively recent proof, due Yo-Sub Han and Derick Wood in 20052, thatis morally equivalent to Kleene’s 1951 argument, but uses more modern standard notation.
Recall that a standard NFA can be represented by a state-transition graph, whose vertices are
the states and whose edges represent possible transitions. Each edge is labeled with a single
symbol in Σ. A string w ∈ Σ∗ is accepted if and only if there is a sequence of transitions
a1

a3

a2

a`

s −→ q1 −→ q2 −→ · · · −→ q`

2Yo-Sub Han* and Derick Wood. The generalization of generalized automata: Expression automata. International
Journal of Foundations of Computer Science 16(3):499–510, 2005.

10

Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]

where the final state q` is accepting and a1 a2 · · · a` = w.
We’ve already seen that NFAs can be generalized to include "-transitions; we can push thisgeneralization further. A string NFA allows each transition pq to be labeled with an arbitrary
string x(pq) ∈ Σ∗ . We are allowed to transition from state p to state q if the label x(pq) is aprefix of the remaining input. Thus, a string w ∈ Σ∗ is accepted if and only if there is a sequenceof transitions
x1
x3
x2
x`
s −→ q1 −→ q2 −→ · · · −→ q`

where the final state q` is accepting, and x 1 • x 2 • · · · • x ` = w. Thus, an NFA with "-transitions
is just a string NFA where every label has length 0 or 1. Any string NFA can be converted into an
equivalent standard NFA, by subdividing each edge pq into a path of length |x(pq)| (unlessx(pq) = ").
Finally, Han and Wood define an expression automaton as a finite-state machine where eachtransition pq is labeled with an arbitrary regular expression R(pq). We can transition fromstate p to state q if any prefix of the remaining input matches the regular expression R(pq).
Thus, a string w ∈ Σ∗ is accepted by an expression automaton if and only if there is a sequenceof transitions
R1
R3
R2
R`
s −→ q1 −→ q2 −→ · · · −→ q`
where the final state q` is accepting, and we can write w = x 1 • x 2 • · · · • x ` = w, where each
substring x i matches the corresponding regular expression R i .
More formally, an expression automaton consists of the following components:• A finite set Σ called the input alphabet• Another finite set Q whose elements are called states• A unique start state s ∈ Q• A unique target state t ∈ Q \ {s}• A transition function R: (Q \ {t}) × (Q \ {s}) → Reg(Σ), where Reg(Σ) is the set of regularexpressions over Σ.

The requirement that the start and target states are unique and disatinct is not essential to themodel. We impose this requirement for convenience of the equivalence proof; it can be easily
enforced using "-transitions.
Expression automata are even more nondeterministic than NFAs. A single string could matchseveral (even infinitely many) transition sequences from s to t, and it could match each of
those sequences in several (even infinitely many) different ways. A string w is accepted if any
decomposition of w into a sequence of substrings matches any sequence of transitions from s to t.
Conversely, a string might match no state sequences, in which case the string is rejected.
Two extreme special cases of expression automata are already familiar. First, every regular
language is clearly the language of an expression automaton with exactly two states. Second,with only minor modifications, any DFA or NFA can be converted into an expression automatonwith trivial transition expressions. Thompson’s algorithm can be used to transform any expression
automaton into a standard NFA (with "-transitions), by recursively expanding any nontrivial
transition expression. To complete the proof of Kleene’s theorem, we show how to convert anarbitrary expression automaton into a regular expression, by repeatedly deleting vertices.
Lemma 4.3. Every expression automaton accepts a regular language.

11

Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]

Proof: Let E = (Q, Σ, R, s, t) be an arbitrary expression automaton. Assume that any expression
automaton with fewer states than E accepts a regular language. There are two cases to consider,depending on the number of states in Q:• If Q = {s, t}, then trivially, E accepts the regular language R(s t).

• On the other hand, suppose Q has more than two states; fix an arbitrary state q ∈ Q \ {s, t}.
We modify the automaton, without changing its language, so that state q is redundant andcan be removed. Define a new transition function R0 : Q × Q → Reg(Σ) by setting
R0 (p r) := R(p r) + R(pq) R(qq)∗ R(q r).

With this modified transition function in place, any string w that matches the sequencepqq · · · q r with any number of q’s also matches the single transition p r. Thus,
by induction, if w matches a sequence of states, it also matches the subsequence obtainedby removing all q’s. Let E 0 be the expression automaton with states Q0 = Q \ {q} that uses
this modified transition function R0 . This new automaton accepts exactly the same strings
as the original automaton E. Because E 0 has fewer states than E, the inductive hypothesis
implies E 0 accepts a regular language.
In both cases, we conclude that E accepts a regular language.

This proof can be mechanically translated into an algorithm to convert any DFA or NFA into
an equivalent regular expression, via a sequence of expression automata with fewer and fewer
states, but increasingly complex transition expressions.
C

q
B

p

A

C

q

D

B

r

p

D

A + BC*Dr

One step in Kleene’s/Han and Wood’s reduction algorithm.

The figure on the next page shows Han and Wood’s algorithm in action, starting with a DFA
that accepts the binary representations of non-negative integers divisible by 3, possibly with extra
leading 0s. (State i means the binary number we’ve read so far is congruent to i mod 3.) First
we convert the DFA into an expression automaton by adding a new accept state. (We don’t needto add a new start state, because there are no transitions the original start state s.) Then weremove state‘2, then state 0, and finally state 1, updating the transition expressions between
any remaining states at each iteration. For the sake of clarity, edges pq with R(pq) = ∅ areomitted from the figures. The final regular expression 00∗ + (00∗ 1 + 1)(10∗ 1 + 01∗ 0)∗ 10∗ canbe slightly simplified to 0∗ 0 + 0∗ 1(10∗ 1 + 01∗ 0)∗ 10∗ , which is precisely the regular expression
we gave for this language back in Lecture Note 2!
Given an NFA with n states (including s and t), Han and Wood’s algorithm iteratively removesn − 2 states, updating O(n2 ) transition expressions in each iteration. If the concatenation andKleene star operations could be performed in constant time, the resulting algorithm would run inO(n3 ) time. However, in the worst case, the transition expressions grows in length by roughly afactor of 4 in each iteration, so the final expression has length Θ(4n ). If we insist on representing
the expressions as explicit strings, the worst-case running time is actually Θ(4n ).
12Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]

01*0
0

1
1

0
1

s

2

1

1

1

0

0

1

0

0

1

s

1

2

0

1

1

1

0

0

ε

t

1

s

0

0

1

0

ε

t

0
01*0+10*11s00*+(00*1+1)(01*0+10*1)*10*10*t00*1+1s

00*

tConverting a DFA into an equivalent regular expression using Han and Wood’s algorithm.

4.9

Regular Language Transformations

We have already seen that many functions of regular languages are themselves regular: unions,concatenations, and Kleene closure by definition. and intersections and differences by productconstruction on DFA. However, the set of regular languages is closed under a much richer class offunctions.
Suppose we wanted to prove that regular languages are closed under some function f ; thatis, for every regular language L, we want to prove that the language f (L) is also regular. There
are two general techniques to prove such a statement:• Describe an algorithm that transforms an arbitrary regular expression R into a new regularexpression R0 such that L(R0 ) = f (L(R)).
• Describe an algorithm that transforms an arbitrary DFA M into a new NFA M 0 such thatL(M 0 ) = f (L(M )).
The equivalence between regular expressions and finite automata implies that in principle wecan always use either technique, but in practice, the second one is far more powerful and usuallysimpler. The asymmetry in the second technique is important. We start with a DFA for L to
impose as much structure as possible in the input; we aim for an NFA with "-transitions to giveourselves as much freedom as possible in the output.3
For our first example, I’ll describe proofs using both techniques.
Lemma 4.4. For any regular language L, the language L R = {wR | w ∈ L} is also regular.
Proof (regular expression to regular expression): Let R be an arbitrary regular expression
such that L = L(R). Assume for any proper subexpression S of R that L(S)R is regular. There are
five cases to consider, mirroring the recursive definition of regular expressions:• If R = ∅, then L R = L = ∅, so L(R) = L R .
• Suppose R consists of a single word w. Let R0 = wR . Then L(R0 ) = {wR } = L R .

3We could give ourselves even more freedom by constructing an expression automaton, but creativity thrives on
constraint.

13

Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]• Suppose R = A + B. The inductive hypothesis implies that there are regular expressions
A0 and B 0 such that L(A0 ) = L(A)R and L(B 0 ) = L(B)R . Let R0 = A0 + B 0 . Then L(R0 ) =L(A0 ) ∪ L(B 0 ) = L(A)R ∪ L(B)R = (L(A) ∪ L(B))R = L R .

• Suppose R = A • B. The inductive hypothesis implies that there are regular expressions
A0 and B 0 such that L(A0 ) = L(A)R and L(B 0 ) = L(B)R . Let R0 = B 0 • A0 . Then L(R0 ) =L(B 0 ) • L(A0 ) = L(B)R • L(A)R = (L(A) • L(B))R = L R .
• Finally, suppose R = A∗ . The inductive hypothesis implies that there is a regular expression A0
such that L(A0 ) = L(A)R . Let R0 = (A0 )∗ . Then L(R0 ) = L(A0 )∗ = (L(A)R )∗ = (L(A)∗ )R = L R .
In all cases, we have constructed a regular expression R0 such that L(R0 ) = L R . We conclude that
L R is regular.

Careful readers may be unsatisfied with the previous proof, because it assumes several“obvious” properties of string and language reversal. Specifically, for all strings x and y and all
languages L and L 0 , we assumed the following:• (x • y)R = y R • x R• (L · L 0 )R = (L 0 )R · L R .

• (L ∪ L 0 )R = L R ∪ (L 0 )R .
• (L ∗ )R = (L R )∗ .

All of these claims are all easy to prove by inductive definition-chasing.
Proof (DFA to NFA): Let M = (Σ, Q, s, A, δ) be an arbitrary DFA that accepts L. We construct
an NFA M R = (Σ, QR , sR , AR , δR ) with "-transitions that accepts L R , intuitively by reversing everytransition in M , and swapping the roles of the start state and the accepting states. Because
M does not have a unique accepting state, we need to introduce a special start state sR , with"-transitions to each accepting state in M . These are the only "-transitions in M R .
QR = Q ∪ {sR }AR = {s}δR (sR , ") = AδR (sR , a) = ∅for all a ∈ ΣδR (q, ") = ∅δR (q, a) = p q ∈ δ(p, a)

for all q ∈ Q

for all q ∈ Q and a ∈ ΣRoutine inductive definition-chasing now implies that the reversal of any sequence q0 q1  · · · q`of transitions in M is a valid sequence q` q`−1  · · · q0 of transitions in M R . Because thetransitions retain their labels (but reverse directions), it follows that M accepts any string w if
and only if M R accepts wR .
We conclude that the NFA M R accepts L R , so L R must be regular.

Lemma 4.5. For any regular language L, the language half(L) := {w | ww ∈ L} is also regular.

Proof: Let M = (Σ, Q, s, A, δ) be an arbitrary DFA that accepts L.
Intuitively, we construct an NFA M 0 that reads its input string w and simulates the original
DFA M reading the input string ww. Our overall strategy has three parts:
14Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]• First M 0 non-deterministically guesses the state h = δ∗ (s, w) that M will reach after reading
input w. (We can’t just run M on input w to compute the correct state h, because thatwould consume the input string!)• Then M 0 runs two copies of M in parallel (using a product construction): a “left” copy
starting at s and a “right” copy starting at the (guessed) halfway state h.
• Finally, when M 0 is done reading w, it accepts if and only if the first copy of M actually
stopped in state h (so our initial guess was correct) and the second copy of M stopped inan accepting state. That is, M 0 accepts if and only if δ∗ (s, w) = h and δ∗ (h, w) ∈ A.

To implement this strategy, M 0 needs to maintain three states of M : the state of the left copyof M , the guess h for the halfway state, and the state of the right copy of M . The first andthird states evolve according to the transition function δ, but the second state never changes.
Finally, to implement the non-deterministic guessing, M 0 includes a special start state s0 with"-transitions to every triple of the form (s, h, h).
Summing up, our new NFA M 0 = (Σ, Q0 , s0 , A0 , δ0 ) is formally defined as follows.
Q0 = (Q × Q × Q) ∪ {s0 }
A0 = (h, h, q) h ∈ Q and q ∈ Aδ0 (s0 , ") = (s, h, h) h ∈ Q

δ0 (s0 , a) = ∅δ0 ((p, h, q), ") = ∅δ0 ((p, h, q), a) = (δ(p, a), h, δ(q, a))for all a ∈ Σ

for all p, h, q ∈ Q

for all p, h, q ∈ Q and a ∈ ΣExercises
1. For each of the following regular expressions, describe or draw two finite-state machines:• An NFA that accepts the same language, constructed using Thompson’s algorithm.
• An equivalent DFA, built from the previous NFA using the incremental subset construction. For each state in your DFA, identify the corresponding subset of states inyour NFA. Your DFA should have no unreachable states.
(a) (01 + 10)∗ (0 + 1 + ")(b) (" + 1)(01)∗ (" + 0)(c) 1∗ + (10)∗ + (100)∗(d) (" + 0 + 00)(1 + 10 + 100)∗(e) ((0 + 1)(0 + 1))∗(f) " + 0(0 + 1)∗ + 1(1 + 0)∗

2. The accepting language of an NFA M = (Σ, Q, s, A, δ) is defined as follows:L(M ) := w ∈ Σ∗ δ∗ (s, w) ∩ A 6= ∅ .

Kleene’s theorem (described here as Han and Wood’s algorithm) implies that L(M ) isregular. Prove that the following languages associated with M are also regular:
15

Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]

(a) L∀ (M ) := w ∈ Σ∗ A ⊆ δ∗ (s, w) . That is, a string w is in the language L∀ (M ) if andonly if δ∗ (s, w) contains every accepting states.
(b) L ⊆ (M ) := w ∈ Σ∗ δ∗ (s, w) ⊆ A . That is, a string w is in the language L ⊆ (M ) if
and only if δ∗ (s, w) contains only accepting states.
(c) L ≡ (M ) := w ∈ Σ∗ δ∗ (s, w) = A . That is, a string w is in the language L = (M ) if
and only if δ∗ (s, w) is exactly the set of accepting states.
3. A certain professor who really should know better once woke up in the middle of the nightwith a startling revelation—Thompson’s algorithm doesn’t need all those "-transitions!
Filled with the certainty that only sleep deprivation can bring, he ran to his laptop andquickly changed two cases in his description of Thompson’s algorithm.
S• When R = S • T , instead of connecting the accept state ofto the start stateTofwith an "-transition, we can just identify those two states to build theSTsimpler NFA!

• When R = S ∗ , instead of introducing two new states and four "-transitions, we canSjust add two "-transitions between the start and accept states of
to build theεsimpler NFA

S

!

ε

Satisfied with his simplification, he thanked the penguin who gave him the idea, andthen flew his hat back into the ocean marshmallows, where a giant man with the head of adog gave him the power of bread. The next morning, while he was proudly teaching his
new simplified proof for the first time, he realized his horrible mistake.
Prove that neither of the professor’s optimizations is actually correct.
(a) Find a regular expression R, such that the NFA constructed from R by Thompson’salgorithm with only the first modification accepts strings that are not in L(R).
(b) Find a regular expression R, such that the NFA constructed from R by Thompson’salgorithm with only the second modification accepts strings that are not in L(R).
4. A Moore machine is a variant of a finite-state automaton that produces output; Moore
machines are sometimes called finite-state transducers. For purposes of this problem, aMoore machine formally consists of six components:• A finite set Σ called the input alphabet• A finite set Γ called the output alphabet• A finite set Q whose elements are called states• A start state s ∈ Q• A transition function δ : Q × Σ → Q• An output function ω: Q → Γ

16Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]

More intuitively, a Moore machine is a graph with a special start vertex, where every node(state) has one outgoing edge labeled with each symbol from the input alphabet, and eachnode (state) is additionally labeled with a symbol from the output alphabet.
The Moore machine reads an input string w ∈ Σ∗ one symbol at a time. For eachsymbol, the machine changes its state according to the transition function δ, and thenoutputs the symbol ω(q), where q is the new state. Formally, we recursively define atransducer function ω∗ : Σ∗ × Q → Γ ∗ as follows:¨"
if w = "ω∗ (w, q) =∗ω(δ(a, q)) · ω (x, δ(a, q)) if w = ax

Given the input string w ∈ Σ∗ , the machine outputs the string ω∗ (w, s) ∈ Γ ∗ . To simplify
notation, we define M (w) = ω∗ (w, s).
Finally, the output language L◦ (M) of a Moore machine M is the set of all strings thatthe machine can output:L ◦ (M ) := M (w) w ∈ Σ∗(a) Let M be an arbitrary Moore machine. Prove that L ◦ (M ) is a regular language.
(b) Let M be an arbitrary Moore machine whose input alphabet Σ and output alphabet Γ
are identical. Prove that the language
L = (M ) = w ∈ Σ∗ M (w) = w? (c)is regular. Strings in L = (M ) are also called fixed points of the function M : Σ∗ → Σ∗ .
As in part (b), let M be an arbitrary Moore
 machine whose input and output alphabets
are identical. Prove that the language w ∈ Σ∗ M (M (w)) = w is regular.

[Hint: Parts (a) and (b) are easier than they look!]
5. A Mealy machine is a variant of a finite-state automaton that produces output; Mealy
machines are sometimes called finite-state transducers. For purposes of this problem, aMealy machine formally consists of six components:• A finite set Σ called the input alphabet• A finite set Γ called the output alphabet• A finite set Q whose elements are called states• A start state s ∈ Q• A transition function δ : Q × Σ → Q• An output function ω: Q × Σ → Γ

More intuitively, a Mealy machine is a graph with a special start vertex, where every node(state) has one outgoing edge labeled with each symbol from the input alphabet, andeach edge (transition) is additionally labeled with a symbol from the output alphabet.
(Mealy machines are closely related to Moore machines, which produce output at eachstate instead of at each transition.)17

Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]

The Mealy machine reads an input string w ∈ Σ∗ one symbol at a time. For each symbol,
the machine changes its state according to the transition function δ, and simultaneously
outputs a symbol according the output function ω. Formally, we recursively define atransducer function ω∗ : Q × Σ∗ → Γ ∗ as follows:¨"
if w = "∗ω (q, w) =∗ω(q, a) · ω (δ(q, a), x) if w = a x

Given any input string w ∈ Σ∗ , the machine outputs the string ω∗ (w, s) ∈ Γ ∗ . To simplify
notation, we define M (w) = ω∗ (w, s).
Finally, the output language L◦ (M) of a Mealy machine M is the set of all strings thatthe machine can output:
L ◦ (M ) := {M (w) | w ∈ Σ∗ }(a) Let M be an arbitrary Mealy machine. Prove that L ◦ (M ) is a regular language.
(b) Let M be an arbitrary Mealy machine whose input alphabet Σ and output alphabet Γ
are identical. Prove that the language
L = (M ) = {w ∈ Σ∗ | w = ω∗ (s, w)}

is regular. L = (M ) consists of all strings w such that M outputs w when given input w;
these are also called fixed points for the transducer function ω∗ .
? (c)As in part (b), let M be an arbitrary Mealy
 machine whose input and output alphabets
are identical. Prove that the language w ∈ Σ∗ M (M (w)) = w is regular.

[Hint: Parts (a) and (b) are easier than they look!]
6. Let L ⊆ Σ∗ be an arbitrary regular language. Prove that the following languages are regular.
Assume # ∈ Σ.
(a) censor(L) := #|w| w ∈ L(b) dehash(L) = dehash(w) w ∈ L , where dehash(w) is the subsequence of w obtainedby deleting every #.
(c) insert#(L) := x # y x y ∈ L .
(d) delete#(L) := x y x # y ∈ L .
(e) prefix(L) := {x ∈ Σ∗ | x y ∈ L for some y ∈ Σ∗ }(f) suffix(L) := { y ∈ Σ∗ | x y ∈ L for some x ∈ Σ∗ }(g) substring(L) := { y ∈ Σ∗ | x yz ∈ L for some x, z ∈ Σ∗ }(h) superstring(L) := {x yz | y ∈ L and x, z ∈ Σ∗ }(i) cycle(L) := {x y | x, y ∈ Σ∗ and y x ∈ L}(j) prefmax(L) := {x ∈ L | x y ∈ L ⇐⇒ y = "}.

(k) sufmin(L) := {x y ∈ L | y ∈ L ⇐⇒ x = "}.
18

Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18](l) minimal(L) := {w ∈ L | no proper substring of w is in L}.

(m) maximal(L) := {w ∈ L | no proper superstring of w is in L}.

(n) evens(L) := {evens(w) | w ∈ L}, where even(w) is the subsequence of w containing
every even-indexed symbol. For example, evens(EVENINDEX) = VNNE.
(o) evens−1 (L) := {w ∈ Σ∗ | evens(w) ∈ L}.

(p) subseq(L) := {x ∈ Σ∗ | x is a subsequence of some y ∈ L}(q) superseq(L) := {x ∈ Σ∗ | some y ∈ L is a subsequence of x}(r) swap(L) := {swap(w) | w ∈ L}, where swap(w) is defined recursively as follows:¨w
if |w| ≤ 1
swap(w) =ba • swap(x) if w = ab x for some a, b ∈ Σ and x ∈ Σ∗(s) oneswap(L) := xbay xaby ∈ L where a, b ∈ Σ and x, y ∈ Σ∗ .
(t) left(L) := {x ∈ Σ∗ | x y ∈ L for some y ∈ Σ∗ where |x| = | y|}(u) right(L) := { y ∈ Σ∗ | x y ∈ L for some x ∈ Σ∗ where |x| = | y|}(v) middle(L) := { y ∈ Σ∗ | x yz ∈ L for some x, z ∈ Σ∗ where |x| = | y| = |z|}(w) halfseq(L) := {w ∈ Σ∗ | w is a subsequence of some string x ∈ L where |x| = 2 · |w|}(x) third(L) := {w ∈ Σ∗ | www ∈ L}(y) palin(L) := w ∈ Σ∗ wwR ∈ L(z) drome(L) := w ∈ Σ∗ wR w ∈ L

7. Let L and L 0 be arbitrary regular languages over the alphabet {0, 1}. Prove that thefollowing languages are also regular:(a) L u L 0 := x u y x ∈ L and y ∈ L 0 and |x| = | y| , where x u y denotes bitwise-and.
For example, 0011 u 0101 = 0001.
(b) L t L 0 := x t y x ∈ L and y ∈ L 0 with |x| = | y| , where x t y denotes bitwise-or.
For example, 0011 t 0101 = 0111.
(c) L  L 0 := x  y x ∈ L and y ∈ L 0 with |x| = | y| , where x  y denotes bitwiseexclusive-or. For example, 0011  0101 = 0110.
(d) faro(L, L 0 ) := faro(x, z) x ∈ L and z ∈ L 0 with |x| = |z| , where¨

faro(x, z) :=z

if x = "a · faro(z, y) if x = a y

For example, faro(0011, 0101) = 00011011.
S(e) shuffles(L, L 0 ) := w∈L, y∈L 0 shuffles(w, y), where shuffles(w, y) is the set of all strings
obtained by shuffling w and y, or equivalently, all strings in which w and y are19Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18]

complementary subsequences. Formally:


{ y}
shuffles(w, y) =if w = "{w}
if y = "{a} • shuffles(x, y) ∪ {b} • shuffles(w, z) if w = ax and y = bz

For example, shuffles(01, 10) = {0101, 0110, 1001, 1010} and shuffles(00, 11) ={0011, 0101, 1001, 0110, 1010, 1100}.
8. (a) Let inc: {0, 1}∗ → {0, 1}∗ denote the increment function, which transforms the binary
representation of an arbitrary integer n into the binary representation of n + 1,
truncated to the same number of bits. For example:inc(0010) = 0011

inc(0111) = 1000inc(1111) = 0000

inc(") = "Let L ⊆ {0, 1}∗ be an arbitrary regular language. Prove that inc(L) = {inc(w) | w ∈ L}
is also regular.
(b) Let dbl: {0, 1}∗ → {0, 1}∗ denote the doubling function, which transforms the binary
representation of an arbitrary integer n into the binary representation of 2n, truncatedto the same number of bits. For example:
dbl(0010) = 0100

dbl(0111) = 1110

dbl(1111) = 1110

dbl(") = "Let L ⊆ {0, 1}∗ be an arbitrary regular language. Prove that dbl(L) = {dbl(w) | w ∈ L}
is also regular.
? (c)Let tpl: {0, 1}∗ → {0, 1}∗ denote the tripling function, which transforms the binary
representation of an arbitrary integer n into the binary representation of 3n, truncatedto the same number of bits. For example:
tpl(0010) = 0110

tpl(0111) = 0101

tpl(1111) = 1101

tpl(") = "Let L ⊆ {0, 1}∗ be an arbitrary regular language. Prove that tpl(L) = {tpl(w) | w ∈ L}
is also regular. [Hint: It may be easier to consider the language tpl(L R )R first.]? 9.

Let L ⊆ Σ∗ be an arbitrary regular language. Prove that the following languages are
regular.
(a) sqrt(L) := x ∈ Σ∗ x y ∈ L for some y ∈ Σ∗ such that | y| = |x|2
(b) log(L) := x ∈ Σ∗ x y ∈ L for some y ∈ Σ∗ such that | y| = 2|x|(c) flog(L) := x ∈ Σ∗ x y ∈ L for some y ∈ Σ∗ such that | y| = F|x| , where Fn is thenth Fibonacci number.

? 10.

Let L ⊆ Σ∗ be an arbitrary regular language. Prove that the following languages are
regular.
(a) somerep(L) := {w ∈ Σ∗ | wn ∈ L for some n ≥ 0}20

Models of Computation

Lecture 4: Nondeterministic Automata [Sp’18](b) allreps(L) := {w ∈ Σ∗ | wn ∈ L for every n ≥ 0}(c) manyreps(L) := {w ∈ Σ∗ | wn ∈ L for infinitely many n ≥ 0}(d) fewreps(L) := {w ∈ Σ∗ | wn ∈ L for finitely many n ≥ 0}n(e) powers(L) := w ∈ Σ∗ w2 ∈ L for some n ≥ 0Æ(f) whattheN (L) := {w ∈ Σ∗ | wn ∈ L for some n ∈ N }, where N is an arbitrary fixed setof non-negative integers. [Hint: You only have to prove that an accepting NFA exists;
you don’t have to describe how to construct it.]

[Hint: For each of these languages, there is an accepting NFA with at most qq states,
where q is the number of states in some DFA that accepts L.]? 11.

For any string w ∈ (0 + 1)∗ , let 〈w〉2 denote the integer represented by w in binary. For
example:〈"〉2 = 0〈0010〉2 = 2〈0111〉2 = 7〈1111〉2 = 15

Let L and L 0 be arbitrary regular languages over the alphabet {0, 1}. Prove that thefollowing language is also regular:w ∈ (0 + 1)∗ 〈w〉2 = 〈x〉2 + 〈 y〉2 for some strings x ∈ L and y ∈ L 0
Æ

12. Let L ⊆ Σ∗ be an arbitrary regular language. Prove that the following languages are
regular.
(a) repsqrt(L) = w ∈ Σ∗ w|w| ∈ L .
|w|(b) replog(L) = w ∈ Σ∗ w2 ∈ L .
(c) repflog(L) = w ∈ Σ∗ w F|w| ∈ L , where Fn is the nth Fibonacci number.

[Hint: The NFAs for these languages use a LOT of states. Let M = (Σ, Q, s, A, δ) be a DFA
that accepts L. Imagine that you somehow know δ∗ (q, w) in advance, for every state q ∈ Q.
Ha, ha, ha! Mine is an evil laugh!]21

Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

The product of mental labor — science — always stands far below its value, because thelabor-time necessary to reproduce it has no relation at all to the labor-time required for its
original production. For example, a schoolboy can learn the binomial theorem in an hour.
— Karl Marx, Theories of Surplus Value (1863)
Imagine a piano keyboard, eh, 88 keys, only 88 and yet, and yet, hundreds of new melodies,
new tunes, new harmonies are being composed upon hundreds of different keyboards every
day in Dorset alone. Our language, tiger, our language: Hundreds of thousands of available
words, frillions of legitimate new ideas, so that I can say the following sentence and beutterly sure that nobody has ever said it before in the history of human communication:“Hold the newsreader’s nose squarely, waiter, or friendly milk will countermand
my trousers.” Perfectly ordinary words, but never before put in that precise order. A uniquechild delivered of a unique mother.
— Stephen Fry, A Bit of Fry and Laurie, Series 1, Episode 3 (1989)

5 Context-Free Languages and Grammars
5.1

Definitions

Intuitively, a language is regular if it can be built from individual strings by concatenation, union,
and repetition. In this note, we consider a wider class of context-free languages, which arelanguages that can be built from individual strings by concatenation, union, and recursion.
Formally, a language is context-free if and only if it has a certain type of recursive description
known as a context-free grammar, which is a structure with the following components:• A finite set Σ, whose elements are called symbols or terminals.
• A finite set Γ disjoint from Σ, whose elements are called non-terminals.
• A finite set R of production rules of the form A → w, where A ∈ Γ is a non-terminal andw ∈ (Σ ∪ Γ )∗ is a string of symbols and variables.

• A starting non-terminal, typically denoted S.

For example, the following eight production rules describe a context free grammar with terminals
Σ = {0, 1} and non-terminals Γ = {S, A, B, C}:
S→A

S→B

A → 0AB → B1A → 0C

B → C1C →"C → 0C 1

Normally we write grammars more compactly by combining the right sides of all rules foreach non-terminal into one list, with alternatives separated by vertical bars.1 For example, theprevious grammar can be written more compactly as follows:
S →A| BA → 0A | 0C

B → B1 | C 1

C → " | 0C 1

1Yes, this means we now have three symbols ∪, +, and | with exactly the same meaning. Sigh.
© Copyright 2018 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms/ for the most recent revision.

1Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

For the rest of this lecture, I will almost always use the following notational conventions.
• Monospaced digits (0, 1, 2, . . . ), and symbols (, $, #, •, . . . ) are explicit terminals.
• Early lower-case Latin letters (a, b, c, . . . ) represent unknown or arbitrary terminals in Σ.
• Upper-case Latin letters (A, B, C, . . . ) and the letter S represent non-terminals in Γ .
• Late lower-case Latin letters (. . . , w, x, y, z) represent strings in (Σ ∪ Γ )∗ , whose characters
could be either terminals or non-terminals.
We can apply a production rule to a string in (Σ ∪ Γ )∗ by replacing any instance of the
non-terminal on the left of the rule with the string on the right. More formally, for any strings
x, y, z ∈ (Σ ∪ Γ )∗ and any non-terminal A ∈ Γ , applying the production rule A → y to the stringxAz yields the string x yz. We use the notation x Az
x y z to describe this application. For
example, we can apply the rule C → 0C 1 to the string 00C 1BAC 0 in two different ways:

00 C 1BAC 0

00 0C 1 1BAC 0

00C 1BA C 0

00C 1BA 0C 1 0

More generally, for any strings x, z ∈ (Σ ∪ Γ )∗ , we say that z derives from x , written x ∗ z,
if we can transform x into z by applying a finite sequence of production rules, or more formally,
if either• x = z, or• xy and y∗z for some string y ∈ (Σ ∪ Γ )∗ .

Straightforward definition-chasing implies that, for any strings w, x, y, z ∈ (Σ ∪ Γ )∗ , if x ∗ y,then wxz ∗ w yz.
The language L(w ) of any string w ∈ (Σ ∪ Γ )∗ is the set of all strings in Σ∗ that derive from w:
L(w) := {x ∈ Σ∗ | w

∗

x} .

The language generated by a context-free grammar G, denoted L(G), is the language of its
starting non-terminal. Finally, a language is context-free if it is generated by some context-freegrammar.
Context-free grammars are sometimes used to model natural languages. In this context, thesymbols are words, and the strings in the languages are sentences. For example, the following
grammar describes a simple subset of English sentences. (Here I diverge from the usual notation
conventions. Strings in 〈angle brackets〉 are non-terminals, and regular strings are terminals.)〈sentence〉 → 〈noun phrase〉〈verb phrase〉〈noun phrase〉〈noun phrase〉 → 〈adjective phrase〉〈noun〉〈adj. phrase〉 → 〈article〉 | 〈possessive〉 | 〈adjective phrase〉〈adjective〉〈verb phrase〉 → 〈verb〉 | 〈adverb〉〈verb phrase〉〈noun〉 → dog | trousers | daughter | nose | homework | time lord | pony | · · ·〈article〉 → the | a | some | every | that | · · ·〈possessive〉 → 〈noun phrase〉’s | my | your | his | her | · · ·〈adjective〉 → friendly | furious | moist | green | severed | timey-wimey | little | · · ·〈verb〉 → ate | found | wrote | killed | mangled | saved | invented | broke | · · ·〈adverb〉 → squarely | incompetently | barely | sort of | awkwardly | totally | · · ·2Models of Computation

5.2

Lecture 5: Context-Free Languages and Grammars [Sp’18]

Parse Trees

It is often useful to visualize derivations of strings in L(G) using a parse tree. The parse tree fora string w ∈ L(G) is a rooted ordered tree where• Each leaf is labeled with a terminal or the empty string ". Concatenating these in orderfrom left to right yields the string w.
• Each internal node is labeled with a non-terminal. In particular, the root is labeled withthe start non-terminal S.
• For each internal node v, there is a production rule A → ω where A is the label of v andthe symbols in ω are the labels of the children of v in order from left to right.

In other words, the production rules of the grammar describe template trees that can beassembled into larger parse trees. For example, the simple grammar on the previous page has
the following templates, one for each production rule:
S

S

A

A

B

A

B

0 A

0 C

B 1

B
C

1

C

C

"

0 C

1

The same grammar gives us the following parse tree for the string 000011:
S
A

0

A

0

C

0

1

C

0 C 1
"

Our more complicated “English” grammar gives us parse trees like the following:〈sentence〉〈noun phrase〉〈adj. phrase〉〈adj. phrase〉〈adj. phrase〉 〈adjective〉〈posessive〉〈noun phrase〉〈verb phrase〉〈noun〉 〈adverb〉 〈verb phrase〉〈adjective〉 time lord barely
green〈posessive〉 trousers〈verb〉
mangledfurious〈adj. phrase〉 〈noun〉〈noun phrase〉 ’s〈adj. phrase〉 〈noun〉

your〈possessive〉

dog

my

Any parse tree that contains at least one node with more than one non-terminal child corresponds
to several different derivations. For example, when deriving an “English” sentence, we have a
choice of whether to expand the first 〈noun phrase〉 (“your furious green time lord”) before orafter the second (“my dog’s trousers”).
3Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

A string w is ambiguous with respect to a grammar if there is more than one parse tree for w,
and a grammar G is ambiguous is some string is ambiguous with respect to G. Neither of theprevious example grammars is ambiguous. However, the grammar S → 1 | S +S is ambiguous,
because the string 1+1+1+1 has five different parse trees:
S
S
S

+ S

S + S

1

1

S

+ S

S

1

S +

S

1

S + S

1

+ S

1

S

S

1
1

+

S

S +

S

S + S

S + S

1

1

1

S

S

+ S

S + S

1

1

1

S +

S

1

1

1

S
S +

S

1

S + S

1

1

A context-free language L is inherently ambiguous if every context-free grammar thatgenerates L is ambiguous. The language generated by the previous grammar (the regular
language (1+)∗ 1) is not inherently ambiguous, because the unambiguous grammar S → 1 | 1+S
generates the same language.

5.3

From Grammar to Language

Let’s figure out the language generated by our first example grammar
S →A| BA → 0A | 0C

B → B1 | C 1

C → " | 0 C 1.

Since the production rules for non-terminal C do not refer to any other non-terminal, let’s begin
by figuring out L(C). After playing around with the smaller grammar C → " | 0C 1 for a few
seconds, you can probably guess that its language is {", 01, 0011, 000111, . . .}, that is, theset all of strings of the form 0n 1n for some integer n. For example, we can derive the string
00001111 from the start non-terminal S using the following derivation:
C

0C 1

00C 11000C 111

0000C 1111

0000" 1111 = 00001111

The same derivation can be viewed as the following parse tree:
C

0

1

C

0

1

C

0

1

C

0

C

1

"

In fact, it is not hard to prove by induction that L(C) = {0n 1n | n ≥ 0} as follows. As usual when
we prove that two sets X and Y are equal, the proof has two stages: one stage to prove X ⊆ Y ,the other to prove Y ⊆ X .
Lemma 5.1. C∗

0n 1n for every non-negative integer n.

Proof: Fix an arbitrary non-negative integer n. Assume that C
integer k < n. There are two cases to consider.
4∗0k 1k for every non-negativeModels of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]• If n = 0, then 0n 1n = ". The rule C → " implies that C" and therefore C• Suppose n > 0. The inductive hypothesis implies that C
C → 0C 1 implies that C
0C 1 ∗ 0(0n−1 1n−1 )1 = 0n 1n .

In both cases, we conclude that that C

∗

∗

∗

".

0n−1 1n−1 . Thus, the rule0n 1n , as claimed.

Lemma 5.2. For every string w ∈ L(C), we have w = 0n 1n for some non-negative integer n.
Proof: Fix an arbitrary string w ∈ L(C). Assume that for any string x ∈ L(C) such that |x| < |w|,
we have x = 0k 1k for some non-negative integer k. There are two cases to consider, one for eachproduction rule.
• If w = ", then w = 00 10 .
• Otherwise, w = 0 x 1 for some string x ∈ L(C). Because |x| = |w| − 2 < |w|, the inductive
hypothesis implies that x = 0k 1k for some integer k. Then we have w = 0k+1 1k+1 .
In both cases, we conclude that w = 0n 1n for some non-negative integer n, as claimed.

The first proof uses induction on strings, following the boilerplate proposed in the very firstlecture; in particular, the case analysis mirrors the recursive definition of “string”. The second
proof uses structural induction on the parse tree of the string 0n 1n ; the case analysis mirrors
the recursive definition of the language of S, as described by the production rules. In bothproofs, as in every proof by induction, the inductive hypothesis is “Assume there is no smaller
counterexample.”
Similar analysis implies that L(A) = {0m 1n | m > n} and L(B) = {0m 1n | m < n}, andtherefore L(S) = {0m 1n | m 6= n}.
5.3.1

Careful With Those Epsilons

There is an important subtlety in the proof of Lemma 5.2. The proof is written as induction on
the length of the string w; unfortunately, this induction pattern does not work for all context-freegrammars. Consider the following ambiguous grammar
S → " | SS | 0S 1 | 1S 0.

A bit of experimentation should convince you that L(S) is the language of all binary strings withthe same number of 0s and 1s. We cannot use the string-induction boilerplate for this grammar,
because there are arbitrarily long2 derivations of the form
S

SS

S

SS

S

SS

SS

···

w,

which alternately apply the productions S → SS and S → ". Specifically, even if we knew that
our arbitrary string w can be written as x y for some strings x, y ∈ L(S), we cannot guaranteethat |x| < |w| and | y| < |w|, to we cannot apply the standard string-induction hypothesis.
However, we can still argue inductively about this grammar, by considering a minimum-length
derivation of w, and basing the case analysis on the first production in this derivation. Here’s
an example of this induction boilerplate in action, with the modified boilerplate language
highlighted.
2but not infinite; derivations are finite by definition!

5Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

Lemma 5.3. For every string w ∈ L(S), we have #(0, w) = #(1, w).
Proof: Let w be an arbitrary string in L(S). Fix an minimum-length derivation of w.
Assume that for any string x ∈ L(S) that is shorter than w, we have x = 0k 1k for some
non-negative integer k. There are four cases to consider, depending on the first production in our
fixed derivation.
• Suppose the first production is S → ". Then w = " and therefore #(0, w) = #(1, w) = 0 by
definition.
• Suppose the first production is S → SS. Then w = x y for some strings x, y ∈ L(S). Bothx and y must be non-empty; otherwise, we could shorten our derivation of w. Thus,
both x and y are shorter than w. The inductive hypothesis implies #(0, x) = #(1, x) and#(0, y) = #(1, y), so #(0, w) = #(0, x) + #(0, y) = #(1, x) + #(1, y) = #(1, w).
• Suppose the first production is S → 0S 1. Then w = 0 x 1 for some string x ∈ L(S). The
inductive hypothesis implies #(0, x) = #(1, x) so #(0, w) = #(0, x) + 1 = #(1, x) + 1 =#(1, w).
• Finally, suppose the first production is S → 1S 0. Then w = 1 x 0 for some string x ∈ L(S).
The inductive hypothesis implies #(0, x) = #(1, x) so #(0, w) = #(0, x) + 1 = #(1, w) +1 = #(1, w).
In all cases, we conclude that #(0, w) = #(1, w), as claimed.



Another (more traditional) way to handle this issue is to fix an arbitrary derivation, and theninduct on the length of the derivation, rather than the length of the string itself. The case analysis
is still based on the first production in the chosen derivation.
In fact, this subtlety only matters for grammars that either contain a nullable non-terminal A
such that A ∗ " or equivalent nonterminals A and B such that A ∗ B and B ∗ A. We describe
algorithms to identify these pathologies and remove them from the grammar (without changing
its language) in Section 5.9 below.
5.3.2

Mutual Induction

Another pitfall in induction proofs for context-free languages is that non-terminals may invoke
each other. Consider, for example, the grammar
S → 0A1 | "A → 1S 0 | "Because each non-terminal appears on the right side of a production rule for the other, we mustargue about L(S) and L(A) simultaneously.
Lemma 5.4. L(S) = (01)∗ .
Proof: We actually prove simultaneously that L(S) = (01)∗ and L(A) = (10)∗ .
First, we claim that for any non-negative integer n, we have (01)n ∈ L(S) and (10)n ∈ L(A).
Let n be an arbitrary non-negative integer, and assume, for all non-negative integers m < n, that(01)m ∈ L(S) and (10)m ∈ L(A). There are two cases to consider.
• If n = 0, the production rules S → " and A → " immediately imply S
A " = (10)n .
6" = (01)n andModels of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]• Suppose n > 0. We easily observe that (01)n = 0(10)n−1 1, so the production rule S → 0A1
and inductive hypothesis imply S
0A1 ∗ (01)n . Symmetrically, (10)n = 1(01)n−1 0, so
the production rule A → 1S 0 and the inductive hypothesis implies A 1S 0 ∗ (10)n .

Next we claim that for every string w ∈ L(S), we have w = (01)n for some non-negative
integer n, and for every string w ∈ L(A), we have w = (10)n for some non-negative integer n.
The proof requires two stages.
• Let w be an arbitrary string in L(S), and assume for all x ∈ L(A) such that |x| < |w| thatx = (10)n for some non-negative integer n. There are two cases to consider.
– If w = ", then w = (01)0 .
– Suppose w = 0 x 1 for some string x ∈ L(A). The inductive hypothesis implies
x = (10)n for some non-negative integer n. It follows that w = 0(10)n 1 = (01)n+1 .
• Let w be an arbitrary string in L(A), and assume for all x ∈ L(S) such that |x| < |w| thatx = (01)n for some non-negative integer n. There are two cases to consider.
– If w = ", then w = (10)0 .
– Suppose w = 1 x 0 for some string x ∈ L(S). The inductive hypothesis implies
x = (01)n for some non-negative integer n. It follows that w = 1(01)n 0 = (10)n+1 .
Together these two claims imply L(S) = (01)∗ and L(A) = (10)∗ , as required.

5.4

More Examples

Here are some more examples of context-free languages and grammars that generate them,along with brief sketches of correctness proofs.
• Palindromes in {0, 1}∗ :S → 0S 0 | 1S 1 | 0 | 1 | "This grammar is a straightforward translation of the recursive definition of palindrome.
• Strings in (0 + 1)∗ that are not palindromes.
S → 0S 0 | 1S 1 | 0 Z 1 | 1 Z 0

Z → " | 0Z | 1Z

A string w is a non-palindrome if and only if w = x 0z 1 x R or w = x 1z 0 x R for some(possibly empty) strings x and y.
• Strings in {0, 1}∗ with the same number of 0s and 1s:

S → 0S 1 | 1S 0 | SS | "A non-empty string w has the same number of 0s and 1s if and only one of the following
conditions holds:– We can write w = x y for some non-empty strings x and y such that #(0, x) = #(1, x)
and #(0, y) = #(1, y).
7Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]– #(0, x) > #(1, x) for every non-empty proper prefix x of w. In this case, w = 0z 1
for some string z with #(0, z) = #(1, z).
– #(0, x) < #(1, x) for every non-empty proper prefix x of w. In this case, w = 1z 0
for some string z with #(0, z) = #(1, z).
• Strings in {0, 1}∗ with the same number of 0s and 1s, again:
S → 0S 1S | 1S 0S | "Let w be any non-empty string such that #(0, w) = #(1, w), let x be the shortest non-empty
prefix of w such that #(0, x) = #(1, x), and let y be the complementary suffix of w, so
w = x y. It is not hard to prove that x begins and ends with different symbols, so either
w = 0z 1 y or w = 1z 0 y, where #(0, y) = #(1, y) and #(0, z) = #(1, z).
• Strings in {0, 1}∗ in which the number of 0s is greater than or equal to the number of 1s:
S → 0S 1 | 0S | 1S 0 | S 0 | SS | "S → 0S 1S | 0SS | 1S 0S | S 0S | "We have to different grammars, each constructed from a grammar for strings with equal 0s
and 1s by either dropping the 1 or keeping the 1 from the right side of each production rule
containing a 1. For example, we split the production rule S → 0S 1 in the first grammar
into two production rules S → 0S 1 and S → 0S.
If we add the trivial production S → 0 to the first grammar, we can remove two
redundant productions to get the simpler grammar
S → 0S 1 | 1S 0 | SS | 0 | "• Strings in {0, 1}∗ with different numbers of 0s and 1s:
S→O|I(different)

I → E1I | E1E(more 1s)

O → E 0O | E 0 E(more 0s)

E → 0E1E | 1E0E | "(equal)We can argue correctness by considering each non-terminal in turn, in reverse order.
– E generates all strings with the same number of 0s and 1s, as in the previous example.
– I generates all strings with more 1s than 0s. Any such string can be decomposed into
its longest prefix with the same number of 0s and 1s (E), followed by a 0, followed
by a suffix with at least as many 0s as 1s (I or E).
– Symmetrically, O generates all strings with more 0s than 1s.
– Finally, S generates all strings with different numbers of 0s and 1s. Any such string
either has more 0s (O) or more 1s (I)• Balanced strings of parentheses:
S → (S ) | SS | "orS → (S )S | "Here we have two grammars for the same language. The first one uses simpler productions,and is a bit closer to the natural recursive definition. However, the first grammar is8Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

ambiguous — consider the string ()()() — while the second grammar is not. The second
grammar decomposes any balanced string of parentheses into its shortest non-empty
balanced prefix, which must start with ( and end with ), and the remaining suffix, whichmust be balanced.
• Unbalanced strings of parentheses—the complement of the previous language:
S → L | RX(unbalanced)

L → E( L | E(E(more left parens)

R → E )R | E ) E(more right parens)

E → " | (E)E | )E(E(equal left and right)

X → " | (X | )X

(anything)A string w of parens is balanced if and only if both (a) w has the same number of left andright parens and (b) no prefix of w has more right parens than left parens. (Proving thisfact is a good homework exercise.) Thus, a string w of parens is unbalanced if and only ifeither w has more left parens than right parens or some prefix of w has more right parens
than left parens.
• Arithmetic expressions, possibly with redundant parentheses, over the variables X and Y:
E → E+T | T(expressions)

T → T×F | F(terms)F → (E) | X | Y(factors)

Every Eexpression is a sum of T erms, every T erm is a product of F actors, and every F actor
is either a variable or a parenthesized Eexpression.
• Regular expressions over the alphabet {0, 1} without redundant parentheses
S → T | T +S

(Regular expressions)

F → Ø | W | ( T +S ) | X * | (Y )*(Factors = concatenable expressions)

T → F | FT

(Terms = summable expressions)

X →Ø|3|0|1(Directly starrable expressions)

Y → T +S | F • T | X * | (Y )* | Z Z(Starrable expressions needing parens)

Z → 0 | 1 | ZZ

(Non-empty strings)

W →3|Z(Words = strings)

Every regular expression is a sum of terms; every term is a concatenation of factors. Everyfactor is either the empty-set symbol, a string, a nontrivial sum of terms in parens, or astarred expression. The expressions Ø*, 3*, 0*, and 1* require no parentheses; otherwise,
the starred subexpression is either a nontrivial sum of terms, a nontrivial concatenation offactors, a starred expression, or a string of length 2 or more.
The “epsilon” symbol 3 in the production rules for W and Z does not represent theempty string per se, but rather an actual symbol that might appear in a regular expression.
The empty string is not a regular expression, but the one-symbol string 3 is a regularexpression that represents the set containing only the empty string!
9Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

The final grammar illustrates an important subtlety for certain applications of context-freegrammars. This grammar is considerably more complicated than one might initially expect fromthe definition of regular languages. It’s tempting to suggest a much simpler grammar likeS → Ø | 3 | 0 | 1 | S +S | SS | S * | (S )but this is incorrect! This grammar does correctly generate all regular expressions as raw strings,
but it allows parse trees that do not respect the meaning of the regular expression. For example,
this “simpler” grammar can parse the regular expression string 0*+1* in two different ways:
S

S

S*

S +S
S*

0 *

+

S +S

S*

S*

1 *

*

+ 1

0 *
The first tree correctly parses the regular expression string 1*+0* as the expression (1∗ ) + (0∗ )but without the redundant parentheses. The second tree incorrectly parses the same string as(1∗ + 0)∗ , which describes a very different regular language!

5.5

Regular Languages are Context-FreeThe following inductive argument proves that every regular language is also a context-freelanguage. Let L be an arbitrary regular language, encoded by some regular expression R. Assume
that any regular expression simpler than R represents a context-free language. (“Assume nosmaller counterexample.”) We construct a context-free grammar for L as follows. There areseveral cases to consider.
• Suppose L is empty. Then L is generated by the trivial grammar S → S.

• Suppose L = {w} for some string w ∈ Σ∗ . Then L is generated by the grammar S → w.

• Suppose L is the union of some regular languages L1 and L2 . The inductive hypothesis
implies that L1 and L2 are context-free. Let G1 be a context-free language for L1 withstarting non-terminal S1 , and let G2 be a context-free language for L2 with starting nonterminal S2 , where the non-terminal sets in G1 and G2 are disjoint. Then L = L1 ∪ L2 isgenerated by the production rule S → S1 | S2 .

• Suppose L is the concatenation of some regular languages L1 and L2 . The inductive
hypothesis implies that L1 and L2 are context-free. Let G1 be a context-free language forL1 with starting non-terminal S1 , and let G2 be a context-free language for L2 with starting
non-terminal S2 , where the non-terminal sets in G1 and G2 are disjoint. Then L = L1 L2 isgenerated by the production rule S → S1 S2 .
• Suppose L is the Kleene closure of some regular language L1 . The inductive hypothesis
implies that L1 is context-free. Let G1 be a context-free language for L1 with starting
non-terminal S1 . Then L = L1∗ is generated by the production rule S → " | S1 S.

In every case, we have found a context-free grammar that generates L, which means L iscontext-free.
In the previous lecture note, we proved that the context-free language {0n 1n | n ≥ 0} is not
regular. (In fact, this is the canonical example of a non-regular language.) Thus, context-freegrammars are strictly more expressive than regular expressions.
10Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

5.6 Not Every Language is Context-Free
Again, you may be tempted to conjecture that every language is context-free, but a variant of ourearlier cardinality argument implies that this is not the case.
Any context-free grammar over the alphabet Σ can be encoded as a string over the alphabetΣ ∪ Γ ∪ {3, K, |, $}, where $ indicates the end of the production rules for each non-terminal. For
example, our example grammar
A → 0A | 0 C

S →A| BB → B1 | C 1

C → " | 0C 1

can be encoded as the string

SKA|B$AK0A|0C$BKB1|C1$CK3|0C1$
We can further encode any such string as a binary string by associating each symbol in theset Σ ∪ Γ ∪ {3, K, |, $} with a different binary substring. Specifically, if we encode each of thegrammar symbols 3, K, |, $ as a string of the form 11∗ 0, each terminal in Σ as a string of theform 011∗ 0, and each non-terminal as a string of the form 0011∗ 0, we can unambiguously
recover the grammar from the encoding. For example, applying the code

3 7→ 10

K 7→ 110| 7→ 1110

0 7→ 010

1 7→ 0110$ 7→ 11110

S 7→ 0010

A 7→ 00110

B 7→ 001110

C 7→ 0011110

transforms our example grammar into the 136-bit string

00101100011011100011101111000110
11001000110111001000111101111000
11101100011100110111000111100110
11110001111011010111001000111100
11011110.
Adding a 1 to the start of this bit string gives us the binary encoding of the integer
102 231 235 533 163 527 515 344 124 802 467 059 875 038.
Our construction guarantees that two different context-free grammars over the same alphabet(ignoring changing the names of the non-terminals) yield different positive integers. Thus, theset of context-free grammars over any alphabet is at most as large as the set of integers, and istherefore countably infinite. (Most integers are not encodings of context-free grammars, but that
only helps us.) It follows that the set of all context-free languages over any fixed alphabet isalso countably infinite. But we already showed that the set of all languages over any alphabet isuncountably infinite. So almost all languages are non-context-free!
There are techniques for proving that specific languages are not context-free, just as there
are for proving certain languages are not regular; unfortunately, they are beyond the scope of
this course. In particular, the {0n 1n 0n | n ≥ 0} is not context-free. (In fact, this is the canonicalexample of a non-context-free language.)11Models of Computation?

5.7

Lecture 5: Context-Free Languages and Grammars [Sp’18]

Recursive Automata

All the flavors of finite-state automata we have seen so far describe/encode/accept/compute
regular languages; these are precisely the languages that can be constructed from individual
strings by union, concatenation, and unbounded repetition. Just as context-free grammars arerecursive generalizations of regular expressions, we can define a class of machines called recursive
automata, which generalize (nondeterministic) finite-state automata. Recursive automata wereintroduced by Walter Woods in 1970 for natural language parsing; Wodds’ terminology recursive
transition networks is more common among computational linguists.
Formally, a recursive automaton consists of the following components:• A non-empty finite set Σ, called the input alphabet• Another non-empty finite set N , disjoint from Σ, whose elements are called module names• A start name S ∈ N• A set M = {MA | A ∈ N } of NFAs, called modules, over the alphabet Σ ∪ N . Each module
MA has the following components:– A finite set Q A of states, such that Q A ∩ Q B = ∅ for all A 6= B

– A start state sA ∈ Q A– A unique terminal or accepting state t A ∈ Q A– A nondeterministic transition function δA : Q A × (Σ ∪ {"} ∪ N ) → 2Q A .

Equivalently,
we have a single global transition function δ : Q × (Σ ∪ {"} ∪ N ) → 2Q , whereS
Q = A∈N Q A, such that for any name A and any state q ∈ Q A we have δ(q) ⊆ Q A. Machine MS iscalled the main module.
A configuration of a recursive automaton is a triple (w, q, s), where w is a string in Σ∗ called
the input, q is a state in Q called the local state, and σ is a string in Q∗ called the stack. The
module containing the local state q is called the active module. A configuration can be changedby three types of transitions.
• A read transition consumes the first symbol in the input and changes the local state within
the active module, just like a standard NFA.
• An epsilon transition changes the local state within the active module, without consuming
any input characters, just like a standard NFA.
• A call transition chooses a module name A, pushes some state in δ(q, A) onto the stack,and then changes the local state to sA (thereby changing the active module to MA), without
consuming any input characters.
• Finally, if the current state is the terminal state of the active module and the stack is
non-empty, a return transition pops the top state off the stack and makes it the new
local state (thereby possibly changing the active module), without consuming any input
characters.
Symbolically, we can describe these transitions as follows:


read:
ax, q, σ 7−→ x, q0 , σ
for some q0 ∈ δ(q, a)epsilon:w, q, σ 7−→ w, q0 , σ
for some q0 ∈ δ(q, ")


call:
w, q, σ 7−→ w, sA, q0 · σ
for some A ∈ N and some q0 ∈ δ(q, A)
return:w, t A, q · σ 7−→ w, q, σ
12Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

A recursive automaton accepts a string w if there is a finite sequence of transitions starting at thestart configuration (w, sS , ") and ending at the terminal configuration (", t S , ").

ÆÆÆ

Reformulate recursive automata using recursion-as-magic, analogously to the nondeterminism-as-magic in string NFAs or Han and Wood’s expression automata. A recursive
automaton module MA accepts a string w if any only if there is a finite sequence of transitions
α1

α3

α2

α`

sA = q0 −→ q1 −→ q2 −→ · · · −→ q` = t Aamong states in Q A, and a decomposition of w into substrings x 1 • x 2 • · · · • x ` , where one of
the following conditions holds for each index i :• αi = " and x i = "• αi ∈ Σ and x i = αi
• αi ∈ N and module Mαi accepts x i .

This model is then easily extended to more general transition labels:• Recursive string-automata allow transitions to be labeled by either strings in Σ∗ ormodule names, and the first two bullets in the previous list become “αi = x i ”.
• Recursive expression-automata allow transitions to be labeled by either regular expressions over Σ or module names, and the first two bullets in the previous list become “αiis a regular expression and x i matches αi ”.
• We could even consider recursive-expression automata, which allow transitions to belabeled by arbitrary regular expressions over Σ ∪ N .
• We could even even consider recursive-grammar automata, which allow transitions to
be labeled by arbitrary context-free grammars over Σ ∪ N . WEEEE/EEEEW!

For example, the following recursive automaton accepts the language {0m 1n | m 6= n}. The
recursive automaton has two component modules; the start machine named S and a “subroutine”
named E (for “equal”) that accepts the language {0n 1n | n ≥ 0}. White arrows indicate recursive
transitions. The large arrow into each module indicates that module’s start state; the large arrowleading out of each module indicates that modules terminal state.

S

E
E

0

ε
1

0

1

0

E

1
E

A recursive automaton for the language {0m 1n | m 6= n}

Lemma 5.5. Every context-free language is accepted by a recursive automaton.
Proof:

ÆÆÆDirect construction from the CFG, with one module per nonterminal.



13Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

For example, the context-free grammar
S → 0A | B1
A → 0A | E

B → B1 | E

E → " | 0E0

leads to the following recursive automaton with four modules:ÆÆÆ

Figure!

Lemma 5.6. Every recursive automaton accepts a context-free language.
Proof (sketch): Let R = (Σ, N , S, δ, M ) be an arbitrary recursive automaton. We define acontext-free grammar G that describes the language accepted by R as follows.
The set of nonterminals in G is isomorphic the state set Q; that is, for each state q ∈ Q, thegrammar contains a corresponding nonterminal [q]. The language of [q] will be the set of strings
w such that there is a finite sequence of transitions starting at the start configuration (w, q, ")and ending at the terminal configuration (", t, "), where t is the terminal state of the module
containing q.
The grammar has four types of production rules, corresponding to the four types of transitions:• read: For each symbol a and each pair of states p and q such that p ∈ δ(q, a), the grammar
contains the production rule [q] → a[p].

• epsilon: For any two states p and q such that p ∈ δ(q, "), the grammar contains the
production rule [q] → [p].

• call: Each name A and each pair of states states p and q such that p ∈ δ(q, A), the grammar
contains the production rule [q] → [sA][p].

• return: Each name A, the grammar contains the production rule [t A] → ".

Finally, the starting nonterminal of G is [sS ], which corresponds to the start state of the main
module.
We can now argue inductively that the grammar G and the recursive automaton R describe
the same language. Specifically, any sequence of transitions in R from (w, sS , ") to (", t S , ") can betransformed mechanically into a derivation of w from the nonterminal [sS ] in G. Symmetrically,
the leftmost derivation of any string w in G can be mechanically transformed into an accepting
sequence of transitions in R. We omit the straightforward but tedious details.
For example, the recursive automaton on the previous page gives us the following context-freegrammar. To make the grammar more readable, I’ve renamed the nonterminals corresponding tostart and terminal states: S = [sS ], T = [t S ], and E = [s E ] = [t E ]:S → EA | 0B

E → " | 0X

A → 1A | 1 T

X → EYB → 0B | E T

Y → 1ZT →"Z→E

Our earlier proofs imply that we can forbid "-transitions or even allow regular-expression
transitions in our recursive automata without changing the set of languages they accept.
14

Models of Computation

5.8

Lecture 5: Context-Free Languages and Grammars [Sp’18]

Chomsky Normal Form

For many algorithmic problems involving context-free grammars, it is helpful to consider
grammars with a particular special structure called Chomsky normal form, abbreviated CNF:
• The starting non-terminal S does not appear on the right side of any production rule.
• The starting non-terminal S may have the production rule S → ".

• The right side of every other production rule is either a single terminal symbol or a stringof exactly two non-terminals—that is, every other production rule has the form A → BC or
A → a.

A particularly attractive feature of CNF grammars is that they yield full binary parse trees; inparticular, every parse tree for a string of length n > 0 has exactly 2n − 1 non-terminal nodes.
Consequently, any string of length n in the language of a CNF grammar can be derived in exactly
2n − 1 production steps. It follows that we can actually determine whether a string belongs to
the language of a CNF grammar by brute-force consideration of all possible derivations of theappropriate length.
For arbitrary context-free grammars, there is no similar upper bound on the length of a
derivation, and therefore no similar brute-force membership algorithm, because the grammar
may contain additional "-productions of the form A → " and/or unit productions of the form
A → B, where both A and B are non-terminals. Unit productions introduce nodes of degree 1
into any parse tree, and "-productions introduce leaves that do not contribute to the word beingparsed.
Fortunately, it is possible to determine membership in the language of an arbitrary context-freegrammar, thanks to the following theorem. Two context-free grammars are equivalent if they
define the same language.
Every context-free grammar is equivalent to a grammar in Chomsky normal form.
Moreover, there are algorithms to automatically convert any context-free grammar into Chomsky
normal form. Unfortunately, these conversion algorithms are quite complex, but for mostapplications of context-free grammars, the details of the conversion are unimportant—it’s enoughto know that the algorithms exist. For the sake of completeness, however, I will describe one
such conversion algorithm in the next section.
?

5.9 CNF Conversion Algorithm
I’ll actually prove a stronger statement: Not only can we convert any context-free grammar into
Chomsky normal form, but we can do so quickly. We analyze the running time of our conversion
algorithm in terms of the total length of the input grammar, which is just the number of symbols
needed to write down the grammar. Up to constant factors, the total length is the sum of thelengths of the production rules.
Theorem 5.7. Given an arbitrary context-free grammar with total length L, we can compute anequivalent grammar in Chomsky normal form with total length O(L 2 ) in O(L 2 ) time.
Our algorithm consists of several relatively straightforward stages. Efficient implementationof some of these stages requires standard graph-traversal algorithms, which are described in adifferent part of the course.
15Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

0. Add a new starting non-terminal. Add a new non-terminal S 0 and a production rule S 0 → S,
where S is the starting non-terminal for the given grammar. S 0 will be the starting non-terminal
for the resulting CNF grammar. (In fact, this step is necessary only when S ∗ ", but at this pointin the conversion process, we don’t yet know whether that’s true.)
1. Decompose long production rules. For each production rule A → ω whose right side w has
length greater than two, add new production rules of length two that still permit the derivationA ∗ ω. Specifically, suppose ω = αχ for some symbol α ∈ Σ ∪ Γ and string χ ∈ (Σ ∪ Γ )∗ . The
algorithm replaces A → ω with two new production rules A → αB and B → χ, where B is a new
non-terminal, and then (if necessary) recursively decomposes the production rule B → χ. For
example, we would replace the long production rule A → 0BC 1C B with the following sequenceof short production rules, where each Ai is a new non-terminal:
A → 0A1

A1 → BA2

A2 → CA3

A3 → 1A4

A4 → C B

This stage can significantly increase the number of non-terminals and production rules, but it
increases the total length of all production rules by at most a small constant factor.3 Moreover,for the remainder of the conversion algorithm, every production rule has length at most two. The
running time of this stage is O(L).
2. Identify nullable non-terminals. A non-terminal A is nullable if and only if A ∗ ". The
recursive definition of ∗ implies that A is nullable if and only if the grammar contains a
production rule A → ω where ω consists entirely of nullable non-terminals (in particular, if
ω = "). You may be tempted to transform this recursive characterization directly into a recursivealgorithm, but this is a bad idea; the resulting algorithm would fall into an infinite loop if (forexample) the same non-terminal appeared on both sides of the same production rule. Instead, weapply the following fixed-point algorithm, which repeatedly scans through the entire grammar
until a complete scan discovers no new nullable non-terminals.
Nullables(Σ, Γ , R, S):Γ" ← ∅〈〈known nullable non-terminals〉〉done ← False
while ¬done
done ← Truefor each non-terminal A ∈ Γ \ Γ"for each production rule A → ω
if ω ∈ Γ∗"
add A to Γ"
done ← False
return Γ"

At this point in the conversion algorithm, if S 0 is not identified as nullable, then we can safely
remove it from the grammar and use the original starting nonterminal S instead.
As written, Nullables runs in O(nL) = O(L 2 ) time, where n is the number of non-terminals
in Γ . Each iteration of the main loop except the last adds at least one non-terminal to Γ" , so the
3In most textbook descriptions of the CFG conversion algorithm, this stage is performed last, after removing"-productions and unit productions. But with the stages in that traditional order, removing "-productions could
exponentially increase the length of the grammar in the worst case! Consider the production rule A → (BC)k , where B
is nullable but C is not. Decomposing this rule first and then removing "-productions introduces about 3k new rules;
whereas, removing "-productions first introduces 2k new rules, most of which then must then be further decomposed!

16Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

algorithm halts after at most n + 1 ≤ L iterations, and in each iteration, we examine at most L
production rules. There is a faster implementation of Nullables that runs in O(n + L) = O(L)time,⁴ but since other parts of the conversion algorithm already require O(L 2 ) time, we needn’t
bother.
3. Eliminate "-productions. First, remove every production rule of the form A → ". Then foreach production rule A → w, add all possible new production rules of the form A → w0 , where w0
is a non-empty string obtained from w by removing one nullable non-terminal. For example, if if
the grammar contained the production rule A → BC, where B and C are both nullable, we would
add two new production rules A → B | C. Finally, if the starting nonterminal S 0 was identified as
nullable in the previous stage, add the production rule S 0 → "; this will be the only "-productionin the final grammar. This phase of the conversion runs in O(L) time and at most triples thenumber of production rules.
4. Merge equivalent non-terminals. We say that two non-terminals A and B are equivalent if
they can be derived from each other: A ∗ B and B ∗ A. Because we have already removed"-productions, any such derivation must consist entirely of unit productions. For example, in thegrammar
S → B | C,

A → B | D | C C | 0,

B → C | AD | 1,

C → A | DA,

D → BA | C S,

non-terminals A, B, C are all equivalent, but S is not in that equivalence class (because we cannot
derive S from A) and neither is D (because we cannot derive A from D).
Construct a directed graph G whose vertices are the non-terminals and whose edges correspondto unit productions, in O(L) time. Then two non-terminals are equivalent if and only if they arein the same strong component of G. Compute the strong components of G in O(L) time using,for example, the algorithm of Kosaraju and Sharir. Then merge all the non-terminals in each
equivalence class into a single non-terminal. Finally, remove any unit productions of the form
A → A. The total running time for this phase is O(L). Starting with our example grammar above,
merging B and C with A and removing the production A → A gives us the simpler grammar
S → A,A → AA | D | DA | 0 | 1,

D → AA | AS.

We could further simplify the grammar by merging all non-terminals reachable from S using only
unit productions (in this case, merging non-terminals S and S), but this further simplification is
unnecessary.
5. Remove unit productions. Once again, we construct a directed graph G whose vertices are
the non-terminals and whose edges correspond to unit productions, in O(L) time. Because no
two non-terminals are equivalent, G is acyclic. Thus, using topological sort, we can index thenon-terminals A1 , A2 , . . . , An such that for every unit production Ai → A j we have i < j, againin O(L) time; moreover, we can assume that the starting non-terminal is A1 . (In fact, both thedag G and the linear ordering of non-terminals was already computed in the previous phase!!)Then for each index j in decreasing order, for each unit production Ai → A j and eachproduction A j → ω, we add a new production rule Ai → ω. At this point, all unit productions are

⁴Consider the bipartite graph whose vertices correspond to non-terminals and the right sides of production rules,
with one edge per rule. The faster algorithm is a modified breadth-first search of this graph, starting at the vertex
representing ".

17Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

redundant and can be removed. Applying this algorithm to our example grammar above gives us
the grammar
S → AA | AS | DA | 0 | 1,

A → AA | AS | DA | 0 | 1,

D → AA | AS.

In the worst case, each production rule for An is copied to each of the other n − 1 nonterminals. Thus, this phase runs in Θ(nL) = O(L 2 ) time and increases the length of the grammarto Θ(nL) = O(L 2 ) in the worst case.
This phase dominates the running time of the CNF conversion algorithm. Unlike previous
phases, no faster algorithm for removing unit transformations is known! There are grammars oflength L with unit productions such that any equivalent grammar without unit productions haslength Ω(L 1.499999 ) (for any desired number of 9s), but this lower bound does not rule out thepossibility of an algorithm that runs in only O(L 3/2 ) time. Closing the gap between Ω(L 3/2−" )and O(L 2 ) has been an open problem since the early 1980s!
6. Protect terminals. Finally, for each terminal a ∈ Σ, we introduce a new non-terminal Aa
and a new production rule Aa → a, and then replace a with Aa in every production rule oflength two.
This completes the conversion to Chomsky normal form! As claimed, the total running timeof the algorithm is O(L 2 ), and the total length of the output grammar is also O(L 2 ).
To see the conversion algorithm in action, let’s apply these stages one at a time to our very
first example grammar for the language {0m 1n | m 6= n}:
S →A| BA → 0A | 0 C

B → B1 | C 1

0. Add a new starting non-terminal S 0 .
S0 → SS →A| BA → 0A | 0 C

1. Decompose the long production rule C → 0C 1.
S0 → SS →A| BA → 0A | 0C

C → " | 0C 1

B → B1 | C 1

B → B1 | C 1

C → " | 0C 1

C → " | 0D

D → C1

2. Identify C as the only nullable non-terminal. Because S 0 is not nullable, remove theproduction rule S 0 → S.

3. Eliminate the "-production C → ".
S →A| BA → 0A | 0 C | 0

B → B1 | C 1 | 1

C → 0D

4. No two non-terminals are equivalent, so there’s nothing to merge.

D → C1 | 1

5. Remove the unit productions S 0 → S, S → A, and S → B.
S → 0A | 0 C | B 1 | C 1 | 0 | 1
A → 0A | 0 C | 0

B → B1 | C 1 | 1

C → 0D

D → C 1 | 1.

6. Finally, protect the terminals 0 and 1 to obtain the final CNF grammar.
S → EA | EC | BF | C F | 0 | 1
A → EA | EC | 0

B → BF | C F | 1

D → CF | 1

C → ED
E→0

F →1

18

Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

Exercises
1. Describe context-free grammars that generate each of the following languages. The
function #(x, w) returns the number of occurrences of the substring x in the string w.
For example, #(0, 101001) = 3 and #(010, 1010100011) = 2. These are not listed inorder of increasing difficulty.
(a) All strings in {0, 1}∗ whose length is divisible by 5.

(b) All strings in {0, 1}∗ representing a non-negative multiple of 5 in binary.
(c) {w ∈ {0, 1}∗ | #(0, w) = 2 · #(1, w)}(d) {w ∈ {0, 1}∗ | #(0, w) 6= 2 · #(1, w)}(e) {w ∈ {0, 1}∗ | #(00, w) = #(11, w)}(f) {w ∈ {0, 1}∗ | #(01, w) = #(10, w)}(g) {w ∈ {0, 1}∗ | #(0, w) = #(1, w) and |w| is a multiple of 3}(h) {0, 1}∗ \ {0n 1n | n ≥ 0}(i) {0n 12n | n ≥ 0}(j) {0, 1}∗ \ {0n 12n | n ≥ 0}(k) {0n 1m | 0 ≤ 2m ≤ n < 3m}(l) {0i 1 j 2i+ j | i, j ≥ 0}(m) {0i 1 j 2k | i = j or j = k}(n) {0i 1 j 2k | i 6= j or j 6= k}(o) {0i 1 j 0 j 1i | i, j ≥ 0}(p) w#0#(0,w) w ∈ {0, 1}∗(q) {x y | x, y ∈ {0, 1}∗ and x 6= y and |x| = | y|}(r) x # y R x, y ∈ {0, 1}∗ and x 6= y(s) {x # y | x, y ∈ {0, 1}∗ and #(0, x) = #(1, y)}(t) {0, 1}∗ \ {ww | w ∈ {0, 1}∗ }(u) All strings in {0, 1}∗ that are not palindromes.

(v) All strings in {(, ), }∗ in which the parentheses are balanced and the symbol 
appears at most four times. For example, ()(()) and (   (()()  )()())  and   are strings in this language, but )(() and (    )   are not.

2. Describe recursive automata for each of the languages in problem 1. (“Describe” does notnecessarily mean “draw”!)
3. Prove that if L is a context-free language, then L R is also a context-free language. [Hint:
How do you reverse a context-free grammar?]
4. Consider a generalization of context-free grammars that allows any regular expression overΣ ∪ Γ to appear on the right side of a production rule. Without loss of generality, for each
non-terminal A ∈ Γ , the generalized grammar contains a single regular expression R(A). To
19

Models of Computation

Lecture 5: Context-Free Languages and Grammars [Sp’18]

apply a production rule to a string, we replace any non-terminal A with an arbitrary wordin the language described by R(A). As usual, the language of the generalized grammar isthe set of all strings that can be derived from its start non-terminal.
For example:, the following generalized context-free grammar describes the languageof all regular expressions over the alphabet {0, 1}:
S → (T +)∗ T + Ø(Regular expressions)

F → (0 + 1 + (S ))(* + ")(Factors = concatenable expressions)

T →3+F F∗(Terms = summable expressions)

Here is a parse tree for the regular expression 0+1(10*1+01*0)*10* (which represents
the set of all binary numbers divisible by 3):
S
T +

0

T
F

F

1 (

F

) * 1 0 *

S

+

T
F

F

F

1 0 * 1

F

T
F

F

F

0 1 * 0

Prove that every generalized context-free grammar describes a context-free language.
In other words, show that allowing regular expressions to appear in production rules does
not increase the expressive power of context-free grammars.

20

Models of Computation

Lecture 6: Turing Machines [Fa’16]
Think globally, act locally.
— Attributed to Patrick Geddes (c.1915), among many others.
We can only see a short distance ahead,but we can see plenty there that needs to be done.
— Alan Turing, “Computing Machinery and Intelligence” (1950)
Never worry about theory
as long as the machinery does what it’s supposed to do.
— Robert Anson Heinlein, Waldo & Magic, Inc. (1950)
It is a sobering thought that when Mozart was my age,he had been dead for two years.
— Tom Lehrer, introduction to “Alma”, That Was the Year That Was (1965)

6

Turing Machines

In 1936, a few months before his 24th birthday, Alan Turing launched computer science as amodern intellectual discipline. In a single remarkable paper, Turing provided the following
results:• A simple formal model of mechanical computation now known as Turing machines.
• A description of a single universal machine that can be used to compute any function
computable by any other Turing machine.
• A proof that no Turing machine can solve the halting problem—Given the formal descriptionof an arbitrary Turing machine M , does M halt or run forever?
• A proof that no Turing machine can determine whether an arbitrary given proposition
is provable from the axioms of first-order logic. This is Hilbert and Ackermann’s famous
Entscheidungsproblem (“decision problem”).
• Compelling arguments1 that his machines can execute arbitrary “calculation by finite
means”.
Although Turing did not know it at the time, he was not the first to prove that the Entscheidungsproblem had no algorithmic solution. The first such proof is implicit in the work of Kurt
Gödel; in lectures on his incompleteness theorems2 at Princeton in 1934, Gödel described amodel of general recursive functions, which he largely credited to Jacques Herbrand.3 Gödel’s
incompleteness theorem can be viewed as a proof that some propositions cannot be proved using
general recursive functions. However, Gödel viewed his definition as a “heuristic principle” rather
than an accurate model of effective computation, or even a complete definition of recursion.
The first published proof was written by Alonzo Church and published just a new months
before Turing’s paper, using another different model of computation, now called the untyped
λ-calculus. Turing and Church developed their results independently; indeed, Turing rushed
1As Turing put it, “All arguments which can be given are bound to be, fundamentally, appeals to intuition, and forthis reason rather unsatisfactory mathematically.” The claim that anything that can be computed can be computing
using Turing machines is now known as the Church-Turing thesis.
2which he published at the ripe old age of 25
3Herbrand was a brilliant French mathematician who was killed in a mountain-climbing accident at the age of 23.
© Copyright 2018 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms/ for the most recent revision.

1Models of Computation

Lecture 6: Turing Machines [Fa’16]

the submission of his own paper immediately after receiving a copy of Church’s paper, pausing
only long enough to prove that any function computable via λ-calculus can also be computedby a Turing machine and vice versa.⁴ Church was the referee for Turing’s paper; between thepaper’s submission and its acceptance, Turing was admitted to Princeton as a PhD student, where
Church became his advisor. He finished his PhD two years later.
Informally, Turing described an abstract machine with a finite number of internal states thathas access to “memory” in the form of a tape. The tape consists of a semi-infinite sequence ofcells, each containing a single symbol from some arbitrary finite alphabet. The Turing machine
can access the tape only through its head, which is positioned over a single cell. Initially, the tapecontains an arbitrary finite input string followed by an infinite sequence of blanks, and the headis positioned over the first cell on the tape. In a single iteration, the machine reads the symbol inthat cell, possibly write a new symbol into that cell, possibly changes its internal state, possibly
moves the head to a neighboring cell, and possibly halts. The precise behavior of the machine ateach iteration is entirely determined by its internal state and the symbol that it reads. When themachine halts, it indicates whether it has accepted or rejected the original input string.
Write O
Move left

T O R T U R I N G M A C H I N E
Write N
Move rightT O R T U R I N G M A C H I N E
Write U
Move rightN O R T U R I N G M A C H I N E
Halt and
accept!

N U R T U R I N G M A C H I N E
A few iterations of a six-state Turing machine.

6.1

Why Bother?

Students used to thinking of computation in terms of higher-level operations like random memory
accesses, function calls, and recursion may wonder why we should even consider a model as
simple and constrained as Turing machines. Admittedly, Turing machines are a terrible modelfor thinking about fast computation; simple operations that take constant time in the standard
⁴At roughly the same time as Turing’s paper, Church and his more recent PhD graduate Steven Kleene independently
proved that all general recursive functions are definable in the λ-calculus and vice versa. At the time, Kleene was 27,
and Church was 33.

2Models of Computation

Lecture 6: Turing Machines [Fa’16]

random-access model can require arbitrarily many steps on a Turing machine. Worse, seemingly
minor variations in the precise definition of “Turing machine” can have significant impact on
problem complexity. As a simple example (which will make more sense later), we can reversea string of n bits in O(n) time using a two-tape Turing machine, but the same task provably
requires Ω(n2 ) time on a single-tape machine.
But here we are not interested in finding fast algorithms, or indeed in finding algorithms
at all, but rather in proving that some problems cannot be solved by any computational means.
Such a bold claim requires a formal definition of “computation” that is simple enough to support
formal argument, but still powerful enough to describe arbitrary algorithms. Turing machines
are ideal for this purpose. In particular, Turing machines are powerful enough to simulate other
Turing machines, while still simple enough to let us build up this self-simulation from scratch,
unlike more complex but efficient models like the standard random-access machine(Arguably, self-simulation is even simpler in Church’s λ-calculus, or in Schönfinkel andCurry’s combinator calculus, which is one of many reasons those models are more common in thedesign and analysis of programming languages than Turing machines. Those models are much
more abstract; in particular, they are harder to show equivalent to standard iterative models ofcomputation.)

6.2

Formal Definitions

Formally, a Turing machine consists of the following components. (Hang on; it’s a long list.)• An arbitrary finite set Γ with at least two elements, called the tape alphabet.
• An arbitrary symbol  ∈ Γ , called the blank symbol or just the blank.

• An arbitrary nonempty subset Σ ⊆ (Γ \ {}), called the input alphabet.
• Another arbitrary finite set Q whose elements are called states.
• Three distinct special states start, accept, reject ∈ Q.

• A transition function δ : (Q \ {accept, reject}) × Γ → Q × Γ × {−1, +1}.

A configuration or global state of a Turing machine is represented by a triple (q, x, i) ∈Q ×Γ ∗ ×N, indicating that the machine’s internal state is q, the tape contains the string x followedby an infinite sequence of blanks, and the head is located at position i. Trailing blanks in thetape string are ignored; the triples (q, x, i) and (q, x, i) describe exactly the same configuration.
The transition function δ describes the evolution of the machine. For example, δ(q, a) =(p, b, −1) means that when the machine reads symbol a in state q, it changes its internal state
to p, writes symbol b onto the tape at its current location (replacing a), and then decreases its
position by 1 (or more intuitively, moves one step to the left). If the position of the head becomes
negative, no further transitions are possible, and the machine crashes.
We write (p, x , i) ⇒ M (q , y, j ) to indicate that Turing machine M transitions from the first
configuration to the second in one step. (The symbol ⇒ is often pronounced “yields”; I will omit
the subscript M if the machine is clear from context.) For example, δ(p, a) = (q, b, ±1) meansthat(p, x a y, i) ⇒ (q, x b y, i ± 1)
for any non-negative integer i, any string x of length i, and any string y. The evolution of any
Turing machine is deterministic; each configuration C yields a unique configuration C 0 . We write
C ⇒∗ C 0 to indicate that there is a (possibly empty) sequence of transitions from configuration C
to configuration C 0 . (The symbol ⇒∗ can be pronounced “eventually yields”.)
3Models of Computation

Lecture 6: Turing Machines [Fa’16]

The initial configuration is (start, w, 0) for some arbitrary (and possibly empty) input stringw ∈ Σ∗ . If M eventually reaches the accept state—more formally, if (start, w, 0) ⇒∗ (accept, x, i)for some string x ∈ Γ ∗ and some integer i—we say that M accepts the original input string w.
Similarly, if M eventually reaches the reject state, we say that M rejects w. We must emphasizethat “rejects” and “does not accept” are not synonyms; if M crashes or runs forever, then M
neither accepts nor rejects w.
We distinguish between two different senses in which a Turing machine can “accept” alanguage. Let M be a Turing machine with input alphabet Σ, and let L ⊆ Σ∗ be an arbitrary
language over Σ.
• M recognizes or accepts L if and only if M accepts every string in L but nothing else. A
language is recognizable (or semi-computable or recursively enumerable) if it is recognizedby some Turing machine.
• M decides L if and only if M accepts every string in L and rejects every string in Σ∗ \ L.
Equivalently, M decides L if and only if M recognizes L and halts (without crashing) on all
inputs. A language is decidable (or computable or recursive) if it is decided by some Turingmachine.
Trivially, every decidable language is recognizable, but (as we will see later), not every recognizable
language is decidable.

6.3

A First Example

Consider the language L = {0n 1n 0n | n ≥ 0}. This language is neither regular nor context-free,
but it can be decided by the following six-state Turing machine. The alphabets and states of themachine are defined as follows:Γ = {0, 1, $, x,}

Σ = {0, 1}

Q = {start, seek1, seek0, reset, verify, accept, reject}
The transition function is described in the table on the next page; all unspecified transitions leadto the reject state. The figure below shows a graphical representation of the same machine,which resembles a drawing of a DFA, but with output symbols and actions specified on each edge.
For example, we indicate the transition δ(p, 0) = (q, 1, +1) by writing 0/1, +1 next to the arrowfrom state p to state q.
$/$,+1

0/$,+1start

1/x,+1

0/0,+1x/x,+1x/$,+1x/$,+1

seek1

verify□/□,−1seek0

1/1,+1x/x,+10/x,−1reset

0/0,−1
1/1,−1x/x,−1

acceptA graphical representation of the example Turing machine4Models of Computationδ(p, a) = (Lecture 6: Turing Machines [Fa’16]q, b, ∆ )δ( start , 0) = ( seek1 , $, +1)
δ( start , x) = ( verify , $, +1)

explanation
mark first 0 and scan rightlooks like we’re done, but let’s make sureδ(seek1, 0) = ( seek1 , 0, +1)δ(seek1, x) = ( seek1 , x, +1)δ(seek1, 1) = ( seek0 , x, +1)

scan rightward for 1
mark 1 and continue rightδ(seek0, 1) = ( seek0 , 1, +1)δ(seek0, x) = ( seek0 , x, +1)δ(seek0, 0) = ( reset , x, +1)

scan rightward for 0
mark 0 and scan left

δ( reset , 1) = ( reset , 1, −1)δ( reset , x) = ( reset , x, −1)δ( reset , $) = ( start , $, +1)

step right and start overδ( reset , 0) = ( reset , 0, −1)δ( verify , x) = ( verify , $, +1)δ( verify , ) = (accept, , −1)

scan leftward for $scan right for any unmarked symbol
success!

The transition function for a Turing machine that decides the language {0n 1n 0n | n ≥ 0}.

Finally, we trace the execution of this machine on two input strings: 001100 ∈ L and
00100 6∈ L. In each configuration, we indicate the position of the head using a small triangle
instead of listing the position explicitly. Notice that we automatically add blanks to the tapestring as necessary. Proving that this machine actually decides L—and in particular, that it nevercrashes or infinite-loops—is a straightforward but tedious exercise in induction.

6.4

Variations

There are actually several formal models that all fall under the name “Turing machine”, eachwith small variations on the definition we’ve given. Although we do need to be explicit about
which variant we want to use for any particular problem, the differences between the variants are
relatively unimportant. For any machine defined in one model, there is an equivalent machine ineach of the other models; in particular, all of these variants recognize the same languages anddecide the same languages. For example:• Halting conditions. Some models allow multiple accept and reject states, which (depending on the precise model) trigger acceptance or rejection either when the machine enters
the state, or when the machine has no valid transitions out of such a state. Others include
only explicit accept states, and either equate crashing with rejection or do not define arejection mechanism at all. Still other models include halting as one of the possible actionsof the machine, in addition to moving left or moving right; in these models, the machine
accepts/rejects its input if and only if it halts in an accepting/non-accepting state.
• Actions. Some Turing machine models allow transitions that do not move the head, orthat move the head by more than one cell in a single step. Others insist that a single step of
the machine either writes a new symbol onto the tape or moves the head one step. Finally,
as mentioned above, some models include halting as one of the available actions.
• Transition function. Some models of Turing machines, including Turing’s original
definition, allow the transition function to be undefined on some state-symbol pairs. In this5Models of Computation

Lecture 6: Turing Machines [Fa’16](start, 001100)
Î⇒ (seek1, $01100)
Î⇒ (seek1, $01100)
Î⇒ (seek0, $0x100)Î⇒ (seek0, $0x100)Î⇒ (reset, $0x1x0)Î⇒ (reset, $0x1x0)Î⇒ (reset, $0x1x0)Î⇒ (reset, $0x1x0)Î⇒ (start, $0x1x0)Î⇒ (seek1, $$x1x0)Î⇒ (seek1, $$x1x0)Î⇒ (seek0, $$xxx0)Î⇒ (seek0, $$xxx0)Î⇒ (reset, $$xxxx)Î⇒ (reset, $$xxxx)Î⇒ (reset, $$xxxx)Î⇒ (reset, $$xxxx)Î⇒ (start, $$xxxx)Î⇒ (verify, $$$xxx)Î⇒ (verify, $$$$xx)
Î⇒ (verify, $$$$$x)
Î⇒ (verify, $$$$$$)Î⇒ (accept, $$$$$$) ⇒ accept!
ÎThe evolution of the example Turing machine on the input string 001100 ∈ L(start, 00100)
Î⇒ (seek1, $0100)
Î⇒ (seek1, $0100)
Î⇒ (seek0, $0x00)
Î⇒ (reset, $0xx0)Î⇒ (reset, $0xx0)Î⇒ (reset, $0xx0)Î⇒ (start, $0xx0)Î⇒ (seek1, $$xx0)Î⇒ (seek1, $$xx0)Î⇒ (seek1, $$xx0) ⇒ reject!
ÎThe evolution of the example Turing machine on the input string 00100 6∈ L

6Models of Computation

Lecture 6: Turing Machines [Fa’16]

formulation, the transition function is given by a set δ ⊂ Q × Γ × Q × Γ × {+1, −1}, suchthat for each state q and symbol a, there is at most one transition (q, a, · , · , · ) ∈ δ. If themachine enters a configuration from which there is no transition, it halts and (dependingon the precise model) either crashes or rejects. Others define the transition function asδ : Q × Γ → Q × (Γ ∪ {−1, +1}), allowing the machine to either write a symbol to the tapeor move the head in each step.
• Beginning of the tape. Some models forbid the head to move past the beginning of thetape, either by starting the tape with a special symbol that cannot be overwritten andthat forces a rightward transition, or by declaring that a leftward transition at position 0
leaves the head in position 0, or even by pure fiat—declaring any machine that performs aleftward move at position 0 to be invalid.
To prove that any two of these variant “species” of Turing machine are equivalent, we mustshow how to transform a machine of one species into a machine of the other species that accepts
and rejects the same strings. For example, let M = (Γ ,, Σ, Q, s, accept, reject, δ) be a Turingmachine with explicit accept and reject states. We can define an equivalent Turing machine
M 0 that halts only when it moves left from position 0, and accepts only by halting while in an
accepting state, as follows. We define the set of accepting states for M 0 as A = {accept} anddefine a new transition function(accept, a, −1) if q = accept0δ (q, a) := (reject, a, −1) if q = rejectδ(q, a)otherwise
Similarly, suppose someone gives us a Turing machine M = (Γ ,, Σ, Q, s, accept, reject, δ)whose transition function δ : Q ×Γ → Q ×Γ ×{−1, 0, +1} allows the machine to transition without
moving its head. Then we can construct an equivalent Turing machine M 0 = (Γ ,, Σ, Q0 , s,accept, reject, δ0 ) that moves its head at every transition by defining Q0 := Q × {0, 1} and¨((q, 1), b, +1) if δ(p, a) = (q, b, 0),0δ ((p, 0), a) :=((q, 0), b, ∆) if δ(p, a) = (q, b, ∆) and ∆ 6= 0,δ0 ((p, 1), a) := ((p, 0), a, −1).

6.5

Computing Functions

Turing machines can also be used to compute functions from strings to strings, instead of justaccepting or rejecting strings. Since we don’t care about acceptance or rejection, we replace
the explicit accept and reject states with a single halt state, and we define the output of theTuring machine to be the contents of the tape when the machine halts, after removing theinfinite sequence of trailing blanks. More formally, for any Turing machine M , any string w ∈ Σ∗ ,and any string x ∈ Γ ∗ that does not end with a blank, we write M(w ) = x if and only if(w, s, 0) ⇒∗M (x, halt, i) for some integer i. If M does not halt on input w, then we write M(w ) %,which can be read either “M diverges on w” or “M (w) is undefined.” We say that M computes
the function f : Σ∗ → Σ∗ if and only if M (w) = f (w) for every string w.
6.5.1

Shifting

One basic operation that is used in many Turing machine constructions is shifting the input
string a constant number of steps to the right or to the left. For example, given any input
7Models of Computation

Lecture 6: Turing Machines [Fa’16]

string w ∈ {0, 1}∗ , we can compute the string 0w using a Turing machine with tape alphabet
Γ = {0, 1,}, state set Q = {0, 1, halt}, start state 0, and the following transition function:
δ(p, a) = ( q , b, ∆ )δ(0, 0) = ( 0 , 0, +1)δ(0, 1) = ( 1 , 0, +1)δ(0, ) = (halt, 0, +1)δ(1, 0) = ( 0 , 1, +1)δ(1, 1) = ( 1 , 1, +1)δ(1, ) = (halt, 1, +1)
By increasing the number of states, we can build a Turing machine that shifts the input string any
fixed number of steps in either direction. For example, a machine that shifts its input to the leftby five steps might read the string from right to left, storing the five most recently read symbols in
its internal state. A typical transition for such a machine would be δ(12345, 0) = (01234, 5, −1).
6.5.2

Binary Addition

With a more complex Turing machine, we can implement binary addition. The input is a string of
the form w+ x, where w, x ∈ {0, 1}n , representing two numbers in binary; the output is the binary
representation of w+ x. To simplify our presentation, we assume that |w| = |x| > 0; however, thisrestrictions can be removed with the addition of a few more states. The following figure showsthe entire Turing machine at a glance. The machine uses the tape alphabet Γ = {, 0, 1, +, 0, 1};
the start state is shift0. All missing transitions go to a fail state, indicating that the input wasbadly formed.
Execution of this Turing machine proceeds in several phases, each with its own subset ofstates, as indicated in the figure. The initialization phase scans the entire input, shifting it to
the right to make room for the output string, marking the rightmost bit of w, and reading anderasing the last bit of x.
δ( p , a) = ( q , b, ∆ )δ( shift0 , 0) = ( shift0 , 0, +1)
δ( shift0 , 1) = ( shift1 , 0, +1)
δ( shift0 , +) = (shift+, 0, +1)
δ( shift0 , ) = ( add0 , , −1)δ( shift1 , 0) = ( shift0 , 1, +1)
δ( shift1 , 1) = ( shift1 , 1, +1)
δ( shift1 , +) = (shift+, 1, +1)
δ( shift1 , ) = ( add1 , , −1)δ(shift+, 0) = ( shift0 , +, +1)
δ(shift+, 1) = ( shift1 , +, +1)

The first part of the main loop scans left to the marked bit of w, adds the bit of x that was
just erased plus the carry bit from the previous iteration, and records the carry bit for the next
iteration in the machines internal state.

8Models of Computation

Lecture 6: Turing Machines [Fa’16]

shift++/0,+10/+,+1

initialization+/1,+1

1/+,+1

1/0,+1
shift00/0,+1

0/1,+1□/□,−10/0,−1
1/1,−1+/+,−1

shift1

1/1,+10/0,−1
1/1,−1+/+,−1

add0
0/0,−1
1/1,−1add1
1/0,−10/1,−1

next1□/□,−1

last0

0/0,+1
1/1,+1+/+,+1□/□,−1

1/□,−10/□,−1+/□,−10/0,−1
1/1,−1

scan rightand read

1/1,+1

next0

get0

scan left
and add0/0,−1
1/1,−1

back1

1/0,+10/□,−10/0,−1
1/1,−1+/+,−1

add2

back0

0/0,+1
1/1,+1+/+,+1

main loop□/□,−1get1

1/□,−1+/□,−10/0,−1halt

0/0,−1

last1

0/0,−1
1/1,−1termination

A Turing machine that adds two binary numbers of the same length.

δ( p , a) = ( q , b, ∆ )δ(add0, 0) = ( add0 , 0, −1)δ(add0, 1) = ( add0 , 0, −1)δ(add0, +) = ( add0 , 0, −1)δ(add0, 0) = (back0, 0, −1)δ(add0, 1) = (back0, 1, −1)δ( p , a) = ( q , b, ∆ )δ(add1, 0) = ( add1 , 0, −1)δ(add1, 1) = ( add1 , 0, −1)δ(add1, +) = ( add1 , 0, −1)δ(add1, 0) = (back0, 1, −1)δ(add1, 1) = (back1, 0, −1)δ( p , a) = ( q , b, ∆ )δ(add2, 0) = ( add2 , 0, −1)δ(add2, 1) = ( add2 , 0, −1)δ(add2, +) = ( add2 , 0, −1)δ(add2, 0) = (back1, 0, −1)δ(add2, 1) = (back1, 1, −1)

The second part of the main loop marks the previous bit of w, scans right to the end of x, andthen reads and erases the last bit of x, all while maintaining the carry bit.
δ( p , a) = ( q , b, ∆ )δ(back0, 0) = (next0, 0, +1)
δ(back0, 1) = (next0, 1, +1)
δ( next0 , 0) = (next0, 0, +1)
δ( next0 , 1) = (next0, 0, +1)
δ( next0 , +) = (next0, 0, +1)
δ( next0 , ) = ( get0 , , −1)δ( get0 , 0) = ( add0 , , −1)δ( get0 , 1) = ( add1 , , −1)δ( get0 , +) = ( last0 , , −1)δ( p , a) = ( q , b, ∆ )δ(back1, 0) = (next1, 0, +1)
δ(back1, 1) = (next1, 1, +1)
δ( next1 , 0) = (next1, 0, +1)
δ( next1 , 1) = (next1, 0, +1)
δ( next1 , +) = (next1, 0, +1)
δ( next1 , ) = ( get1 , , −1)δ( get1 , 0) = ( add1 , , −1)δ( get1 , 1) = ( add2 , , −1)δ( get1 , +) = ( last1 , , −1)

Finally, after erasing the + in the last iteration of the main loop, the termination phase adds thelast carry bit to the leftmost output bit and halts.

9Models of Computation

Lecture 6: Turing Machines [Fa’16]

δ( p , a) = ( q , b, ∆ )δ(last0, 0) = (last0, 0, −1)δ(last0, 1) = (last0, 0, −1)δ(last0, 0) = ( halt , 0,)δ(last1, 0) = (last1, 0, −1)δ(last1, 1) = (last1, 0, −1)δ(last1, 0) = ( halt , 1,)

6.6

Variations on Tracks, Heads, and Tapes

Multiple Tracks
It is sometimes convenient to endow the Turing machine tape with multiple tracks, each with its
own tape alphabet, and allow the machine to read from and write to the same position on all
tracks simultaneously. For example, to define a Turing machine with three tracks, we need threetape alphabets Γ1 , Γ2 , and Γ3 , each with its own blank symbol, where (say) Γ1 contains the input
alphabet Σ as a subset; we also need a transition function of the form
δ : Q × Γ1 × Γ2 × Γ3 → Q × Γ1 × Γ2 × Γ3 × {−1, +1}

Describing a configuration of this machine requires a quintuple (q, x 1 , x 2 , x 3 , i), indicating thateach track i contains the string x i followed by an infinite sequence of blanks. The initialconfiguration is (start, w, ", ", 0), with the input string written on the first track, and the othertwo tracks completely blank.
But any such machine is equivalent (if not identical) to a single-track Turing machine withthe (still finite!) tape alphabet Γ := Γ1 × Γ2 × Γ3 . Instead of thinking of the tape as three infinite
sequences of symbols, we think of it as a single infinite sequence of “records”, each containing
three symbols. Moreover, there’s nothing special about the number 3 in this construction; aTuring machine with any constant number of tracks is equivalent to a single-track machine.
Doubly-Infinite Tape
It is also sometimes convenient to allow the tape to be infinite in both directions, for example,
to avoid boundary conditions. There are several ways to simulate a doubly-infinite tape on amachine with only a semi-infinite tape. Perhaps the simplest method is to use a semi-infinite tapewith two tracks, one containing the cells with positive index and the other containing the cellswith negative index in reverse order, with a special marker symbol at position zero to indicate
the transition.
0 +1 +2 +3 +4 · · ·É −1 −2 −3 −4 · · ·Another method is to shuffle the positive-index and negative-index cells onto a single track,and add additional states to allow the Turing machine to move two steps in a single transition.
Again, we need a special symbol at the left end of the tape to indicate the transition:
É

0

−1

+1

−2

+2

−3

+3

···

A third method maintains two sentinel symbols É and Ê that surround all other non-blanksymbols on the tape. Whenever the machine reads the right sentinel Ê, we write a blank, moveright, write Ê, move left, and then proceed as if we had just read a blank. On the other hand,when the machine reads the left sentinel É, we shift the entire contents of the tape (up to and10Models of Computation

Lecture 6: Turing Machines [Fa’16]

including the right sentinel) one step to the right, then move back to the left sentinel, move right,
write a blank, and finally proceed as if we had just read a blank. Since the Turing machine does
not actually have access to the position of the head as an integer, shifting the head and the tapecontents one step right has no effect on its future evolution.
É

−3

−2

−1

0

+1

+2

+3

+4

+5

Ê

···

Using either of the first two methods, we can simulate t steps of an arbitrary Turing machinewith a doubly-infinite tape using only O(t) steps on a standard Turing machine. The third
method, unfortunately, requires Θ(t 2 ) steps in the worst case.
Insertion and Deletion
We can also allow Turing machines to insert and delete cells on the tape, in addition to simply
overwriting existing symbols. We’ve already seen how to insert a new cell: Leave a special markon the tape (perhaps in a second track), shift everything to the right of this mark one cell to theright, scan left to the mark, erase the mark, and finally write the correct character into the newcell. Deletion is similar: Mark the cell to be deleted, shift everything to the right of the mark one
step to the left, scan left to the mark, and erase the mark. We may also need to maintain a markin some cell to the right every non-blank symbol, indicating that all cells further to the right areblank, so that we know when to stop shifting left or right.
Multiple Heads
Another convenient extension is to allow machines simultaneous access to more than one positionon the tape. For example, to define a Turing machine with three heads, we need a transition
function of the form
δ : Q × Γ 3 → Q × Γ 3 × {−1, +1}3 .

Describing a configuration of such a machine requires a quintuple (q, x, i, j, k), indicating that themachine is in state q, the tape contains string x, and the three heads are at positions i, j, k. The
transition function tells us, given q and the three symbols x[i], x[ j], x[k], which three symbols
to write on the tape and which direction to move each of the heads.
We can simulate this behavior with a single head by adding additional tracks to the tapethat record the positions of each head. To simulate a machine M with three heads, we use atape with four tracks: track 0 is the actual work tape; each of the remaining tracks has a single
non-blank symbol recording the position of one of the heads. We also insert a special marker
symbols at the left end of the tape.
É
É
É
É

M

Y
Î

W O R

K

T A

P
Î

Î

E ···
···
···
···

We can simulate any single transition of M , starting with our single head at the left end of
the tape, as follows. Throughout the simulation, we maintain the internal state of M as one of
the components of our current state. First, for each i, we read the symbol under the ith head of
M as follows:
Scan to the right to find the mark on track i, read the corresponding symbol fromtrack 0 into our internal state, and then return to the left end of the tape.
11Models of Computation

Lecture 6: Turing Machines [Fa’16]

At this point, our internal state records M ’s current internal state and the three symbols under
M ’s heads. After one more transition (using M ’s transition function), our internal state records
M ’s next state, the symbol to be written by each head, and the direction to move each head.
Then, for each i, we write with and move the ith head of M as follows:
Scan to the right to find the mark on track i, write the correct symbol onto on track
0, move the mark on track i one step left or right, and then return to the left end of
the tape.
Again, there is nothing special about the number 3 here; we can simulate machines with any
fixed number of heads.
Careful analysis of this technique implies that for any integer k, we can simulate t stepsof an arbitrary Turing machine with k independent heads in Θ(t 2 ) time on a standard Turingmachine with only one head. Unfortunately, this quadratic blowup is unavoidable. It is relatively
easy to recognize the language of marked palindromes {w•wR | w ∈ {0, 1}∗ } in O(n) time usinga Turing machine with two heads, but recognizing this language provably requires Ω(n2 ) time
on a standard machine with only one head. On the other hand, with much more sophisticatedtechniques, it is possible to simulate t steps of a Turing machine with k head, for any fixed
integer k, using only O(t log t) steps on a Turing machine with just two heads.
Multiple Tapes
We can also allow machines with multiple independent tapes, each with its own head. To
simulate such a machine with a single tape, we simply maintain each tape as an independent
track with its own head. Equivalently, we can simulate a machine with k tapes using a single
tape with 2k tracks, half storing the contents of the k tapes and half storing the positions of the kheads.
É T A P E # O N E
···
É
Î
···
É T A P E # T W O
···
É
Î
···
É T A P E # T H R E E ···ÉÎ···

Just as for multiple tracks, for any constant k, we can simulate t steps of an arbitrary Turingmachine with k independent tapes in Θ(t 2 ) steps on a standard Turing machine with one tape,and this quadratic blowup is unavoidable. Moreover, it is possible to simulate t steps on a
k-tape Turing machine using only O(t log t) steps on a two-tape Turing machine using moresophisticated techniques. (This faster simulation is easier to obtain for multiple independenttapes than for multiple heads on the same tape.)
By combining these tricks, we can simulate a Turing machine with any fixed number of tapes,
each of which may be infinite in one or both directions, each with any fixed number of heads andany fixed number of tracks, with at most a quadratic blowup in the running time.

12Models of Computation

Lecture 6: Turing Machines [Fa’16]

6.7

Simulating a Real Computer

6.7.1

Subroutines and Recursion

ÆÆÆUse a second tape/track as a “call stack”. Add save and restore actions. In the simplest
formulation, subroutines do not have local memory. To call a subroutine, save the current
state onto the call stack and jump to the first state of the subroutine. To return, restore (andremove) the return state from the call stack. We can simulate t steps of any recursive Turingmachine with O(t) steps on a multitape standard Turing machine, or in O(t 2 ) steps on astandard Turing machine.
More complex versions of this simulation can adapt to

6.7.2

ÆÆÆ

Random-Access Memory

Keep [address•data] pairs on a separate “memory” tape. Write address to an “address”
tape; read data from or write data to a “data” tape. Add new or changed [address•data]
pairs at the end of the memory tape. (Semantics of reading from an address that has neverbeen written to?)
Suppose all memory accesses require at most ` address and data bits. Then we cansimulate the kth memory access in O(k`) steps on a multitape Turing machine or in O(k2 `2 )steps on a single-tape machine. Thus, simulating t memory accesses in a random-accessmachine with `-bit words requires O(t 2 `) time on a multitape Turing machine, or O(t 3 `2 ) time
on a single-tape machine.

6.8

Universal Turing Machines

With all these tools in hand, we can now describe the pinnacle of Turing machine constructions:the universal Turing machine. For modern computer scientists, it’s useful to think of a universal
Turing machine as a "Turing machine interpreter written in Turing machine". Just as the input
to a Python interpreter is a string of Python source code, the input to our universal Turingmachine U is a string 〈M , w〉 that encodes both an arbitrary Turing machine M and a string w in
the input alphabet of M . Given these encodings, U simulates the execution of M on input w; inparticular,• U accepts 〈M , w〉 if and only if M accepts w.
• U rejects 〈M , w〉 if and only if M rejects w.

The next few pages, I will sketch a universal Turing machine U that uses the input alphabet{0, 1, [, ], •, |} and a somewhat larger tape alphabet (via marks on additional tracks). However,I will not require that the Turing machines that U simulates have similarly small alphabets, so
we first need a method to encode arbitrary input and tape alphabets.
Encodings
Let M = (Γ , , Σ, Q, start, accept, reject, δ) be an arbitrary Turing machine, with a single halfinfinite tape and a single read-write head. (I will consistently indicate the states and tape symbolsof M in slanted green to distinguish them from the upright red states and tape symbols of U.)
We encode each symbol a ∈ Γ as a unique string |a| of dlg(|Γ |)e bits. Thus, if Γ = {0, 1, $, x, },
we might use the following encoding:〈0〉 = 001,〈1〉 = 010,〈$〉 = 011,
13〈x〉 = 100,〈〉 = 000.

Models of Computation

Lecture 6: Turing Machines [Fa’16]

The input string w is encoded by its sequence of symbol encodings, with separators • between
every pair of symbols and with brackets [ and ] around the whole string. For example, with thisencoding, the input string 001100 would be encoded on the input tape as〈001100〉 = [001•001•010•010•001•001]
Similarly, we encode each state q ∈ Q as a distinct string 〈q〉 of dlg|Q|e bits. Without loss ofgenerality, we encode the start state with all 1s and the reject state with all 0s. For example, if
Q = {start, seek1, seek0, reset, verify, accept, reject}, we might use the following encoding:〈start〉 = 111〈verify〉 = 101〈seek1〉 = 010〈seek0〉 = 011〈accept〉 = 110〈reject〉 = 000〈reset〉 = 100

We encode the machine M itself as the string 〈M 〉 = [〈reject〉•〈〉]〈δ〉, where 〈δ〉 is theconcatenation of substrings [〈p〉•〈a〉|〈q〉•〈b〉•〈∆〉] encoding each transition δ(p, a) = (q, b, ∆)such that q 6= reject. We encode the actions ∆ = ±1 by defining 〈−1〉 := 0 and 〈+1〉 := 1.
Conveniently, every transition string has exactly the same length. For example, with the symboland state encodings described above, the transition δ(reset, $) = (start, $, +1) would be encodedas[100•011|001•011•1].
Our first example Turing machine for recognizing {0n 1n 0n | n ≥ 0} would be represented by
the following string (here broken into multiple lines for readability):[000•000][[001•001|010•011•1][001•100|101•011•1][010•001|010•001•1][010•100|010•100•1][010•010|011•100•1][011•010|011•010•1][011•100|011•100•1][011•001|100•100•1][100•001|100•001•0][100•010|100•010•0][100•100|100•100•0][100•011|001•011•1][101•100|101•011•1][101•000|110•000•0]]
Finally, we encode any configuration of M on U’s work tape by alternating between encodingsof states and encodings of tape symbols. Thus, each tape cell is represented by the string[〈q〉•〈a〉] indicating that (1) the cell contains symbol a; (2) if q 6= reject, then M ’s head islocated at this cell, and M is in state q; and (3) if q = reject, then M ’s head is located somewhere
else. Conveniently, each cell encoding uses exactly the same number of bits. We also surroundthe entire tape encoding with brackets [ and ].
For example, with the encodings described above, the initial configuration (start, 001100, 0)
Î
for our first example Turing machine would be encoded on U’s tape as follows.

[[111•001][000•001][000•010][000•010][000•001][000•001]]
|
{z
}|
{z
}|
{z
}|
{z
}|
{z
}|
{z
}
start 0reject 0

reject 1

reject 1

reject 0

reject 0

Similarly, the intermediate configuration (reset, $0x1x0, 3) would be encoded as follows:Î[[000•011][000•011][000•100][010•010][000•100][000•001]]
|
{z
}|
{z
}|
{z
}|
{z
}|
{z
}|
{z
}
reject $reject 0

reset 1

reject x

14

reject x

reject 0

Models of Computation

Lecture 6: Turing Machines [Fa’16]

Input and Execution
Without loss of generality, we assume that the input to our universal Turing machine U is given
on a separate read-only input tape, as the encoding of an arbitrary Turing machine M followedby an encoding of its input string x. Notice the substrings [[ and ]] each appear only only once
on the input tape, immediately before and after the encoded transition table, respectively. U also
has a read-write work tape, which is initially blank.
We start by initializing the work tape with the encoding 〈start, x, 0〉 of the initial configurationof M with input x. First, we write [[〈start〉•. Then we copy the encoded input string 〈x〉 onto
the work tape, but we change the punctuation as follows:• Instead of copying the left bracket [, write [[〈start〉•.

• Instead of copying each separator •, write ][〈reject〉•• Instead of copying the right bracket ], write two right brackets ]].
The state encodings 〈start〉 and 〈reject〉 can be copied directly from the beginning of 〈M 〉(replacing 0s for 1s for 〈start〉). Finally, we move the head back to the start of U’s tape.
At the start of each step of the simulation, U’s head is located at the start of the work tape.
We scan through the work tape to the unique encoded cell [〈p〉•〈a〉] such that p 6= reject.
Then we scan through the encoded transition function 〈δ〉 to find the unique encoded tuple[〈p〉•〈a〉|〈q〉•〈b〉•〈∆〉] whose left half matches our the encoded tape cell. If there is no suchtuple, then U immediately halts and rejects. Otherwise, we copy the right half 〈q〉•〈b〉 of thetuple to the work tape. Now if q = accept, then U immediately halts and accepts. (We don’t
bother to encode reject transformations, so we know that q 6= reject.) Otherwise, we transfer
the state encoding to either the next or previous encoded cell, as indicated by M ’s transition
function, and then continue with the next step of the simulation.
During the final state-copying phase, we ever read two right brackets ]], indicating that
we have reached the right end of the tape encoding, we replace the second right bracket with[〈reject〉•〈〉]] (mostly copied from the beginning of the machine encoding 〈M 〉) and thenscan back to the left bracket we just wrote. This trick allows our universal machine to pretendthat its tape contains an infinite sequence of encoded blanks [〈reject〉•〈〉] instead of actual
blanks .
ExampleAs an illustrative example, suppose U is simulating our first example Turing machine M on
the input string 001100. The execution of M on input w eventually reaches the configuration(seek1, $$x1x0, 3). At the start of the corresponding step in U’s simulation, U is in the followingÎ
configuration:[[000•011][000•011][000•100][010•010][000•100][000•001]]
ÎFirst U scans for the first encoded tape cell whose state is not reject. That is, U repeatedly
compares the first half of each encoded state cell on the work tape with the prefix [〈reject〉• of
the machine encoding 〈M 〉 on the input tape. U finds a match in the fourth encoded cell.

[[000•011][000•011][000•100][010•010][000•100][000•001]]
Î

Next, U scans the machine encoding 〈M 〉 for the substring [010•010 matching the current encoded cell. U eventually finds a match in the left size of the the encoded transition15

Models of Computation

Lecture 6: Turing Machines [Fa’16][010•010|011•100•1]. U copies the state-symbol pair 011•100 from the right half of thisencoded transition into the current encoded cell. (The underline indicates which symbols arechanged.)[[000•011][000•011][000•100][011•100][000•100][000•001]]
Î
The encoded transition instructs U to move the current state encoding one cell to the right. (Theunderline indicates which symbols are changed.)[[000•011][000•011][000•100][000•100][011•100][000•001]]
ÎFinally, U scans left until it reads two left brackets [[; this returns the head to the left end of
the work tape to start the next step in the simulation. U’s tape now holds the encoding of M ’s
configuration (seek0, $$xxx0, 4), as required.
Î

[[000•011][000•011][000•100][000•100][011•100][000•001]]
Î

Exercises
In the following problems, a standard Turing machine has a single semi-infinite tape, one
read-write head, and the input alphabet Σ = {0, 1}. For problems that ask you to construct a
standard Turing machine, you may assume without loss of generality that the initial tape contains
a special symbol É just to the left of the input string, indicating the left end of the tape; theread-write head starts just to the right of this symbol. For problems that ask you to simulate astandard Turing machine, you may assume without loss of generality that the tape alphabet is{0, 1,}.

Turing Machine Programming
1. Describe standard Turing machines that decide each of the following languages:(a) Palindromes over the alphabet {0, 1}(b) {ww | w ∈ {0, 1}∗ }(c) 0a 1 b 0a b | a, b ∈ N

2. Let 〈n〉2 denote the binary representation of the non-negative integer n. For example,〈17〉2 = 10001 and 〈42〉2 = 101010. Describe standard Turing machines that computethe following functions from {0, 1}∗ to {0, 1}∗ :(a) w 7→ www(b) 1n 01m 7→ 1mn(c) 1n 7→ 12n(d) 1n 7→ 〈n〉2(e) 0∗ 〈n〉2 7→ 1n(f) 〈n〉2 7→ 〈n2 〉216Models of Computation

Lecture 6: Turing Machines [Fa’16]

3. Describe standard Turing machines that write each of the following infinite streams of bits
onto their tape. Specifically, for each integer n, there must be a finite time after which thefirst n symbols on the tape always match the first n symbols in the target stream.
(a) An infinite stream of 1s(b) 0101101110111101111101111110 . . . , where the nth block of 1s has length n.
(c) The stream of bits whose nth bit is 1 if and only if n is prime.
(d) The Thue-Morse sequence T0 • T1 • T2 • T3 · · · , where
if n = 0
0
Tn := 1
if n = 1T•Totherwisen−1

n−1

where w indicates the binary string obtained from w by flipping every bit. Equivalently,
the nth bit of the Thue Morse sequence if 0 if the binary representation of n has aneven number of 1s and 1 otherwise.

0110100110010110100101100110100110010110011010010110 . . .
(e) The Fibonacci sequence F0 • F1 • F2 • F3 · · · , where
if n = 0
0
Fn := 1
if n = 1F•Fotherwisen−2

n−1

01011010110110101101011011010110110101101011011010101 . . .

Simulation by “Weaker” Machines
4. A two-stack machine is a Turing machine with two tapes with the following restrictedbehavior. At all times, on each tape, every cell to the right of the head is blank, and every
cell at or to the left of the head is non-blank. Thus, a head can only move right by writinga non-blank symbol into a blank cell; symmetrically, a head can only move left by erasing
the rightmost non-blank cell. Thus, each tape behaves like a stack. To avoid underflow,
there is a special symbol at the start of each tape that cannot be overwritten. Initially, onetape contains the input string, with the head at its last symbol, and the other tape is empty(except for the start-of-tape symbol).
Prove that any standard Turing machine can be simulated by a two-stack machine.
That is, given any standard Turing machine M , describe a two-stack machine M 0 that
accepts and rejects exactly the same input strings as M .
5. A k-register machine is a finite-state automaton with k non-negative integer registers.
Formally, a k-register machine consists of a finite set Q of states (which include start,
accept, and reject) and a transition function
δ : Q × {0, 1}k → Q × {halve, nop, double, double+1}k17Models of Computation

Lecture 6: Turing Machines [Fa’16]that takes the internal state and the signs of the registers as input, and produces a newinternal state and changes to the registers as output. The instructions halve, nop, double,
and double+1 change any register with value n to n/2, n, 2n, and 2n + 1, respectively.
For example, if δ(p, 0, 1, 0, 1) = (q, halve, nop, halve, double+1), then from the configuration (p, 0, 2, 3, 1), the machine would transition to (q, 1, 2, 1, 3).
Prove that any standard Turing machine (with suitably encoded input and output) canbe simulated by a two-register machine. The input to the register machine is encoded inreversed binary in one of the registers, so the parity of the register value is the first input
bit; the other register is initially zero.
6. A k-counter machine (also known as a Minksy machine) is a finite-state automaton withk non-negative integer registers. Formally, a k-counter machine consists of a finite set Q ofstates (which include start, accept, and reject) and a transition function
δ : Q × {0, +}k → Q × {inc, nop, dec}kthat takes the internal state and the signs of the registers as input, and produces a newinternal state and changes to the registers as output. The instructions inc, nop, and decchange any register with value n to n + 1, n, and n − 1, respectively. The transition function
must forbid decrementing a register whose value is already zero.
For example, if δ(p, 0, +, +, +) = (q, inc, dec, nop, dec), then from the configuration(p, 0, 2, 3, 1), the machine would transition to (q, 1, 1, 3, 0).
(a) Prove that any standard Turing machine (with suitably encoded input and output) canbe simulated by a three-counter machine. [Hint: Simulate a two-register machine,using the third counter for scratch work.](b) Prove that any three-counter machine (with suitably encoded input and output) canbe simulated by a two-counter machine. [Hint: Store all three counters in a single
integer of the form 2a 3 b 5c , and use the other counter for scratch work.]
? (c)

Æ

Prove that a three-counter machine can compute a suitable encoding of any computablefunction. Specifically, for any computable function f : N → N, prove there is a threecounter machine M that transforms any input (n, 0, 0) into ( f (n), 0, 0). [Hint: Firsttransform (n, 0, 0) to (2n , 0, 0) using all three counters; then run a two- (or three)counter TM simulation to obtain (2 f (n) , 0, 0); and finally transform (2 f (n) , 0, 0) to( f (n), 0, 0) using all three counters.](d) Prove that not two-counter machine can transform (n, 0) to (2n , 0). This impossiblity
result was independently proved by Bārzdin, š in 1963, Yao in 1971, and Schroeppel in1972. ⁵

7. A hole-punch Turing machine is a standard Turing machine with two restrictions. First, thetape alphabet has only two symbols  and , and thus the input alphabet is the singleton
⁵Ja. M. Barzdin0 [Jānis Bārzdin, š]. Ob odnom klasse mašin T0 ûringa (mašiny Minskogo) [On a class of Turingmachines (Minsky machines)]. Algebra i Logika 1(6):42–51, 1963. In Russian. Sorry.
Oscar H. Ibarra, Nicholas Q. Trân. A note on simple programs with two variables. Theoretical Computer Science
112(2): 391–397, 1993.
Rich Schroeppel. A two counter machine cannot calculate 2N . Artificial Intelligence Memo 257, MIT AI Lab, May
1972. [Schroeppel claims that the same result was independently proved by Frances Yao in 1971.

18

Models of Computation

Lecture 6: Turing Machines [Fa’16]

set {}. Second, the machine can never write a blank () over a non-blank (); intuitively,
the machine can punch new holes (s) into the tape, but it cannot erase holes.
Prove that any standard Turing machine (with a unary input alphabet) can be simulated
by a hole-punch Turing machine.
8. A tag-Turing machine has two heads: one can only read, the other can only write. Initially,
the read head is located at the left end of the tape, and the write head is located at the first
blank after the input string. At each transition, the read head can either move one cell tothe right or stay put, but the write head must write a symbol to its current cell and move
one cell to the right. Neither head can ever move to the left.
Prove that any standard Turing machine can be simulated by a tag-Turing machine.
That is, given any standard Turing machine M , describe a tag-Turing machine M 0 that
accepts and rejects exactly the same input strings as M .
9. ? (a) Prove that any standard Turing machine can be simulated by a standard Turingmachine with only three states. [Hint: Keep an encoding of the state of the simulated
machine on the tape of the simulating machine.]Æ(b) Prove that any standard Turing machine can be simulated by a standard Turingmachine with only two states.

Simulating “Stronger” Machines
10. A two-dimensional Turing machine uses an infinite two-dimensional grid of cells as
the tape; at each transition, the head can move from its current cell to any of its
four neighbors on the grid. The transition function of such a machine has the form
δ : Q × Γ → Q × Γ × {↑, ←, ↓, →}, where the arrows indicate which direction the head should
move.
(a) Prove that any two-dimensional Turing machine can be simulated by a standard
Turing machine.
(b) Suppose further that we endow our two-dimensional Turing machine with thefollowing additional actions, in addition to moving the head:• Insert row: Move all symbols on or above the row containing the head up one
row, leaving the head’s row blank.
• Insert column: Move all symbols on or to the right of the column containing thehead one column to the right, leaving the head’s column blank.
• Delete row: Move all symbols above the row containing the head down one row,deleting the head’s row of symbols.
• Delete column: Move all symbols the right of the column containing the head
one column to the right, deleting the head’s column of symbols.
Show that any two-dimensional Turing machine that can add an delete rows can be
simulated by a standard Turing machine.
11. A binary-tree Turing machine uses an infinite binary tree as its tape; that is, every cell inthe tape has a left child and a right child. At each step, the head moves from its current
19Models of Computation

Lecture 6: Turing Machines [Fa’16]

cell to its Parent, its Left child, or to its Right child. Thus, the transition function of such amachine has the form δ : Q × Γ → Q × Γ × {P, L, R}. The input string is initially given along
the left spine of the tape.
Show that any binary-tree Turing machine can be simulated by a standard Turingmachine.
12. A stack-tape Turing machine uses an semi-infinite tape, where every cell is actually the
top of an independent stack. The behavior of the machine at each iteration is governed by
its internal state and the symbol at the top of the current cell’s stack. At each transition,
the head can optionally push a new symbol onto the stack, or pop the top symbol off thestack. (If a stack is empty, its “top symbol” is a blank and popping has no effect.)Show that any stack-tape Turing machine can be simulated by a standard Turingmachine. (Compare with Problem 4!)
13. A tape-stack Turing machine has two actions that modify its work tape, in addition tosimply writing individual cells: it can save the entire tape by pushing in onto a stack, and it
can restore the entire tape by popping it off the stack. Restoring a tape returns the content
of every cell to its content when the tape was saved. Saving and restoring the tape do notchange the machine’s state or the position of its head. If the machine attempts to “restore”
the tape when the stack is empty, the machine crashes.
Show that any tape-stack Turing machine can be simulated by a standard Turingmachine.

© Copyright 2018 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms/ for the most recent revision.

20Models of Computation

Lecture 7: Undecidability [Fa’16]
I said in my haste, All men are liars.
— Psalms 116:11 (King James Version)
Some problems are so complex that you have to be highly intelligent
and well informed just to be undecided about them.
— Laurence Johnston Peter, Peter’s Almanac (September 24, 1982)“Proving or disproving a formula—once you’ve encrypted the formula into numbers,that is—is just a calculation on that number. So it means that the answer to the questionis, no! Some formulas cannot be proved or disproved by any mechanical process! So I
guess there’s some point in being human after all!”Alan looked pleased until Lawrence said this last thing, and then his face collapsed.
“Now there you go making unwarranted assumptions.”— Neal Stephenson, Cryptonomicon (1999)
No matter how P might perform, Q will scoop it:
Q uses P ’s output to make P look stupid.
Whatever P says, it cannot predict Q:
P is right when it’s wrong, and is false when it’s true!
— Geoffrey S. Pullum, “Scooping the Loop Sniffer” (2000)

ÆÆÆ

Rewrite in the language of algorithms instead of the language of Turing machines, using“source code” instead of “encoding” everywhere. Formulation in terms of TMs makes almost
everything much more complicated than it needs to be. (The dovetail/product construction in
the proof of Lemma 4 may be an exception.)7

Undecidability

Perhaps the single most important result in Turing’s remarkable 1936 paper that introduces Turingmachines is his observation that there are problems that cannot be solved by any algorithm.
Turing’s canonical example of an undecidable problem was the halting problem, which asks
whether a given Turing machine halts when given a particular input string. Among otherconsequences, Turing’s undecidability result provided an elegant negative solution to Hilbert’s
Entscheidungsproblem, which asked for an algorithm to decide whether a given statement of
first-order logic is true—no such algorithm exists.

7.1

Acceptable versus Decidable

Recall that there are three possible outcomes for a Turing machine M running on any particular
input string w: acceptance, rejection, and divergence. Every Turing machine M immediately
defines four different languages (over the input alphabet Σ of M ):• The accepting language Accept(M ) := {w ∈ Σ∗ | M accepts w}• The rejecting language Reject(M ) := {w ∈ Σ∗ | M rejects w}• The halting language Halt(M ) := Accept(M ) ∪ Reject(M )• The diverging language Diverge(M ) := Σ∗ \ Halt(M )For any language L, the sentence “M accepts L” means Accept(M ) = L, and the sentence “Mdecides L” means Accept(M ) = L and Diverge(M ) = ∅.
© Copyright 2018 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms/ for the most recent revision.

1Models of Computation

Lecture 7: Undecidability [Fa’16]

Now let L be an arbitrary language. We say that L is acceptable (or semi-computable, orsemi-decidable, or recognizable, or listable, or recursively enumerable) if some Turing machine
accepts L, and unacceptable otherwise. Similarly, L is decidable (or computable, or recursive) if
some Turing machine decides L, and undecidable otherwise.

7.2

Lo, I Have Become Death, Stealer of Pie

There is a subtlety in the definitions of “acceptable” and “decidable” that many beginners miss:A language can be decidable even if we can’t exhibit a specific Turing machine decides it. As acanonical example, consider the language Π = {w | 1|w| appears in the binary expansion of π}.
Despite appearances, this language is decidable! There are only two cases to consider:• Suppose there is an integer N such that the binary expansion of π contains the substring
1N but does not contain the substring 1N +1 . Let MN be the Turing machine with N + 3
states {0, 1, . . . , N , accept, reject}, start state 0, and the following transition function:
if a = acceptδ(q, a) = rejectif a 6=  and q = n(q + 1, a, +1) otherwise
This machine correctly decides Π.
• Suppose the binary expansion of π contains arbitrarily long substrings of 1s. Then any
Turing machine that accepts all inputs correctly decides Π.
We have no idea which of these machines correctly decides Π, but one of them does, and that’s
enough!

7.3

Useful Properties

This subsection lists several simple but useful properties of (un)decidable and (un)acceptablelanguages. Almost all of these properties follow from routine definition-chasing; readers arestrongly encouraged to try to prove each lemma themselves before reading ahead.
One might reasonably ask why we don’t also define “rejectable” and “haltable” languages.
The following lemma, whose proof is an easy exercise (hint, hint), implies that these sets areboth identical to the acceptable languages.
Lemma 1. Let M be an arbitrary Turing machine.
(a) There is a Turing machine M R such that Accept(M R ) = Reject(M ) and Reject(M R ) =Accept(M ).
(b) There is a Turing machine M A such that Accept(M A) = Accept(M ) and Reject(M A) = ∅.
(c) There is a Turing machine M H such that Accept(M H ) = Halt(M ) and Reject(M H ) = ∅.
The decidable languages have several fairly obvious useful closure properties.
Lemma 2. If L and L 0 are decidable, then L ∪ L 0 , L ∩ L 0 , L \ L 0 , and L 0 \ L are also decidable.

Proof: Let M and M 0 be Turing machines that decide L and L 0 , respectively. We can build a
Turing machine M∪ that decides L ∪ L 0 as follows. First, M∪ copies its input string w onto asecond tape. Then M∪ runs M on input w (on the first tape), and then runs M 0 on input w (onthe second tape). If either M or M 0 accepts, then M∪ accepts; if both M and M 0 reject, then M∪
rejects.
The other three languages are similar.
2Models of Computation

Lecture 7: Undecidability [Fa’16]

Corollary 3. The following hold for all languages L and L 0 .
(a) If L ∩ L 0 is undecidable and L 0 is decidable, then L is undecidable.
(b) If L ∪ L 0 is undecidable and L 0 is decidable, then L is undecidable.
(c) If L \ L 0 is undecidable and L 0 is decidable, then L is undecidable.
(d) If L 0 \ L is undecidable and L 0 is decidable, then L is undecidable.
Unfortunately, acceptable languages are not quite as well-behaved as decidable languages,
thanks to the subtle distinction between rejecting a string and not accepting a string.
Lemma 4. For all acceptable languages L and L 0 , the languages L ∪ L 0 and L ∩ L 0 are also
acceptable.
Proof: Let M and M 0 be Turing machines that decide L and L 0 , respectively. We can build a
Turing machine M∩ that decides L ∩ L 0 as follows. First, M∩ copies its input string w onto asecond tape. Then M∩ runs M on input w using the first tape, and then runs M 0 on input w using
the second tape. If both M and M 0 accept, then M∩ accepts; if either M or M 0 reject, then M∩
rejects; if either M or M 0 diverge, then M∩ diverges (automatically).
The construction for L ∪ L 0 is more subtle; instead of running M and M 0 in series, we mustrun them in parallel. Like M∩ , the new machine M∪ starts by copying its input string w onto
a second tape. But then M∪ runs M and M 0 simultaneously; with each step of M∪ simulating
both one step of M on the first tape and one step of M 0 on the second. Ignoring the states andtransitions needed for initialization, the state set of M∪ is the product of the state sets of M
and M 0 , and the transition function is
if q = accept or q0 = accept0
accept∪δ∪ (q, a, q0 , a0 ) = reject∪
if q = reject and q0 = reject0(δ(q, a), δ0 (q0 , a0 )) otherwise
Thus, M∪ accepts as soon as either M or M 0 accepts, and rejects only after both M or M 0
reject.

Lemma 5. An acceptable language L is decidable if and only if Σ∗ \ L is also acceptable.

Proof: Let M and M be Turing machines that accept L and Σ∗ \ L, respectively. Following theprevious proof, we construct a new Turing machine M ∗ that copies its input onto a second tape,and then simulates M and M 0 in parallel on the two tapes. If M accepts, then M ∗ accepts; if M
accepts, then M ∗ rejects. Since every string is accepted by either M or M , we conclude that M ∗decides L.
The other direction follows immediately from Lemma 1.


7.4

Code is Data; Data is Code

Perhaps the single most important observation in developing these undecidability results—andone of the most important observations in computer science more broadly—is that Turingmachines can be encoded as strings. At one level, this observation is completely trivial: Any
written description of a Turing machine is a string, and modern code is just a sequence of bytes,
stored in a file like any other data. But this apparently trivial observation is actually incredibly
powerful.
Most natural encodings of Turing machines have three important properties.
3Models of Computation

Lecture 7: Undecidability [Fa’16]• Unique: Different Turing machines are encoded as different strings.
• Modifiable: We can algorithmically modify any Turing machine M , given the encodingof M as input. For example, there are algorithms to swap the accept and reject states of any
Turing machine, or to add new states and transitions representing pre- and post-processing
phases, or to build a new machine that calls M as a subroutine, or to build a new machinethat runs several copies of M in parallel.
• Executable: There is a fixed universal Turing machine U that can simulate the behaviorof an arbitrary Turing machine M , given the encodings of M and w as input. For example,
if we decided to encode Turing machines as Python programs, then U would be a Pythoninterpreter.
The precise details of the encoding are unimportant, but for the sake of concreteness, letme describe a natural encoding of Turing machines as strings over the six-character alphabet{0, 1, {, •, }}. Let M = (Γ , , Σ, Q, start, accept, reject, δ) be an arbitrary Turing machine, witha single half-infinite tape and a single read-write head. (I will consistently indicate the states
and tape symbols of M in slanted green to distinguish them from the upright red symbols in theencoding alphabet.)• We encode each symbol a ∈ Γ as a unique string |a| of dlg(|Γ |)e bits. For example, ifΓ = {0, 1, $, x, }, we might use the following encoding:〈0〉 = 001,〈1〉 = 010,〈$〉 = 011,〈x〉 = 100,〈〉 = 000.

• Similarly, we encode each state q ∈ Q as a distinct string 〈q〉 of dlg|Q|e bits. Without
loss of generality, we encode the start state with all 1s and the reject state with all 0s.
For example, if Q = {start, seek1, seek0, reset, verify, accept, reject}, we might use thefollowing encoding:〈start〉 = 111〈verify〉 = 101〈seek1〉 = 010〈accept〉 = 110〈seek0〉 = 011〈reject〉 = 000〈reset〉 = 100• Finally, we encode the machine M itself as the string 〈M 〉 = {〈reject〉•〈〉}〈δ〉, where 〈δ〉is the concatenation of substrings {〈p〉•〈a〉•〈q〉•〈b〉•〈∆〉} encoding each transition
δ(p, a) = (q, b, ∆) such that q 6= reject. We encode the actions ∆ = ±1 by defining〈−1〉 := 0 and 〈+1〉 := 1. Conveniently, every transition string has exactly the samelength. For example, with the symbol and state encodings described above, the transition
δ(reset, $) = (start, $, +1) would be encoded as the string{100•011•001•011•1}.
Our first example Turing machine for recognizing {0n 1n 0n | n ≥ 0} would be represented
by the following string (broken into multiple lines for readability):{000•000}{{001•001•010•011•1}{001•100•101•011•1}{010•001•010•001•1}{010•100•010•100•1}{010•010•011•100•1}{011•010•011•010•1}{011•100•011•100•1}{011•001•100•100•1}{100•001•100•001•0}{100•010•100•010•0}{100•100•100•100•0}{100•011•001•011•1}{101•100•101•011•1}{101•000•110•000•0}}4Models of Computation

Lecture 7: Undecidability [Fa’16]

Building a universal Turing machine U that uses this encoding is more a matter of careful
bookkeeping than real insight. We can encode any configuration of M on U’s work tape byencoding each cell of M ’s tape as a string {〈q〉•〈a〉} indicating that (1) the cell contains symbol a;(2) if q 6= reject, then M ’s head is located at this cell, and M is in state q; and (3) if q = reject,then M ’s head is located somewhere else. We also surround the entire tape encoding withbrackets { and }. For example, the initial configuration (start, 00110, 0) for our example TuringÎmachine would be encoded as follows.
〈start, 00110, 0〉 = {{111•001}{000•001}{000•010}{000•010}{000•001}}
Î
{z
}|
{z
}|
{z
}|
{z
}|
{z
}
|
start 0reject 0

reject 1

reject 1

reject 0

Similarly, the intermediate configuration (reset, $0x1x, 3) would be encoded as follows:Î〈reset, $$x1x, 3〉 = {{000•011}{000•011}{000•100}{010•010}{000•100}}
Î
|
{z
}|
{z
}|
{z
}|
{z
}|
{z
}
reject $reject 0

reject x

reset 1

reject x

To simulate one step of M ’s execution, we (1) find the location of the head (or reject if the headhas vanished), (2) look up the transition for the state-symbol pair at the head, and (3) update
the current cell and one of its neighbors to reflect the transition. The remaining grungy details
are left as an exercise.

7.5

Self-Haters Gonna Self-Hate

A Turing machine encoding 〈M 〉 is just a string, and any string (over the correct alphabet) canbe used as the input to a Turing machine. Thus, a suitable encoding of any Turing machine canbe used as the input to any Turing machine. In particular:
The encoding 〈M〉 of Turing machine M
can be used as input to the same Turing machine M.
Turing used this observation about self-reference to derive his first undecidable language asfollows. Let’s say that a Turing machine M is self-rejecting if it rejects its own encoding 〈M 〉.
Let SelfReject be the set of all encodings of self-rejecting Turing machines:

SelfReject := 〈M 〉 M rejects 〈M 〉Theorem 6. SelfReject is undecidable.

Proof: Suppose to the contrary that there is a Turing machine SR that decides SelfReject.
Then by definition, Accept(SR) = SelfReject and Diverge(SR) = ∅. More explicitly, for any
Turing machine M ,• SR accepts 〈M 〉 ⇐⇒ M rejects 〈M 〉, and• SR rejects 〈M 〉 ⇐⇒ M does not reject 〈M 〉.

In particular, these equivalences must hold when M is the machine SR. Thus,• SR accepts 〈SR〉 ⇐⇒ SR rejects 〈SR〉, and• SR rejects 〈SR〉 ⇐⇒ SR does not reject 〈SR〉.

In short, SR accepts 〈SR〉 if and only if SR rejects 〈SR〉, which is impossible! The only logicalconclusion is that the Turing machine SR does not exist.
5Models of Computation

7.6

Lecture 7: Undecidability [Fa’16]

Aside: Uncountable Barbers

Turing’s proof by contradiction is an avatar of the famous diagonalization argument that
uncountable sets exist, published by Georg Cantor in 1891. Indeed, SelfReject is sometimes
called “the diagonal language”. Recall that a function f : A → B is a surjection1 if f (A) = { f (a) |a ∈ A} = B.
Cantor’s Theorem. Let f : X → 2X be an arbitrary function from an arbitrary set X to its
power set. This function f is not a surjection.
Proof: Fix an arbitrary function f : X → 2X . Call an element x ∈ X happy if x ∈ f (x) and sad
if x 6∈ f (x). Let Y be the set of all sad elements of X ; that is, for every element x ∈ X , we havex ∈ Y ⇐⇒ x 6∈ f (x).
For the sake of argument, suppose f is a surjection. Then (by definition of surjection) there must
be an element y ∈ X such that f ( y) = Y . Then for every element x ∈ X , we havex ∈ f ( y) ⇐⇒ x 6∈ f (x).
In particular, the previous equivalence must hold when x = y:y ∈ f ( y) ⇐⇒ y 6∈ f ( y).
We have a contradiction! We conclude that f is not a surjection after all.



Now let X = Σ∗ , and define the function f : X → 2X as follows:¨
Accept(M ) if w = 〈M 〉 for some Turing machine M
f (w) :=∅
if w is not the encoding of a Turing machine
Cantor’s theorem immediately implies that not all languages are acceptable.
Alternatively, let X be the set of all Turing machines that halt on all inputs. For any Turingmachine M ∈ X , let f (M ) be the set of all Turing machines N ∈ X such that M accepts theencoding 〈N 〉. Then a Turing machine M is sad if it rejects its own encoding 〈M 〉; thus, Y isessentially the set SelfReject. Cantor’s argument now immediately implies that no Turingmachine decides the language SelfReject.
The core of Cantor’s diagonalization argument also appears in the “barber paradox” popularized by Bertrand Russell in the 1910s. In a certain small town, every resident has a haircut on
Haircut Day. Some residents cut their own hair; others have their hair cut by another resident of
the same town. To obtain an official barber’s license, a resident must cut the hair of all residents
who don’t cut their own hair, and no one else. Given these assumptions, we can immediately
conclude that there are no licensed barbers. After all, who would cut the barber’s hair?
To map Russell’s barber paradox back to Cantor’s theorem, let X be the set of residents, andlet f (x) be the set of residents who have their hair cut by x; then a resident is sad if they do not
cut their own hair. To prove that SelfReject is undecidable, replace “resident” with “a Turingmachine that halts on all inputs”, and replace “A cuts B’s hair” with “A accepts 〈B〉”.
1more commonly, flouting all reasonable standards of grammatical English, “an onto function”

6Models of Computation

7.7

Lecture 7: Undecidability [Fa’16]

Just Don’t Know What to Do with Myself

Similar diagonal arguments imply that three other languages are also undecidable:

SelfAccept := 〈M 〉 M accepts 〈M 〉
SelfHalt := 〈M 〉 M halts on 〈M 〉
SelfDiverge := 〈M 〉 M diverges on 〈M 〉The proofs for these three languages are not quite as direct as the proof for SelfReject; eachfictional deciding machine requires a small modification to create the contradiction.
Theorem 7. SelfAccept is undecidable.
Proof: For the sake of argument, suppose there is a Turing machine SA such that Accept(SA) =SelfAccept and Diverge(M ) = ∅. Let SAR be the Turing machine obtained from SA by
swapping its accept and reject states (as in the proof of Lemma 1). Then Reject(SAR ) =SelfAccept and Diverge(SAR ) = ∅. It follows that SAR rejects 〈SAR 〉 if and only if SAR accepts〈SAR 〉, which is impossible.

Theorem 8. SelfHalt is undecidable.
Proof: Suppose to the contrary that there is a Turing machine SH such that Accept(SH) =SelfHalt and Diverge(SH) = ∅. Let SH X be the Turing machine obtained from SH byredirecting every transition to accept to a new hanging state hang, and then redirecting everytransition to reject to accept. Then Accept(SH X ) = Σ∗ \ SelfHalt and Reject(SH X ) = ∅.
It follows that SH X accepts 〈SH X 〉 if and only if SH X does not halt on 〈SH X 〉, and we have acontradiction.

Theorem 9. SelfDiverge is unacceptable and therefore undecidable.
Proof: Suppose to the contrary that there is a Turing machine SD such that Accept(M ) =SelfDiverge. Let S DA be the Turing machine obtained from M by redirecting every transition
to reject to a new hanging state hang such that δ(hang, a) = (hang, a, +1) for every symbol a.
Then Accept(S DA) = SelfDiverge and Reject(SDA) = ∅. It follows that SDA accepts 〈SDA〉 if
and only if S DA does not halt on 〈S DA〉, which is impossible.

?

7.8

Nevertheless, Acceptable

Our undecidability argument for SelfDiverge actually implies the stronger result that SelfDiverge is unacceptable; we never assumed that the hypothetical accepting machine SD halts on
all inputs. However, we can use or modify our universal Turing machine U to accept the otherthree self-referential languages.
Theorem 10. SelfAccept is acceptable.
Proof: We describe a Turing machine SA that accepts the language SelfAccept. Given any
string w as input, SA first verifies that w is the encoding of a Turing machine. If w is not
the encoding of a Turing machine, then SA diverges. Otherwise, w = 〈M 〉 for some Turingmachine M ; in this case, SA writes the string ww = 〈M 〉〈M 〉 onto its tape and passes control tothe universal Turing machine U. U then simulates M (the machine encoded by the first half of7

Models of Computation

Lecture 7: Undecidability [Fa’16]

its input) on the string 〈M 〉 (the second half of its input).2 In particular, U accepts 〈M , M 〉 if andonly if M accepts 〈M 〉. We conclude that SR accepts 〈M 〉 if and only if M accepts 〈M 〉.

Theorem 11. SelfReject is acceptable.
Proof: Let U R be the Turing machine obtained from our universal machine U by swapping theaccept and reject states. We describe a Turing machine SR that accepts the language SelfReject
as follows. SR first verifies that its input string w is the encoding of a Turing machine anddiverges if not. Otherwise, SR writes the string ww = 〈M , M 〉 onto its tape and passes control to
the reversed universal Turing machine U R . Then U R accepts 〈M , M 〉 if and only if M rejects 〈M 〉.
We conclude that SR accepts 〈M 〉 if and only if M rejects 〈M 〉.
Finally, because SelfHalt is the union of two acceptable languages, SelfHalt is also
acceptable.

7.9

The Halting Problem via Reduction

Now consider the following related languages:3
Accept := 〈M , w〉
Reject := 〈M , w〉Halt := 〈M , w〉
Diverge := 〈M , w〉

M accepts w
M rejects w
M halts on w
M diverges on w

Deciding the language Halt is usually called the halting problem: Given a program M and an
input w to that program, does the program halt? This problem may seem trivial; why not just run
the program and see? More formally, why not just pass the input string 〈M , x〉 to our universal
Turing machine U? That strategy works perfectly if we just want to accept Halt, but we actuallywant to decide Halt; if M is not going to halt on w, we still want an answer in a finite amount oftime. Sadly, we can’t always get what we want.
Theorem 12. Halt is undecidable.
Proof: Suppose to the contrary that there is a Turing machine H that decides Halt. Then we
can use H to build another Turing machine SH that decides the language SelfHalt. Given any
string w, the machine SH first verifies that w = 〈M 〉 for some Turing machine M (rejecting ifnot), then writes the string ww = 〈M , M 〉 onto the tape, and finally passes control to H. But
SelfHalt is undecidable, so no such machine SH exists. We conclude that H does not exist
either.

Nearly identical arguments imply that the languages Accept, Reject, and Diverge areundecidable.
2To simplify the presentation, I am implicitly assuming here that 〈M 〉 = 〈〈M 〉〉. Without this assumption, we needa Turing machine that transforms an arbitrary string w ∈ Σ∗M into its encoding 〈w〉 ∈ Σ∗U ; building such a Turingmachine is straightforward.
3Many sources including Sipser and Wikipedia uses the shorter name A T M instead of Accept, but uses HALTT M
instead of Halt. I have no idea why Sipser thought four-letter names are okay, but six-letter names are not. The
subscript TM is just a reminder that these are languages of Turing machine encodings, as opposed to encodings ofDFAs or some other machine model.

8Models of Computation

Lecture 7: Undecidability [Fa’16]

Here we have our first example of an undecidability proof by reduction. Specifically, we
reduced the language SelfHalt to the language Halt. More generally, to reduce one language
X to another language Y , we assume (for the sake of argument) that there is a program PY that
decides Y , and we write another program that decides X , using PY as a black-box subroutine.
If later we discover that Y is decidable, we can immediately conclude that X is decidable.
Equivalently, if we later discover that X is undecidable, we can immediately conclude that Y is
undecidable.
To prove that a language L is undecidable,
reduce a known undecidable language to L.
Perhaps the most confusing aspect of reduction arguments is that the languages we want toprove undecidable nearly (but not quite) always involve encodings of Turing machines, while atthe same time, the programs that we build to prove them undecidable are also Turing machines.
Our proof that Halt is undecidable involved three different machines:• The hypothetical Turing machine H that decides Halt.
• The new Turing machine SH that decides SelfHalt, using H as a subroutine.
• The Turing machine M whose encoding is the input to H.
It is incredibly easy to get confused about which machines are playing each in the proof. Therefore,
it is absolutely vital that we give each machine in a reduction proof a unique and mnemonic
name, and then always refer to each machine by name. Never write, say, or even think “theTuring machine” or “the state” or “the tape” or “the input” or (gods forbid) “it”. You also mayfind it useful to think of the working programs we are trying to construct (H and SH in thisproof) as being written in a different language than the arbitrary source code that we want those
programs to analyze (〈M 〉 in this proof).

7.10 One Million Years Dungeon!
As a more complex set of examples, consider the following languages:
NeverAccept := 〈M 〉 | Accept(M ) = ∅NeverReject := 〈M 〉 | Reject(M ) = ∅NeverHalt := 〈M 〉 | Halt(M ) = ∅NeverDiverge := 〈M 〉 | Diverge(M ) = ∅Theorem 13. NeverAccept is undecidable.

Proof: Suppose to the contrary that there is a Turing machine N A that decides NeverAccept.
Then by swapping the accept and reject states, we obtain a Turing machine N AR that decides
the complementary language Σ∗ \ NeverAccept.
To reach a contradiction, we construct a Turing machine A that decides Accept as follows.
Given the encoding 〈M , w〉 of an arbitrary machine M and an arbitrary string w as input, A writes
the encoding 〈Mw 〉 of a new Turing machine Mw that ignores its input, writes w onto the tape,and then passes control to M . Finally, A passes the new encoding 〈Mw 〉 as input to N AR . The
following cartoon tries to illustrate the overall construction.
Before going any further, it may be helpful to list the various Turing machines that appear inthis construction.
9Models of Computation

Lecture 7: Undecidability [Fa’16]

x

Mw

acceptw

M
reject
hang

A
<M,w>

NAR
Build <Mw>
<Mw>

NA

acceptrejectA reduction from from Accept to NeverAccept, which proves NeverAccept undecidable.

• The hypothetical Turing machine N A that decides NeverAccept.
• The Turing machine N AR that decides Σ∗ \ NeverAccept, which we constructed bymodifying N A.
• The Turing machine A that we are building, which decides Accept using N AR as a black-box
subroutine.
• The Turing machine M , whose encoding is part of the input to A.
• The Turing machine Mw whose encoding A constructs from 〈M , w〉 and then passes to N AR
as input.
Now let M be an arbitrary Turing machine and w be an arbitrary string, and suppose we run
our new Turing machine A on the encoding 〈M , w〉. To complete the proof, we need to consider
two cases: Either M accepts w or M does not accept w.
• First, suppose M accepts w.
– Then for all strings x, the machine Mw accepts x.
– So Accept(Mw ) = Σ∗ , by the definition of Accept(Mw ).
– So 〈Mw 〉 6∈ NeverAccept, by definition of NeverAccept.
– So N A rejects 〈Mw 〉, because N A decides NeverAccept.
– So N AR accepts 〈Mw 〉, buy construction of N AR .
– We conclude that A accepts 〈M , w〉, by construction of A.

• On the other hand, suppose M does not accept w, either rejecting or diverging instead.
– Then for all strings x, the machine Mw does not accept x.
– So Accept(Mw ) = ∅, by the definition of Accept(Mw ).
– So 〈Mw 〉 ∈ NeverAccept, by definition of NeverAccept.
– So N A accepts 〈Mw 〉, because N A decides NeverAccept.
– So N AR rejects 〈Mw 〉, buy construction of N AR .
– We conclude that A rejects 〈M , w〉, by construction of A.
10

Models of Computation

Lecture 7: Undecidability [Fa’16]

In short, A decides the language Accept, which is impossible. We conclude that N A does notexist.

Again, similar arguments imply that the languages NeverReject, NeverHalt, and NeverDiverge are undecidable. In each case, the core of the argument is describing how to transformthe incoming machine-and-input encoding 〈M , w〉 into the encoding of an appropriate newTuring machine 〈Mw 〉.
Now that we know that NeverAccept and its relatives are undecidable, we can use them as
the basis of further reduction proofs. Here is a typical example:

Theorem 14. The language DivergeSame := 〈M1 〉 〈M2 〉 Diverge(M1 ) = Diverge(M2 ) is
undecidable.
Proof: Suppose for the sake of argument that there is a Turing machine DS that decides
DivergeSame. Then we can build a Turing machine N D that decides NeverDiverge as follows.
Fix a Turing machine Y that accepts Σ∗ (for example, by defining δ(start, a) = (accept, ·, ·) for
all a ∈ Γ ). Given an arbitrary Turing machine encoding 〈M 〉 as input, N D writes the string〈M 〉〈Y 〉 onto the tape and then passes control to DS. There are two cases to consider:• If DS accepts 〈M 〉〈Y 〉, then Diverge(M ) = Diverge(Y ) = ∅, so 〈M 〉 ∈ NeverDiverge.
• If DS rejects 〈M 〉〈Y 〉, then Diverge(M ) 6= Diverge(Y ) = ∅, so 〈M 〉 6∈ NeverDiverge.

In short, N D accepts 〈M 〉 if and only if 〈M 〉 ∈ NeverDiverge, which is impossible. We conclude
that DS does not exist.


7.11

Rice’s Theorem

In 1953, Henry Rice proved the following extremely powerful theorem, which essentially statesthat every interesting question about the language accepted by a Turing machine is undecidable.

ÆÆÆ

The following formulation is closer to the proof and may be (slightly) easier to use:
Rice’s Theorem. For any set L of languages, if ∅ 6∈ L and there is a Turingmachine M such that Accept(M ) ∈ L, then the language AcceptIn(L) :={〈M 〉 | Accept(M ) ∈ L} is undecidable.

The only downside of this formulation is that when ∅ ∈ L, we need to consider either the∗complementary property L = 2Σ \ L or the complementary language {〈M 〉 | Accept(M ) 6∈ L}.

Rice’s Theorem. Let L be any set of languages that satisfies the following conditions:• There is a Turing machine Y such that Accept(Y ) ∈ L.
• There is a Turing machine N such that Accept(N ) 6∈ L.
The language AcceptIn(L) := 〈M 〉 Accept(M ) ∈ L is undecidable.

Proof: Without loss of generality, suppose ∅ 6∈ L. (A symmetric argument establishes the theorem
in the opposite case ∅ ∈ L.) Fix an arbitrary Turing machine Y such that Accept(Y ) ∈ L.
Suppose to the contrary that there is a Turing machine AL that decides AcceptIn(L). To
derive a contradiction, we describe a Turing machine H that decides the halting language Halt,using AL as a black-box subroutine. Given the encoding 〈M , w〉 of an arbitrary Turing machine M
and an arbitrary string w as input, H writes the encoding 〈WTF〉 of a new Turing machine WTF
that executes the following algorithm:
11Models of Computation

Lecture 7: Undecidability [Fa’16]

WTF(x):
run M on input w (and discard the result)run Y on input x

H then passes the new encoding 〈WTF〉 to AL .
Now let M be an arbitrary Turing machine and w be an arbitrary string, and suppose we run
our new Turing machine H on the encoding 〈M , w〉. There are two cases to consider.
• Suppose M halts on input w.

– Then for all strings x, the machine WTF accepts x if and only if Y accepts x.
– So Accept(WTF) = Accept(Y ), by definition of Accept( · ).
– So Accept(WTF) ∈ L, by definition of Y .
– So AL accepts 〈WTF〉, because AL decides AcceptIn(L).
– So H accepts 〈M , w〉, by definition of H.

• Suppose M does not halt on input w.

– Then for all strings x, the machine WTF does not halt on input x, and therefore does
not accept x.
– So Accept(WTF) = ∅, by definition of Accept(WTF).
– So Accept(WTF) 6∈ L, by our assumption that ∅ 6∈ L.
– So AL rejects 〈WTF〉, because AL decides AcceptIn(L).
– So H rejects 〈M , w〉, by definition of H.

In short, H decides the language Halt, which is impossible. We conclude that AL does notexist.
The set L in the statement of Rice’s Theorem is often called a property of languages, rather
than a set, to avoid the inevitable confusion about sets of sets of finite sequences of characters. We
can also think of L as a decision problem about languages, where the languages are represented
by Turing machines that accept or decide them. Rice’s theorem states that the only propertiesof languages that are decidable are the trivial properties “Does this Turing machine accept an
acceptable language?” (Answer: Yes, by definition.) and “Does this Turing machine accept
Discover?” (Answer: No, because Discover is a credit card, not a language.)
Rice’s Theorem makes it incredibly easy to prove that language properties are undecidable;
we only need to exhibit one acceptable language that has the property and another acceptablelanguage that does not. In fact, every proof using Rice’s theorem can use at least one of thefollowing Turing machines:• MAccept accepts every string, by defining δ(start, a) = accept for every tape symbol a.
• MReject rejects every string, by defining δ(start, a) = reject for every tape symbol a.
• MDiverge diverges on every string, by defining δ(start, a) = (start, a, +1) for every tapesymbol a.
Corollary 15. Each of the following languages is undecidable.
(a) {〈M 〉 | M accepts given an empty initial tape}(b) {〈M 〉 | M accepts the string UIUC}(c) {〈M 〉 | M accepts exactly three strings}
12Models of Computation

Lecture 7: Undecidability [Fa’16](d) {〈M 〉 | M accepts all palindromes}(e) {〈M 〉 | Accept(M ) is regular}(f) {〈M 〉 | Accept(M ) is not regular}(g) {〈M 〉 | Accept(M ) is undecidable}(h) {〈M 〉 | Accept(M ) = Accept(N )}, for some arbitrary fixed Turing machine N .
Proof: In all cases, undecidability follows from Rice’s theorem.
(a) Let L be the set of all languages that contain the empty string. Then AcceptIn(L) = {〈M 〉 |M accepts given an empty initial tape}.
• Given an empty initial tape, MAccept accepts, so Accept(MAccept ) ∈ L.
• Given an empty initial tape, MDiverge does not accept, so Accept(MDiverge ) 6∈ L.

Therefore, Rice’s Theorem implies that AcceptIn(L) is undecidable.
(b) Let L be the set of all languages that contain the string UIUC.
• MAccept accepts UIUC, so Accept(MAccept ) ∈ L.
• MDiverge does not accept UIUC, so Accept(MDiverge ) 6∈ L.

Therefore, AcceptIn(L) = {〈M 〉 | M accepts the string UIUC} is undecidable by Rice’s
Theorem.
(c) There is a Turing machine that accepts the language {larry, curly, moe}. On the other
hand, MReject does not accept exactly three strings.
(d) MAccept accepts all palindromes, and MReject does not accept all palindromes.
(e) MReject accepts the regular language ∅, and there is a Turing machine M0n 1n that accepts
the non-regular language {0n 1n | n ≥ 0}.
(f) MReject accepts the regular language ∅, and there is a Turing machine M0n 1n that accepts
the non-regular language {0n 1n | n ≥ 0}.⁴(g) MReject accepts the decidable language ∅, and there is a Turing machine that accepts theundecidable language SelfReject.
(h) The Turing machine N accepts Accept(N ) by definition. For the negative Turing machine
MAccept accepts Σ∗ and the Turing machine MReject accepts ∅, so at least one of those twomachines does not accept Accept(N ).


We can also use Rice’s theorem as a component in more complex undecidability proofs, where
the target language consists of more than just a single Turing machine encoding.

Theorem 16. The language L := 〈M , w〉 M accepts wk for every integer k ≥ 0 is undecidable.
Proof: Fix an arbitrary string w, and let L be the set of all languages that contain wk for all k.
Then Accept(MAccept ) = Σ∗ ∈ L and Accept(MReject ) = ∅ 6∈ L. Thus, even if the string w is
fixed in advance, no Turing machine can decide L.
Nearly identical reduction arguments imply the following variants of Rice’s theorem. (Thenames of these theorems are not standard.)
⁴Yes, parts (e) and (f) have exactly the same proof.

13

Models of Computation

Lecture 7: Undecidability [Fa’16]

Rice’s Rejection Theorem. Let L be any set of languages that satisfies the following conditions:• There is a Turing machine Y such that Reject(Y ) ∈ L• There is a Turing machine N such that Reject(N ) 6∈ L.
The language RejectIn(L) := 〈M 〉 Reject(M ) ∈ L is undecidable.
Rice’s Halting Theorem. Let L be any set of languages that satisfies the following conditions:• There is a Turing machine Y such that Halt(Y ) ∈ L• There is a Turing machine N such that Halt(N ) 6∈ L.
The language HaltIn(L) := 〈M 〉 Halt(M ) ∈ L is undecidable.
Rice’s Divergence Theorem. Let L be any set of languages that satisfies the following conditions:• There is a Turing machine Y such that Diverge(Y ) ∈ L• There is a Turing machine N such that Diverge(N ) 6∈ L.
The language DivergeIn(L) := 〈M 〉 Diverge(M ) ∈ L is undecidable.
Rice’s Decision Theorem. Let L be any set of languages that satisfies the following conditions:• There is a Turing machine Y that decides an language in L.
• There is a Turing machine N that decides an language not in L.

The language DecideIn(L) := 〈M 〉 M decides a language in L is undecidable.
As easy as it is to use Rice’s theorem and its variants, they cannot be used for all undecidability proofs; these theorems only apply to properties of languages. For example, thelanguage ThisIsSparta := {〈M 〉 | M accepts the string SPARTA after exactly 300 steps} is decidable, even though there are Turing machines that accept the string SPARTA after exactly 300
steps and there are other Turing machines that do not.
More subtly, Rice’s theorem cannot be applied to self-referential languages like RevAccept :={〈M 〉 | M accepts 〈M 〉R }, because membership depends on details of the encoded machine andnot just the language that the encoded machine accepts. To be clear: RevAccept is undecidable;
you just can’t use Rice’s theorem to prove that fact.
?

7.12

The Rice-McNaughton-Myhill-Shapiro Theorem

The following subtle generalization of Rice’s theorem precisely characterizes which propertiesof acceptable languages are acceptable. This result was partially proved by Henry Rice in 1953,
in the same paper that proved Rice’s Theorem; Robert McNaughton, John Myhill, and Norman
Shapiro completed the proof a few years later, each independently from the other two.⁵
The Rice-McNaughton-Myhill-Shapiro Theorem. Let L be an arbitrary set of acceptable languages. The language AcceptIn(L) := {〈M 〉 | Accept(M ) ∈ L} is acceptable if and only if L
satisfies the following conditions:(a) L is monotone: For any language L ∈ L, every superset of L is also in L.

(b) L is compact: Every language in L has a finite subset that is also in L.

⁵McNaughton never published his proof (although he did announce the result); consequently, this theorem issometimes called “The Rice-Myhill-Shapiro Theorem”. Even more confusingly, Myhill published his proof twice, oncein a paper with John Shepherdson and again in a later paper with Jacob Dekker. So maybe it should be called theRice–Dekker-Myhill–(McNaughton–)Myhill-Shepherdson–Shapiro Theorem.

14

Models of Computation

Lecture 7: Undecidability [Fa’16](c) L is finitely acceptable: The language 〈L〉 | L ∈ L and L is finite is acceptable.⁶
I won’t give a complete proof of this theorem (in part because it requires techniques I haven’t
introduced), but the following lemma is arguably the most interesting component:
Lemma 17. Let L be a set of acceptable languages. If L is not monotone, then AcceptIn(L) is
unacceptable.
Proof: Suppose to the contrary that there is a Turing machine AIL that accepts AcceptIn(L).
Using this Turing machine as a black box, we describe a Turing machine SD that accepts theunacceptable language SelfDiverge. Fix two Turing machines Y and N such that
Accept(Y ) ∈ L,

Accept(N ) 6∈ L,

and Accept(Y ) ⊆ Accept(N ).
Let w be the input to SD. After verifying that w = 〈M 〉 for some Turing machine M(and rejecting otherwise), S D writes the encoding 〈WTF〉 or a new Turing machine WTF that
implements the following algorithm:
WTF(x):
write x to second tapewrite 〈M 〉 to third tapein parallel:run Y on the first taperun N on the second taperun M on the third tape
if Y accepts x
acceptif N accepts x and M halts on 〈M 〉acceptFinally, SD passes the new encoding 〈WTF〉 to AIL . There are two cases to consider:• If M halts on 〈M 〉, then Accept(WTF) = Accept(N ) 6∈ L, and therefore AIL does not
accept 〈WTF〉.
• If M does not halt on 〈M 〉, then Accept(WTF) = Accept(Y ) ∈ L, and therefore AIL
accepts 〈WTF〉.

In short, SD accepts SelfDiverge, which is impossible. We conclude that SD does not exist. 
Corollary 18. Each of the following languages is unacceptable.
(a) {〈M 〉 | Accept(M ) is finite}(b) {〈M 〉 | Accept(M ) is infinite}(c) {〈M 〉 | Accept(M ) is regular}(d) {〈M 〉 | Accept(M ) is not regular}(e) {〈M 〉 | Accept(M ) is decidable}

⁶Here the encoding 〈L〉 of a finite language L ⊆ Σ∗ is exactly the string that you would write down to explicitly
describe L. Formally, 〈L〉 is the unique string over the alphabet Σ ∪ {{, •, }, 3} that contains the strings in L in
lexicographic order, separated by commas • and surrounded by braces {}, with 3 representing the empty string. For
example, {", 0, 01, 0110, 01101001} = {3•0•01•0110•01101001}.

15

Models of Computation

Lecture 7: Undecidability [Fa’16](f) {〈M 〉 | Accept(M ) is undecidable}(g) {〈M 〉 | M accepts at least one string in SelfDiverge}(h) {〈M 〉 | Accept(M ) = Accept(N )}, for some arbitrary fixed Turing machine N .
Proof: (a) The set of finite languages is not monotone: ∅ is finite; Σ∗ is not finite; both ∅and Σ∗ are acceptable (in fact decidable); and ∅ ⊂ Σ∗ .

(b) The set of infinite acceptable languages is not compact: No finite subset of the infinite
acceptable language Σ∗ is infinite!
(c) The set of regular languages is not monotone: Consider the languages ∅ and {0n 1n | n ≥ 0}.

(d) The set of non-regular acceptable languages is not monotone: Consider the languages{0n 1n | n ≥ 0} and Σ∗ .

(e) The set of decidable languages is not monotone: Consider the languages ∅ and SelfReject.
(f) The set of undecidable acceptable languages is not monotone: Consider the languages
SelfReject and Σ∗ .

(g) The set L = {L | L ∩ SelfDiverge 6= ∅} is not finitely acceptable. For any string w, deciding
whether {w} ∈ L is equivalent to deciding whether w ∈ SelfDiverge, which is impossible.

(h) If Accept(N ) 6= Σ∗ , then the set {Accept(N )} is not monotone. On the other hand, if
Accept(N ) = Σ∗ , then the set {Accept(N )} is not compact: No finite subset of Σ∗ is equalto Σ∗ !


7.13

Turing Machine Behavior: It’s ComplicatedRice’s theorems imply that every interesting question about the language that a Turing machine
accepts—or more generally, the function that a program computes—is undecidable. A more subtle
question is whether we can recognize Turing machines that exhibit certain internal behavior.
Some behaviors we can recognize; others we can’t.
Theorem 19. The language NeverLeft := {〈M , w〉 | Given w as input, M never moves left} isdecidable.
Proof: Given the encoding 〈M , w〉, we simulate M with input w using our universal Turingmachine U, but with the following termination conditions. If M ever moves its head to the left,then we reject. If M halts without moving its head to the left, then we accept. Finally, if M reads
more than |Q| blanks, where Q is the state set of M , then we accept. If the first two cases do not
apply, M only moves to the right; moreover, after reading the entire input string, M only reads
blanks. Thus, after reading |Q| blanks, it must repeat some state, and therefore loop forever
without moving to the left. The three cases are exhaustive.

Theorem 20. The language LeftThree := {〈M , w〉 | Given w as input, M eventually moves left
three times in a row} is undecidable.
Proof: Given 〈M 〉, we build a new Turing machine M 0 that accepts the same language as M andmoves left three times in a row if and only if it accepts, as follows. For each non-accepting state p

16Models of Computation

Lecture 7: Undecidability [Fa’16]of M , the new machine M 0 has three states p1 , p2 , p3 , with the following transitions:
δ0 (p1 , a) = (q2 , b, ∆),0δ (p2 , a) = (p3 , a, +1)

where (q, b, ∆) = δ(p, a) and q 6= accept

δ0 (p3 , a) = (p1 , a, −1)

In other words, after each non-accepting transition, M 0 moves once to the right and then once tothe left. For each transition to accept, M 0 has a sequence of seven transitions: three steps to theright, then three steps to the left, and then finally accept0 , all without modifying the tape. (Thethree steps to the right ensure that M 0 does not fall off the left end of the tape.)
Finally, M 0 moves left three times in a row if and only if M accepts w. Thus, if we could
decide LeftThree, we could also decide Accept, which is impossible.

There is no hard and fast rule like Rice’s theorem to distinguish decidable behaviors fromundecidable behaviors, but I can offer two rules of thumb.
• If it is possible to simulate an arbitrary Turing machine while avoiding the target behavior,
then the behavior is not decidable. For example, there is no algorithm to determine whether
a given Turing machine reenters its start state, or revisits the left end of the tape, or writes
a blank.
• If a Turing machine with the target behavior is limited to a finite number of configurations,or is guaranteed to force an infinite loop after a finite number of transitions, then the
behavior is likely to be decidable. For example, there are algorithms to determine whether
a given Turing machine ever leaves its start state, or reads its entire input string, or writes
a non-blank symbol over a blank.

Exercises
1. Let M be an arbitrary Turing machine.
(a) Describe a Turing machine M R such that
Accept(M R ) = Reject(M ) and Reject(M R ) = Accept(M ).
(b) Describe a Turing machine M A such that
Accept(M A) = Accept(M ) and Reject(M A) = ∅.
(c) Describe a Turing machine M H such that
Accept(M H ) = Halt(M ) and
2. (a) Prove that Accept is undecidable.
(b) Prove that Reject is undecidable.
(c) Prove that Diverge is undecidable.
3. (a) Prove that NeverReject is undecidable.
17

Reject(M H ) = ∅.

Models of Computation

Lecture 7: Undecidability [Fa’16](b) Prove that NeverHalt is undecidable.
(c) Prove that NeverDiverge is undecidable.
4. Prove that each of the following languages is undecidable.
(a) AlwaysAccept := {〈M 〉 | Accept(M ) = Σ∗ }(b) AlwaysReject := {〈M 〉 | Reject(M ) = Σ∗ }(c) AlwaysHalt := {〈M 〉 | Halt(M ) = Σ∗ }(d) AlwaysDiverge := {〈M 〉 | Diverge(M ) = Σ∗ }5. Let L be a non-empty proper subset of the set of acceptable languages. Prove that thefollowing languages are undecidable:(a) RejectIn(L) := 〈M 〉 Reject(M ) ∈ L(b) HaltIn(L) := 〈M 〉 Halt(M ) ∈ L(c) DivergeIn(L) := 〈M 〉 Diverge(M ) ∈ L
6. For each of the following decision problems, either sketch an algorithm or prove that the
problem is undecidable. Recall that wR denotes the reversal of string w. For each problem,
the input is the encoding 〈M 〉 of a Turing machine M .
(a) Does M reject the empty string?
(b) Does M accept 〈M 〉R ?

(c) Does M accept 〈M 〉〈M 〉?

(d) Does M accept 〈M 〉k for any integer k?

(e) Does M accept the encoding of any Turing machine?
(f) Is there a Turing machine that accepts 〈M 〉?

(g) Is 〈M 〉 a palindrome?

(h) Does M reject any palindrome?
(i) Does M accept all palindromes?
(j) Does M diverge only on palindromes?
(k) Is there an input string that forces M to move left?
(l) Is there an input string that forces M to move left three times in a row?
(m) Does M accept the encoding of any Turing machine N such that Accept(N ) =SelfDiverge?
7. For each of the following decision problems, either sketch an algorithm or prove that the
problem is undecidable. Recall that wR denotes the reversal of string w. For each problem,
the input is an encoding 〈M , w〉 of a Turing machine M and its input string w.
(a) Does M accept the string wwR ?
18

Models of Computation

Lecture 7: Undecidability [Fa’16](b) Does M accept either w or wR ?
(c) Does M either accept w or reject wR ?
(d) Does M accept the string wk for some integer k?
(e) Does M accept w in at most 2|w| steps?
(f) If we run M on input w, does M ever change a symbol on its tape?
(g) If we run M on input w, does M ever move to the right?
(h) If we run M on input w, does M ever move to the right twice in a row?
(i) If we run M on input w, does M move its head to the right more than 2|w| times (notnecessarily consecutively)?
(j) If we run M with input w, does M ever change a  on the tape to any other symbol?
(k) If we run M with input w, does M ever change a  on the tape to 1?
(l) If we run M with input w, does M ever write a ?
(m) If we run M with input w, does M ever leave its start state?
(n) If we run M with input w, does M ever reenter its start state?
(o) If we run M with input w, does M ever reenter a state that it previously left? That is,
are there states p 6= q such that M moves from state p to state q and then later moves
back to state p?
8. Let M be a Turing machine, let w be an arbitrary input string, and let s and t be positive
integers integer. We say that M accepts w in space s if M accepts w after accessing at
most the first s cells on the tape, and M accepts w in time t if M accepts w after at most ttransitions.
(a) Prove that the following languages are decidable:
i. 〈M , w〉 M accepts w in time |w|2
ii. 〈M , w〉 M accepts w in space |w|2(b) Prove that the following languages are undecidable:
i. 〈M 〉 M accepts at least one string w in time |w|2
ii. 〈M 〉 M accepts at least one string w in space |w|2
9. Let L0 be an arbitrary language. For any integer i > 0, define the languageL i := 〈M 〉 M decides L i−1 .
For which integers i > 0 is L i decidable? Obviously the answer depends on the initial
language L0 ; give a complete characterization of all possible cases. Prove your answer iscorrect. [Hint: This question is a lot easier than it looks!]
10. Argue that each of the following decision problems about programs in your favorite
programming language are undecidable.
(a) Does this program correctly compute Fibonacci numbers?
19Models of Computation

Lecture 7: Undecidability [Fa’16](b) Can this program fall into an infinite loop?
(c) Will the value of this variable ever change?
(d) Will this program every attempt to deference a null pointer?
(e) Does this program free every block of memory that it dynamically allocates?
(f) Is any statement in this program unreachable?
(g) Do these two programs compute the same function?
? 11.

Call a Turing machine conservative if it never writes over its input string. More formally, aTuring machine is conservative if for every transition δ(p, a) = (q, b, ∆) where a ∈ Σ, wehave b = a; and for every transition δ(p, a) = (q, b, ∆) where a 6∈ Σ, we have b 6= Σ.

(a) Prove that if M is a conservative Turing machine, then Accept(M ) is a regular
language.

(b) Prove that the language {〈M 〉 | M is conservative and M accepts "} is undecidable.

Together, these two results imply that every conservative Turing machine accepts the samelanguage as some DFA, but it is impossible to determine which DFA.
Æ

12. (a) Prove that it is undecidable whether a given C++ program is syntactically correct.
[Hint: Use templates!](b) Prove that it is undecidable whether a given ANSI C program is syntactically correct.
[Hint: Use the preprocessor!](c) Prove that it is undecidable whether a given Perl program is syntactically correct.
[Hint: Does that slash character / delimit a regular expression or represent division?]© Copyright 2018 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms/ for the most recent revision.

20Models of Computation

Lecture 8: Universal Models [Fa’14]

Caveat lector: This note is not even a first draft, but more of a rough sketch, with many
topics still to be written and/or unwritten. But the semester is over, so it’s time to put it down.
Please send bug reports and suggestions to jeffe@illinois.edu.
Any sufficiently advanced technology is indistinguishable from magic.
— Arthur C. Clarke, “Hazards of Prophecy: The Failure of Imagination” (1962)
Any technology that is distinguishable from magic is insufficiently advanced.
— Barry Gehm, quoted by Stan Schmidt in ANALOG magazine (1991)

8ÆÆÆ

Universal Models of Computation
Remind about the Church-Turing thesis.
There is some confusion here between universal models of computation and thesomewhat wider class of undecidable problems/languages.

8.1

Universal Turing Machines

The pinnacle of Turing machine constructions is the universal Turing machine. For modern
computer scientists, it’s useful to think of a universal Turing machine as a "Turing machineinterpreter written in Turing machine". Just as the input to a Python interpreter is a string of
Python source code, the input to our universal Turing machine U is a string 〈M , w〉 that encodes
both an arbitrary Turing machine M and a string w in the input alphabet of M . Given theseencodings, U simulates the execution of M on input w; in particular,• U accepts 〈M , w〉 if and only if M accepts w.
• U rejects 〈M , w〉 if and only if M rejects w.

In the next few pages, I will sketch a universal Turing machine U that uses the input alphabet{0, 1, [, ], •, |} and a somewhat larger tape alphabet. However, I do not require that the Turingmachines that U simulates have similarly small alphabets, so we first need a method to encode
arbitrary input and tape alphabets.
Encodings
Let M = (Γ , , Σ, Q, start, accept, reject, δ) be an arbitrary Turing machine, with a single halfinfinite tape and a single read-write head. (I will consistently indicate the states and tape symbolsof M in slanted green to distinguish them from the upright red states and tape symbols of U.)
We encode each symbol a ∈ Γ as a unique string |a| of dlg(|Γ |)e bits. Thus, if Γ = {0, 1, $, x, },
we might use the following encoding:〈0〉 = 001,〈1〉 = 010,〈$〉 = 011,〈x〉 = 100,〈〉 = 000.

The input string w is encoded by its sequence of symbol encodings, with separators • between
every pair of symbols and with brackets [ and ] around the whole string. For example, with thisencoding, the input string 001100 would be encoded on the input tape as〈001100〉 = [001•001•010•010•001•001]© Copyright 2017 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://www.cs.uiuc.edu/~jeffe/teaching/algorithms/ for the most recent revision.

1Models of Computation

Lecture 8: Universal Models [Fa’14]

Similarly, we encode each state q ∈ Q as a distinct string 〈q〉 of dlg|Q|e bits. Without loss ofgenerality, we encode the start state with all 1s and the reject state with all 0s. For example, if
Q = {start, seek1, seek0, reset, verify, accept, reject}, we might use the following encoding:〈start〉 = 111〈verify〉 = 101〈seek1〉 = 010〈seek0〉 = 011〈accept〉 = 110〈reject〉 = 000〈reset〉 = 100

We encode the machine M itself as the string 〈M 〉 = [〈reject〉•〈〉]〈δ〉, where 〈δ〉 is theconcatenation of substrings [〈p〉•〈a〉|〈q〉•〈b〉•〈∆〉] encoding each transition δ(p, a) = (q, b, ∆)such that q 6= reject. We encode the actions ∆ = ±1 by defining 〈−1〉 := 0 and 〈+1〉 := 1.
Conveniently, every transition string has exactly the same length. For example, with the symboland state encodings described above, the transition δ(reset, $) = (start, $, +1) would be encodedas[100•011|001•011•1].
Our first example Turing machine for recognizing {0n 1n 0n | n ≥ 0} would be represented by
the following string (here broken into multiple lines for readability):[000•000][[001•001|010•011•1][001•100|101•011•1][010•001|010•001•1][010•100|010•100•1][010•010|011•100•1][011•010|011•010•1][011•100|011•100•1][011•001|100•100•1][100•001|100•001•0][100•010|100•010•0][100•100|100•100•0][100•011|001•011•1][101•100|101•011•1][101•000|110•000•0]]
Finally, we encode any configuration of M on U’s work tape by alternating between encodingsof states and encodings of tape symbols. Thus, each tape cell is represented by the string[〈q〉•〈a〉] indicating that (1) the cell contains symbol a; (2) if q 6= reject, then M ’s head islocated at this cell, and M is in state q; and (3) if q = reject, then M ’s head is located somewhere
else. Conveniently, each cell encoding uses exactly the same number of bits. We also surroundthe entire tape encoding with brackets [ and ].
For example, with the encodings described above, the initial configuration (start, 001100, 0)
Î
for our first example Turing machine would be encoded on U’s tape as follows.
〈start, 001100, 0〉 = [[111•001][000•001][000•010][000•010][000•001][000•001]]
Î
|
{z
}|
{z
}|
{z
}|
{z
}|
{z
}|
{z
}
start 0reject 0

reject 1

reject 1

reject 0

reject 0

Similarly, the intermediate configuration (reset, $0x1x0, 3) would be encoded as follows:Î〈reset, $$x1x0, 3〉 = [[000•011][000•011][000•100][010•010][000•100][000•001]]
Î
|
{z
}|
{z
}|
{z
}|
{z
}|
{z
}|
{z
}
reject $reject 0

reject x

reset 1

reject x

reject 0

Input and Execution
Without loss of generality, we assume that the input to our universal Turing machine U is given
on a separate read-only input tape, as the encoding of an arbitrary Turing machine M followedby an encoding of its input string x. Notice the substrings [[ and ]] each appear only only once
on the input tape, immediately before and after the encoded transition table, respectively. U also
has a read-write work tape, which is initially blank.
2Models of Computation

Lecture 8: Universal Models [Fa’14]

We start by initializing the work tape with the encoding 〈start, x, 0〉 of the initial configurationof M with input x. First, we write [[〈start〉•. Then we copy the encoded input string 〈x〉 onto
the work tape, but we change the punctuation as follows:• Instead of copying the left bracket [, write [[〈start〉•.

• Instead of copying each separator •, write ][〈reject〉•• Instead of copying the right bracket ], write two right brackets ]].
The state encodings 〈start〉 and 〈reject〉 can be copied directly from the beginning of 〈M 〉(replacing 0s for 1s for 〈start〉). Finally, we move the head back to the start of U’s tape.
At the start of each step of the simulation, U’s head is located at the start of the work tape.
We scan through the work tape to the unique encoded cell [〈p〉•〈a〉] such that p 6= reject.
Then we scan through the encoded transition function 〈δ〉 to find the unique encoded tuple[〈p〉•〈a〉|〈q〉•〈b〉•〈∆〉] whose left half matches our the encoded tape cell. If there is no suchtuple, then U immediately halts and rejects. Otherwise, we copy the right half 〈q〉•〈b〉 of thetuple to the work tape. Now if q = accept, then U immediately halts and accepts. (We don’t
bother to encode reject transformations, so we know that q 6= reject.) Otherwise, we transfer
the state encoding to either the next or previous encoded cell, as indicated by M ’s transition
function, and then continue with the next step of the simulation.
During the final state-copying phase, we ever read two right brackets ]], indicating that
we have reached the right end of the tape encoding, we replace the second right bracket with[〈reject〉•〈〉]] (mostly copied from the beginning of the machine encoding 〈M 〉) and thenscan back to the left bracket we just wrote. This trick allows our universal machine to pretendthat its tape contains an infinite sequence of encoded blanks [〈reject〉•〈〉] instead of actual
blanks .
ExampleAs an illustrative example, suppose U is simulating our first example Turing machine M on
the input string 001100. The execution of M on input w eventually reaches the configuration(seek1, $$x1x0, 3). At the start of the corresponding step in U’s simulation, U is in the followingÎ
configuration:[[000•011][000•011][000•100][010•010][000•100][000•001]]
ÎFirst U scans for the first encoded tape cell whose state is not reject. That is, U repeatedly
compares the first half of each encoded state cell on the work tape with the prefix [〈reject〉• of
the machine encoding 〈M 〉 on the input tape. U finds a match in the fourth encoded cell.

[[000•011][000•011][000•100][010•010][000•100][000•001]]
Î

Next, U scans the machine encoding 〈M 〉 for the substring [010•010 matching the current encoded cell. U eventually finds a match in the left size of the the encoded transition[010•010|011•100•1]. U copies the state-symbol pair 011•100 from the right half of thisencoded transition into the current encoded cell. (The underline indicates which symbols arechanged.)[[000•011][000•011][000•100][011•100][000•100][000•001]]
Î3

Models of Computation

Lecture 8: Universal Models [Fa’14]

The encoded transition instructs U to move the current state encoding one cell to the right. (Theunderline indicates which symbols are changed.)[[000•011][000•011][000•100][000•100][011•100][000•001]]
ÎFinally, U scans left until it reads two left brackets [[; this returns the head to the left end of
the work tape to start the next step in the simulation. U’s tape now holds the encoding of M ’s
configuration (seek0, $$xxx0, 4), as required.
Î

[[000•011][000•011][000•100][000•100][011•100][000•001]]
Î

8.2

Two-Stack Machines

A two-stack machine is a Turing machine with two tapes with the following restricted behavior.
At all times, on each tape, every cell to the right of the head is blank, and every cell at or to theleft of the head is non-blank. Thus, a head can only move right by writing a non-blank symbol
into a blank cell; symmetrically, a head can only move left by erasing the rightmost non-blankcell. Thus, each tape behaves like a stack. To avoid underflow, there is a special symbol at thestart of each tape that cannot be overwritten. Initially, one tape contains the input string, withthe head at its last symbol, and the other tape is empty (except for the start-of-tape symbol).

ÆÆÆ

Simulate a doubly-infinite tape with two stacks, one holding the tape contents to the left ofthe head, the other holding the tape contents to the right of the head. For each transitionof a standard Turing machine M , the stack machine pops the top symbol off the (say) left
stack, changes its internal state according to the transition δ, and then either pushes a new
symbol onto the right stack, or pushes a new symbol onto the left stack and then moves the
top symbol from the right stack to the left stack.

8.3

ÆÆÆ

Counter Machines
A configuration of a k-counter machine consists of k non-negative integers and an internal
state from some finite set Q. The transition function δ : Q × {0, +1}k → Q × {−1, 0, +1}k takes
an internal state and the signs of the counters as input, and produces a new internal state andchanges to counters as output.
• Prove that any Turing machine can be simulated by a three-counter machine. One
counter holds the binary representation of the tape after the head; another counterholds the reversed binary representation of the tape before the head. Implementtransitions via halving, doubling, and parity, using the third counter for scratch work.
• Prove that two counters can simulate three. Store 2a 3 b 5c in one counter, use the otherfor scratch work.
• Prove that a three-counter machine can compute any computable function: Given input(n, 0, 0), we can compute ( f (n), 0, 0) for any computable function f . First transform(n, 0, 0) to (2n , 0, 0) using all three counters; then run two- (or three-)counter TM simulation to obtain (2 f (n) , 0, 0); and finally transform (2 f (n) , 0, 0) to ( f (n), 0, 0) using all
three counters.
• HARD: Prove that a two-counter machine cannot transform (n, 0) to (2n , 0). [Barzhdin
1963, Yao 1971, Schröpel 1972]4

Models of Computation

8.4

ÆÆÆ

Lecture 8: Universal Models [Fa’14]

FRACTRANFRACTRAN [Conway 1987]: A one-counter machine whose “program” is a sequence of rational
numbers. The counter is initially 1. At each iteration, multiply the counter by the first rational
number that yields an integer; if there is no such number, halt.
• Prove that for any computable function f : N → N, there is a FRACTRAN program thattransforms 2n+1 into 3 f (n)+1 , for all natural numbers n.
• Prove that every FRACTRAN program, given the integer 1 as input, either outputs 1 orloops forever. It follows that there is no FRACTRAN program for the increment function
n 7→ n + 1.

8.5

Post Correspondence Problem

Given n of pairs of strings (x 1 , y1 ), (x 2 , y2 ), . . . , (x n , yn ), is there a finite sequence of integers(i1 , i2 , . . . , ik ) such that x i1 x i2 · · · x ik = yi1 yi2 · · · yik ? For notation convenience, we write each pairxvertically as y instead of horizontally as (x, y). For example, given the string pairs

a=


 


0
01
110
, b=
, c=
,
100
00
11

we should answer True, because


 


110 01 110
0c bca =
11 00 11 100
gives us 110110100 for both concatenations. As more extreme examples, the shortest solutions
for the input




 
0
001
1
a=
, b=
, c=
001
1
0
have length 75; one such solution is aacaacab babccaaccaaaac baa b baac bac b bcc b bac bacc bc b
ac b bac bacc bac bbbaccc babbcc baacaacaaac ba b baacac bcc b ba bac bcaacc baca b b b babcccc
bcaababaacc bc bbbaccc babbcc b. The shortest solution for the instance




 


0
0
01
1111
a=
, b=
, c=
, d=
000
0101
1
10
is the unbelievable a2 b8 a4 c 16 a b4 a2 b4 ad 4 b3 c 8 a6 c 8 b2 c 4 bc 6 d 2 a18 d 2 c 4 dcad 2 c b54 c 3 dca2 c 111 d c
a6 d 28 c b17 c 63 d 16 c 16 d 4 c 4 dc, which has total length 451. Finally, the shortest solution for the
instance






0
010
100
a=
, b=
, c=
,
00010
01
0
has length 528.

ÆÆÆThe simplest universality proof simulates a tag-Turing machine.

8.6

ÆÆÆ

Matrix Mortality
Given a set of integer matrices A1 , . . . , Ak , is the product of any sequence of these matrices(with repetition) equal to 0? Undecidable by reduction from PCP, even for two 15 × 15 matrices
or six 3 × 3 matrices [Cassaigne, Halava, Harju, Nicolas 2014]5

Models of Computation

8.7

Lecture 8: Universal Models [Fa’14]

Dynamical Systems

ÆÆÆ

Ray Tracing [Reif, Tygar, and Yoshida 1994] The configuration of a Turing machine is encoded
as the (x, y) coordinates of a light path crossing the unit square [0, 1] × [0, 1], where the x (resp. y -)coordinate encodes the tape contents to the left (resp. right) of the head. Needeither quadratic-surface mirrors or refraction to simulate transitions.
N-body problem [Smith 2006]: Similar idea
Skolem-Pisot reachability: Given an integer vector x and an integer matrix A, does An x =(0, . . . ) for any integer n? [Halava, Harju, Hirvensalo, Karhumäki 2005] It’s surprising that thisproblem is undecidable; the similar mortality problem for one matrix is not.

8.8

ÆÆÆ

Wang Tiles
Turing machine simulation is straightforward. Small Turing-complete tile sets via affine maps
(via two-stack machines) are a little harder.

8.9

Combinator Calculus

In the 1920s, Moses Schönfinkel developed what can now be interpreted as a model of computation
now called combinator calculus or combinatory logic. Combinator calculus operates on terms,
where every term is either one of a finite number of combinators (represented here by upper
case letters) or an ordered pair of terms. For notational convenience, we omit commas between
components of every pair and parentheses around the left term in every pair. Thus, SKK(IS) is
shorthand for the term (((S, K), K), (I, S)).
We can “evaluate” any term by a sequence of rewriting rules that depend on its first primitive
combinator. Schönfinkel defined three primitive combinators with the following evaluation rules:• Identity: I x 7→ x

• Constant: K x y 7→ x

• Substitution: S x yz 7→ xz( yz)Here, x, y, and z are variables representing unknown but arbitrary terms. “Computation” inthe combinator calculus is performed by repeatedly evaluating arbitrary (sub)terms with one ofthese three structures, until all such (sub)terms are gone.
For example, the term S(K(SI))K x y (for any terms x and y) evaluates as follows:

S(K(SI))Kx y 7→ K(SI) x(K x) y
7→ SI(Kx) y
7→ Iy(K x y)

Substitution
Constant
Substitution

7→ y(Kxy)

Identity

7→ y xConstantThus, we can define a new combinator R := S(K(SI))K that upon evaluation reverses the next
two terms: R x y 7→ y x.

6Models of Computation

Lecture 8: Universal Models [Fa’14]

On the other hand, evaluating SII(S(KI)(SII)) leads to an infinite loop:

SII(S(KI)(SII)) 7→ I(S(KI)(SII))(I(S(KI)(SII)))
7→ S(KI)(SII)(I(S(KI)(SII)))

7→ S(KI)(SII)(S(KI)(SII))

7→ KI(S(KI)(SII))(SII(S(KI)(SII)))7→ I(SII(S(KI)(SII)))ÆÆÆ

7→ SII(S(KI)(SII))

Substitution
Identity
Identity
Substitution
Constant
Identity

Wikipedia sketches a direct undecidability proof. Is there a Turing-completeness proof thatavoids λ-calculus?

Exercises
1. A tag-Turing machine has two heads: one can only read, the other can only write. Initially,
the read head is located at the left end of the tape, and the write head is located at thefirst blank after the input string. At each transition, the read head can either move one cellto the right or stay put, but the write head must write a symbol to its current cell and move
one cell to the right. Neither head can ever move to the left.
Prove that any standard Turing machine can be simulated by a tag-Turing machine.
That is, given any standard Turing machine M , describe a tag-Turing machine M 0 that
accepts and rejects exactly the same input strings as M .
2. ? (a) Prove that any standard Turing machine can be simulated by a Turing machine with
only three states. [Hint: Use the tape to store an encoding of the state of the machine
yours is simulating.]Æ(b) Prove that any standard Turing machine can be simulated by a Turing machine with
only two states.

3. A two-dimensional Turing machine uses an infinite two-dimensional grid of cells as
the tape; at each transition, the head can move from its current cell to any of its
four neighbors on the grid. The transition function of such a machine has the form
δ : Q × Γ → Q × Γ × {↑, ←, ↓, →}, where the arrows indicate which direction the head should
move.
(a) Prove that any two-dimensional Turing machine can be simulated by a standard
Turing machine.
(b) Suppose further that we endow our two-dimensional Turing machine with thefollowing additional actions, in addition to moving the head:• Insert row: Move all symbols on or above the row containing the head up one
row, leaving the head’s row blank.
• Insert column: Move all symbols on or to the right of the column containing thehead one column to the right, leaving the head’s column blank.
• Delete row: Move all symbols above the row containing the head down one row,deleting the head’s row of symbols.
• Delete column: Move all symbols the right of the column containing the head
one column to the right, deleting the head’s column of symbols.
7Models of Computation

Lecture 8: Universal Models [Fa’14]

Show that any two-dimensional Turing machine that can add an delete rows can be
simulated by a standard Turing machine.
4. A binary-tree Turing machine uses an infinite binary tree as its tape; that is, every cell inthe tape has a left child and a right child. At each step, the head moves from its current
cell to its Parent, its Left child, or to its Right child. Thus, the transition function of such amachine has the form δ : Q × Γ → Q × Γ × {P, L, R}. The input string is initially given along
the left spine of the tape.
Show that any binary-tree Turing machine can be simulated by a standard Turingmachine.
5. A stack-tape Turing machine uses an semi-infinite tape, where every cell is actually the
top of an independent stack. The behavior of the machine at each iteration is governed by
its internal state and the symbol at the top of the current cell’s stack. At each transition,
the head can optionally push a new symbol onto the stack, or pop the top symbol off thestack. (If a stack is empty, its “top symbol” is a blank and popping has no effect.)Show that any stack-tape Turing machine can be simulated by a standard Turingmachine. (Compare with Problem ??!)
6. A tape-stack Turing machine has two actions that modify its work tape, in addition tosimply writing individual cells: it can save the entire tape by pushing in onto a stack, and it
can restore the entire tape by popping it off the stack. Restoring a tape returns the content
of every cell to its content when the tape was saved. Saving and restoring the tape do notchange the machine’s state or the position of its head. If the machine attempts to “restore”
the tape when the stack is empty, the machine crashes.
Show that any tape-stack Turing machine can be simulated by a standard Turingmachine.

ÆÆÆ• Tape alphabet = N.

– Read: zero or positive. Write: +1, −1– Read: even or odd. Write: +1, −1, ×2, ÷2– Read: positive, negative, or zero. Write: x + y (merge), x − y (merge), 1, 0

• Never three times in a row in the same direction• Hole-punch TM: tape alphabet {, }, and only  7→  transitions allowed.

© Copyright 2017 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://www.cs.uiuc.edu/~jeffe/teaching/algorithms/ for the most recent revision.

8Models of Computation

Lecture 9: Nondeterministic Turing Machines [Fa’16]

Caveat lector: This is a first draft; some topics still need to be written. Please send bug
reports and suggestions to jeffe@illinois.edu.
If first you don’t succeed, then try and try again.
And if you don’t succeed again, just try and try and try.
— Marc Blitzstein, “Useless Song”, The Three Penny Opera (1954)
Adaptation of Bertold Brecht, “Das Lied von der Unzulänglichkeit
menschlichen Strebens” Die Dreigroschenoper (1928)
Children need encouragement.
If a kid gets an answer right, tell him it was a lucky guess.
That way he develops a good, lucky feeling.
— Jack Handey, “Deep Thoughts”, Saturday Night Live (March 21, 1992)

9

Nondeterministic Turing Machines

9.1

Definitions

In his seminal 1936 paper, Turing also defined an extension of his “automatic machines” that
he called choice machines, which are now more commonly known as nondeterministic Turingmachines. The execution of a nondeterministic Turing machine is not determined entirely by its
input and its transition function; rather, at each step of its execution, the machine can choose
from a set of possible transitions. The distinction between deterministic and nondeterministic
Turing machines exactly parallels the distinction between deterministic and nondeterministic
finite-state automata.
Formally, a nondeterministic Turing machine has all the components of a standard deterministic Turing machine—a finite tape alphabet Γ that contains the input alphabet Σ and a blanksymbol ; a finite set Q of internal states with special start, accept, and reject states; and atransition function δ. However, the transition function now has the signatureδ : Q × Γ → 2Q×Γ ×{−1,+1} .
That is, for each state p and tape symbol a, the output δ(p, a) of the transition function is a setof triples of the form (q, b, ∆) ∈ Q × Γ × {−1, +1}. Whenever the machine finds itself in state preading symbol a, the machine chooses an arbitrary triple (q, b, ∆) ∈ δ(p, a), and then changes
its state to q, writes b to the tape, and moves the head by ∆. If the set δ(p, a) is empty, themachine moves to the reject state and halts.
The set of all possible transition sequences of a nondeterministic Turing machine N on agiven input string w define a rooted tree, called a computation tree. The initial configuration(start, w, 0) is the root of the computation tree, and the children of any configuration (q, x, i)are the configurations that can be reached from (q, x, i) in one transition. In particular, any
configuration whose state is accept or reject is a leaf. For deterministic Turing machines, thiscomputation tree is just a single path, since there is at most one valid transition from every
configuration.
© Copyright 2016 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms/ for the most recent revision.

1Models of Computation

9.2

Lecture 9: Nondeterministic Turing Machines [Fa’16]

Acceptance and Rejection

Unlike deterministic Turing machines, there is a fundamental asymmetry between the acceptanceand rejection criteria for nondeterministic Turing machines. Let N be any nondeterministic
Turing machine, and let w be any string.
• N accepts w if and only if there is at least one sequence of valid transitions from the initialconfiguration (start, w, 0) that leads to the accept state. Equivalently, N accepts w if thecomputation tree contains at least one accept leaf.
• N rejects w if and only if every sequence of valid transitions from the initial configuration(start, w, 0) leads to the reject state. Equivalently, N rejects w if every path through thecomputation tree ends with a reject leaf.
In particular, N can accept w even when there are choices that allow the machine to run forever,
but rejection requires N to halt after only a finite number of transitions, no matter what choices
it makes along the way. Just as for deterministic Turing machines, it is possible that N neither
accepts nor rejects w.
Acceptance and rejection of languages are defined exactly as they are for deterministic
machines. A non-deterministic Turing machine N accepts a language L ⊆ Σ∗ if M accepts all
strings in L and nothing else; N rejects L if M rejects every string in L and nothing else; andfinally, N decides L if M accepts L and rejects Σ∗ \ L.

9.3

ÆÆÆ

Time and Space Complexity• Define “time” and “space”.
• TIME( f (n)) is the class of languages that can be decided by a deterministic multi-tapeTuring machine in O( f (n)) time.

• NTIME( f (n)) is the class of languages that can be decided by a nondeterministic multitape Turing machine in O( f (n)) time.

• SPACE( f (n)) is the class of languages that can be decided by deterministic multi-tapeTuring machine in O( f (n)) space.

• NSPACE( f (n)) is the class of languages that can be decided by a nondeterministic
multi-tape Turing machine in O( f (n)) space.

• Why multi-tape TMs? Because t steps on any k-tape Turing machine can be simulated inO(t log t) steps on a two-tape machine [Hennie and Stearns 1966, essentially using lazy
counters and amortization], and in O(t 2 ) steps on a single-tape machine [Hartmanis
and Stearns 1965; realign multiple tracks at every simulation step]. Moreover, the latter
quadratic bound is tight [Hennie 1965 (palindromes, via communication complexity)].

9.4

Deterministic Simulation via Dovetailing

Theorem 1. For any nondeterministic Turing machine N , there is a deterministic Turing machine
M that accepts exactly the same strings and N and rejects exactly the same strings as N . Moreover,
if every computation path of N on input x halts after at most t steps, then M halts on input x after
at most O(t 2 r 2t ) steps, where r is the maximum size of any transition set in N .
Proof: I’ll describe a deterministic machine M that performs a breadth-first search of thecomputation tree of N . (The depth-first search performed by a standard recursive backtracking
algorithm won’t work here. If N ’s computation tree contains an infinite path, a depth-first searchwould get stuck in that path without exploring the rest of the tree.)2Models of Computation

Lecture 9: Nondeterministic Turing Machines [Fa’16]

At the beginning of each simulation round, M ’s tape contains a string of the form · · · •• y1 q1 z1 • y2 q2 z2 • · · · • yk qk zk ••where each substring yi qi zi encodes a configuration (qi , yi zi , | yi |) of some computation pathof N , and • is a new symbol not in the tape alphabet of N . The machine M interprets thissequence of encoded configurations as a queue, with new configurations inserted on the rightand old configurations removed from the left. The double-separators •• uniquely identify thestart and end of this queue; outside this queue, the tape is entirely blank.
Specifically, in each round, first M appends the encodings of all configurations than N canreach in one transition from the first encoded configuration (q1 , y1 z1 , | y1 |); then M erases thefirst encoded configuration.
· · · •• y1 q1 z1 • y2 q2 z2 • · · · • y r q r z r •• · · ·ww
· · ·  · · · •• y2 q2 z2 • · · · • yk qk zk • ỹ1 q̃1 z̃1 • ỹ2 q̃2 z̃2 • · · · • ỹ r q̃ r z̃ r •• · · ·Suppose each transition set δN (q, a) has size at most r. Then after simulating t steps of N ,the tape string of M encoding O(r t ) different configurations of N and therefore has length
L = O(t r t ) (not counting the initial blanks). If M begins each simulation phase by moving
the initial configuration from the beginning to the end of the tape string, which takes O(t 2 r t )time, the time for the rest of the the simulation phase is negligible. Altogether, simulating all r t
possibilities for the the tth step of N requires O(t 2 r 2t ) time. We conclude that M can simulate
the first t steps of every computation path of N in O(t 2 r 2t ) time, as claimed.
The running time of this simulation is dominated by the time spent reading from one end of
the tape string and writing to the other. It is fairly easy to reduce the running time to O(t r t ) byusing either two tapes (a “read tape” containing N -configurations at time t and a “write tape”
containing N -configurations at time t + 1) or two independent heads on the same tape (one ateach end of the queue).

9.5

Nondeterminism as Advice

Any nondeterministic Turing machine N can also be simulated by a deterministic machine M
with two inputs: the user input string w ∈ Σ∗ , and a so-called advice string x ∈ Ω∗ , where Ω isanother finite alphabet. Only the first input string w is actually given by the user. At least for
now, we assume that the advice string x is given on a separate read-only tape.
The deterministic machine M simulates N step-by-step, but whenever N has a choice of
how to transition, M reads a new symbol from the advice string, and that symbol determines
the choice. In fact, without loss of generality, we can assume that M reads a new symbol fromthe advice string and moves the advice-tape’s head to the right on every transition. Thus, M ’stransition function has the form δ M : Q × Γ × Ω → Q × Γ × {−1, +1}, and we require thatδN (q, a) = {δ M (q, a, ω) | ω ∈ Ω}
For example, if N has a binary choiceδN (branch, ?) = (left, L, −1), (right, R, +1) ,3Models of Computation

Lecture 9: Nondeterministic Turing Machines [Fa’16]

then M might determine this choice by definingδ M (branch, ?, 0) = (left, L, −1)andδ M (branch, ?, 1) = (right, R, +1)

More generally, if every set δN (p, a) has size r, then we let Ω = {1, 2, . . . , r} and define δ M (q, a, i)to be the ith element of δN (q, a) in some canonical order.
Now observe that N accepts a string w if and only if M accepts the pair (w, x) for some stringx ∈ Ω∗ , and N rejects w if and only if M rejects the pair (w, x) for all strings x ∈ Ω∗ .
The “advice” formulation of nondeterminism allows a different strategy for simulation by astandard deterministic Turing machine, which is often called dovetailing. Consider all possible
advice strings x, in increasing order of length; listing these advice strings is equivalent torepeatedly incrementing a base-r counter. For each advice string x, simulate M on input (w, x)
for exactly |x| transitions.
Dovetail M (w):for t ← 1 to ∞done ← True
for all strings x ∈ Ω t
if M accepts (w, x) in at most t steps
acceptif M (w, x) does not halt in at most t steps
done ← False
if donereject

The most straightforward Turing-machine implementation of this algorithm requires three tapes:
A read-only input tape containing w, an advice tape containing x (which is also used as a timer
for the simulation), and the work tape. This simulation requires O(t r t ) time to simulate all
possibilities for t steps of the original non-deterministic machine N .
If we insist on using a standard Turing machine with a single tape and a single head, thesimulation becomes slightly more complex, but (unlike our earlier queue-based strategy) notsignificantly slower. This standard machine S maintains a string of the form •w• x •z, where z
is the current work-tape string of M (or equivalently, of N ), with marks (on a second track)indicating the current positions of the heads on M ’s work tape and M ’s advice tape. Simulating
a single transition of M now requires O(|x|) steps, because S needs to shuttle its single head
between these two marks. Thus, S requires O(t 2 r t ) time to simulate all possibilities for t
steps of the original non-deterministic machine N . This is significantly faster than the queuebased simulation, because we don’t record (and therefore don’t have to repeatedly scan over)intermediate configurations; recomputing everything from scratch is actually cheaper!

9.6

ÆÆÆ

The Cook-Levin Theorem
Define Sat and CircuitSat. Non-determinism is fundamentally different from other Turingmachine extensions, in that it seems to provide an exponential speedup for some problems,
just like NFAs can use exponentially fewer states than DFAs for the same language.

The Cook-Levin Theorem. If SAT ∈ P, then P=NP.
Proof: Let L ⊆ Σ∗ be an arbitrary language in NP, over some fixed alphabet Σ. There must be
an integer k and Turing machine M that satisfies the following conditions:4Models of Computation

Lecture 9: Nondeterministic Turing Machines [Fa’16]• For all strings w ∈ L, there is at least one string x ∈ Σ∗ such that M accepts the string w x.
• For all strings w 6∈ L and x ∈ Σ∗ , M rejects the string w x.

• For all strings w, x ∈ Σ∗ , M halts on input w x after at most max{1, |w|k } steps.

Now suppose we are given a string w ∈ Σ∗ . Let n = |w| and let N = max{1, |w|k }. We
construct a boolean formula Φw that is satisfiable if and only if w ∈ L, by following the executionof M on input w x for some unknown advice string x. Without loss of generality, we can assume
that |x| = N − n − 1 (since we can extend any shorter string x with blanks.) Our formula Φw uses
the following boolean variables for all symbols a ∈ Γ , all states q ∈ Q, and all integers 0 ≤ t ≤ N
and 0 ≤ i ≤ N + 1.
• Q t,i,q — M is in state q with its head at position i after t transitions.
• Tt,i,a — The kth cell of M ’s work tape contains a after t transitions.
The formula Φw is the conjunction of the following constraints:• Boundaries: To simplify later constraints, we include artificial boundary variables justpast both ends of the tape:
Q t,i,q = Q t,N +1,q = False

for all 0 ≤ t ≤ N and q ∈ Q

Tt,0,a = Tt,N +1,a = False

for all 0 ≤ t ≤ N and a ∈ Γ• Initialization: We have the following values for variables with t = 0:
Q 0,1,start = True
Q 0,1,q = False

for all q 6= start

H0,i,q = False

for all i 6= 1 and q ∈ Q

T0,i,w i = True

for all 1 ≤ i ≤ n

T0,i,a = False

for all 1 ≤ i ≤ n and a 6= w i

T0,n+1, = True

T0,n+1,a = False

for all a 6= 

• Uniqueness: The variables T0,i,a with n+2 ≤ i ≤ N represent the unknown advice string x;
these are the “inputs” to Φw . We need some additional constraints ensure that for each i,exactly one of these variables is True:


_
^

T0, j,a ∧T0, j,a ∨ T0, j,b
a∈Γ

a6= b

• Transitions: For all 1 ≤ t ≤ N and 1 ≤ i ≤ N , the following constraints simulate thetransition from time t − 1 to time t.
__
Q t,i,q =Q t−1,i−1,p ∧ Tt,i−1,a ∨Q t−i,i+1,p ∧ Tt,i+1,aδ(p,a)=(q,·,+1)

Tt,i,b =_δ(p,a)=(·,b,·)δ(p,a)=(q,·,−1)

Q t−1,i,p ∧ Tt−1,i,a



5


∨

^
q∈Q


Q t−1,i,q ∧ Tt−1,i,b

Models of Computation

Lecture 9: Nondeterministic Turing Machines [Fa’16]• Output: We have one final constraint that indicates acceptance.
z=

N
N
_
_

Q t,i,accept

t=0 i=1

By definition, Φw is satisfiable if and only if some input values T0,i,a , all constraints are
satisfied, including acceptance. A straightforward induction argument implies that even without
the acceptance constraint, any assignment of values to the unknown variables T0,i,a that satisfies theuniqueness constraints determines unique values for the other variables in Φw , which consistently
describe the execution of M . To satisfy the acceptance constraint, this execution of M must leadto the accept state. Thus, Φw is satisfiable if and only if there is a string x ∈ Γ ∗ such that M
accepts the input w x. We conclude that Φw is satisfiable if and only if w ∈ L.
It remains only to argue that the reduction requires only polynomial time. For any input
string w of length n, the formula Φw has O(N 2 ) variables and O(N 2 ) constraints (where thehidden constants depend on the machine M ). Every constraint except acceptance has constantlength, so altogether Φw has length O(N 2 ). Moreover, we can construct Φw in O(N 2 ) = O(n2k )time.
In conclusion, if we could decide SAT for formulas of size M in O(M c ) time, then we could
decide membership in L in O(n2kc ) time, which implies that L ∈ P.
ExercisesÆÆÆ

1. Prove that the following problem is NP-hard, without using the Cook-Levin Theorem. Givena string 〈M , w〉 that encodes a non-deterministic Turing machine M and a string w, does M
accept w in at most |w| transitions?
More excerises!

© Copyright 2016 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms/ for the most recent revision.

6