From f81950a5a6a918ff27a3f330002d801623212c72 Mon Sep 17 00:00:00 2001
From: Antti H S Laaksonen <ahslaaks@cs.helsinki.fi>
Date: Sat, 25 Feb 2017 21:47:47 +0200
Subject: [PATCH] References etc.

---
 chapter24.tex | 10 +++++++---
 chapter25.tex |  6 ++++--
 list.tex      | 30 ++++++++++++++++++++++++++++++
 3 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/chapter24.tex b/chapter24.tex
index a4bd1aa..6f91c2c 100644
--- a/chapter24.tex
+++ b/chapter24.tex
@@ -359,7 +359,8 @@ The expected value for $X$ in a geometric distribution is
 
 \index{Markov chain}
 
-A \key{Markov chain} is a random process
+A \key{Markov chain}\footnote{A. A. Markov (1856--1922)
+was a Russian mathematician.} is a random process
 that consists of states and transitions between them.
 For each state, we know the probabilities
 for moving to other states.
@@ -516,7 +517,9 @@ It turns out that we can find order statistics
 using a randomized algorithm without sorting the array.
 The algorithm is a Las Vegas algorithm:
 its running time is usually $O(n)$
-but $O(n^2)$ in the worst case.
+but $O(n^2)$ in the worst case\footnote{C. A. R. Hoare
+discovered both this algorithm, known as \key{quickselect} \cite{hoa61b},
+and a similar sorting algorithm, known as \key{quicksort} \cite{hoa61a}.}.
 
 The algorithm chooses a random element $x$
 in the array, and moves elements smaller than $x$
@@ -561,7 +564,8 @@ answer would by easier than to calculate it from scratch.
 
 It turns out that we can solve the problem
 using a Monte Carlo algorithm whose
-time complexity is only $O(n^2)$.
+time complexity is only $O(n^2)$\footnote{This algorithm is sometimes
+called \index{Freivalds' algoritm} \key{Freivalds' algorithm} \cite{fre77}.}.
 The idea is simple: we choose a random vector
 $X$ of $n$ elements, and calculate the matrices
 $ABX$ and $CX$. If $ABX=CX$, we report that $AB=C$,
diff --git a/chapter25.tex b/chapter25.tex
index 5c3b9dc..9c5f565 100644
--- a/chapter25.tex
+++ b/chapter25.tex
@@ -248,7 +248,8 @@ and this is always the final state.
 It turns out that we can easily classify
 any nim state by calculating
 the \key{nim sum} $x_1 \oplus x_2 \oplus \cdots \oplus x_n$,
-where $\oplus$ is the xor operation.
+where $\oplus$ is the xor operation\footnote{The optimal strategy
+for nim was published in 1901 by C. L. Bouton \cite{bou01}}.
 The states whose nim sum is 0 are losing states,
 and all other states are winning states.
 For example, the nim sum for
@@ -367,7 +368,8 @@ so the nim sum is not 0.
 
 \index{Sprague–Grundy theorem}
 
-The \key{Sprague–Grundy theorem} generalizes the
+The \key{Sprague–Grundy theorem}\footnote{The theorem was discovered
+independently by R. Sprague \cite{spr35} and P. M. Grundy \cite{gru39}} generalizes the
 strategy used in nim to all games that fulfil
 the following requirements:
 
diff --git a/list.tex b/list.tex
index 3aa597c..1131cfa 100644
--- a/list.tex
+++ b/list.tex
@@ -35,6 +35,11 @@
   \emph{Programming Pearls}.
   Addison-Wesley, 1986.
 
+\bibitem{bou01}
+  C. L. Bouton.
+  Nim, a game with a complete mathematical theory.
+  \emph{Annals of Mathematics}, 3(1/4):35--39, 1901.
+
 \bibitem{cod15}
   Codeforces: On ''Mo's algorithm'',
   \url{http://codeforces.com/blog/entry/20032}
@@ -94,6 +99,11 @@
   Maximal flow through a network.
   \emph{Canadian Journal of Mathematics}, 8(3):399--404, 1956.
 
+\bibitem{fre77}
+  R. Freivalds.
+  Probabilistic machines can use less running time.
+  In \emph{IFIP congress}, 839--842, 1977.
+
 \bibitem{gal14}
   F. Le Gall.
   Powers of tensors and fast matrix multiplication.
@@ -116,6 +126,11 @@
   \emph{2014 IEEE 55th Annual Symposium on Foundations of Computer Science},
   621--630, 2014.
 
+\bibitem{gru39}
+  P. M. Grundy.
+  Mathematics and games.
+  \emph{Eureka}, 2(5):6--8, 1939.
+
 \bibitem{gus97}
   D. Gusfield.
   \emph{Algorithms on Strings, Trees and Sequences:
@@ -139,6 +154,16 @@
   Über die Möglichkeit, einen Linienzug ohne Wiederholung und ohne Unterbrechung zu umfahren.
   \emph{Mathematische Annalen}, 6(1), 30--32, 1873.
 
+\bibitem{hoa61a}
+  C. A. R. Hoare.
+  Algorithm 64: Quicksort.
+  \emph{Communications of the ACM}, 4(7):321, 1961.
+
+\bibitem{hoa61b}
+  C. A. R. Hoare.
+  Algorithm 65: Find.
+  \emph{Communications of the ACM}, 4(7):321--322, 1961.
+
 \bibitem{hop71}
   J. E. Hopcroft and J. D. Ullman.
   A linear list merging algorithm.
@@ -231,6 +256,11 @@
   A strong-connectivity algorithm and its applications in data flow analysis.
   \emph{Computers \& Mathematics with Applications}, 7(1):67--72, 1981.
 
+\bibitem{spr35}
+  R. Sprague.
+  Über mathematische Kampfspiele.
+  \emph{Tohoku Mathematical Journal}, 41:438--444, 1935.
+
 \bibitem{sta06}
   P. Stańczyk.
   \emph{Algorytmika praktyczna w konkursach Informatycznych},