diff --git a/books/bookvol0.pamphlet b/books/bookvol0.pamphlet
index e9df36c..11cfa44 100644
--- a/books/bookvol0.pamphlet
+++ b/books/bookvol0.pamphlet
@@ -1416,7 +1416,7 @@ floating point number to the nearest integer while the other truncates
 {\bf floating point} number. To extract the fractional part of a floating
 point number use the function {\bf fractionPart} but note that the sign
 of the result depends on the sign of the argument. Axiom obtains the
-fractional partof $x$ using $x - truncate(x)$:
+fractional part of $x$ using $x - truncate(x)$:
 
 \spadcommand{round(3.77623)}
 $$
@@ -1642,7 +1642,7 @@ Given that we can define expressions involving symbols, how do we actually
 compute the result when the symbols are assigned values? The answer is to
 use the {\bf eval} function which takes an expression as its first argument
 followed by a list of assignments. For example, to evaluate the expressions
-{\bf XDummy} and {xyDummy} resulting from their respective assignments above
+{\bf xDummy} and {\bf xyDummy} resulting from their respective assignments above
 we type:
 
 \spadcommand{eval(xDummy,x=3)}
@@ -1762,7 +1762,7 @@ $$
 
 Note that the semicolon ``;'' in the examples above allows several
 expressions to be entered on one line. The result of the last expression
-is displayed. remember also that the percent symbol ``\%'' is used to
+is displayed. Remember also that the percent symbol ``\%'' is used to
 represent the result of a previous calculation.
 
 To display rational numbers in a base other than 10 the function {\bf radix}
@@ -1834,7 +1834,7 @@ is available and returns a partial fraction of one term. To decompose this
 further the numerator can be obtained using {\bf firstNumer} and the 
 denominator with {\bf firstDenom}. The whole part of a partial fraction can
 be retrieved using {\bf wholePart} and the number of fractional parts can
-be found using the function {\bf numberOf FractionalTerms}:
+be found using the function {\bf numberOfFractionalTerms}:
 
 \spadcommand{t := partialFraction(234,40)}
 $$
@@ -1994,7 +1994,7 @@ include them in the object files produced and make them availabe to the
 end user for documentation purposes.
 
 A description is placed {\bf before} a calculation begins with three
-``+++'' signs and a description placed after a calculation begins with
+``+'' signs and a description placed after a calculation begins with
 two plus symbols ``++''. The so-called ``plus plus'' comments are used
 within the algebra files and are processed by the compiler to add
 to the documentation. The so-called ``minus minus'' comments are ignored
@@ -2718,7 +2718,7 @@ $$
 
 (note that {\tt ARRAY1} is an abbreviation for the type 
 {\tt OneDimensionalArray}.) Other types based on one-dimensional arrays are
-{\tt Vector}, {\tt String}, and {tt Bits}.
+{\tt Vector}, {\tt String}, and {\tt Bits}.
 
 \spadcommand{map!(i +-> i+1,a); a}
 $$
@@ -2899,8 +2899,8 @@ $$
 There are several things to point out concerning these
 examples. First, although flexible arrays are mutable, making copies
 of these arrays creates separate entities. This can be seen by the
-fact that the modification of element {\sl b.2} above did not alter
-{\sl a}. Second, the {\bf merge!}  function can take an extra argument
+fact that the modification of element {\sl g.2} above did not alter
+{\sl f}. Second, the {\bf merge!}  function can take an extra argument
 before the two arrays are merged. The argument is a comparison
 function and defaults to ``{\tt <=}'' if omitted. Lastly, 
 {\bf shrinkable} tells the system whether or not to let flexible arrays
@@ -3320,7 +3320,7 @@ current block whereas {\bf break} leaves the current loop. The {\bf return}
 statement leaves the current function.
 
 To skip the rest of a loop body and continue the next iteration of the loop
-use the {\bf iterate} statement (the -- starts a comment in Axiom)
+use the {\bf iterate} statement (the {\tt --} starts a comment in Axiom)
 \begin{verbatim}
 i := 0
 repeat
@@ -3595,8 +3595,8 @@ for w in ["This", "is", "your", "life!"] repeat
 The second form of the {\bf for} loop syntax includes a ``{\bf such that}''
 clause which must be of type {\bf Boolean}:
 \begin{center}
-for {\sl var} | {\sl BoolExpr} in {\sl seg} repeat {\sl loopBody}\\
-for {\sl var} | {\sl BoolExpr} in {\sl list} repeat {\sl loopBody}
+for {\sl var} in {\sl seg} \textbar\ {\sl BoolExpr} repeat {\sl loopBody}\\
+for {\sl var} in {\sl list} \textbar\ {\sl BoolExpr} repeat {\sl loopBody}
 \end{center}
 Some examples are:
 \begin{verbatim}
@@ -4262,7 +4262,7 @@ is the same as if you had entered
 
 Axiom statements in an input file
 (see \sectionref{ugInOutIn})
-can use indentation to indicate the program structure .
+can use indentation to indicate the program structure
 (see \sectionref{ugLangBlocks}).
 
 \subsection{Comments}
@@ -4337,7 +4337,7 @@ $$
 $$
 \returnType{Type: Fraction Integer}
 
-To factor fractions, you have to pmap {\bf factor} onto the numerator
+To factor fractions, you have to map {\bf factor} onto the numerator
 and denominator.
 
 \spadcommand{map(factor,r)}
@@ -4870,17 +4870,17 @@ $$
 $$
 \returnType{Type: FlexibleArray Integer}
 
-Flexible arrays are used to implement ``heaps.'' A {\it heap} is an
-example of a data structure called a {\it priority queue}, where
-elements are ordered with respect to one another. A heap
+Flexible arrays are used to implement ``heaps.'' A {\it heap}
 \footnote{\domainref{Heap}}
+is an example of a data structure called a {\it priority queue}, where
+elements are ordered with respect to one another. A heap
 is organized so as to optimize insertion
 and extraction of maximum elements.  The {\bf extract!} operation
 returns the maximum element of the heap, after destructively removing
 that element and reorganizing the heap so that the next maximum
 element is ready to be delivered.
 
-An easy way to create a heap is to apply the operation {\it heap}
+An easy way to create a heap is to apply the operation {\bf heap}
 to a list of values.
 \spadcommand{h := heap [-4,7,11,3,4,-7]}
 $$
@@ -4904,16 +4904,14 @@ $$
 A {\it binary tree} is a ``tree'' with at most two branches
 \index{tree} per node: it is either empty, or else is a node
 consisting of a value, and a left and right subtree (again, binary
-trees). \footnote{\domainref{BinarySearchTree}}
-Examples of binary tree types are {\tt BinarySearchTree}, 
+trees). Examples of binary tree types are {\tt BinarySearchTree}, 
 {\tt PendantTree}, {\tt TournamentTree}, and {\tt BalancedBinaryTree}.
-\footnote{\domainref{BalancedBinaryTree}}
 
 A {\it binary search tree} is a binary tree such that,
 \index{tree!binary search} for each node, the value of the node is
 \index{binary search tree} greater than all values (if any) in the
 left subtree, and less than or equal all values (if any) in the right
-subtree.
+subtree. \footnote{\domainref{BinarySearchTree}}
 \spadcommand{binarySearchTree [5,3,2,9,4,7,11]}
 $$
 \left[
@@ -4926,6 +4924,7 @@ $$
 \returnType{Type: BinarySearchTree PositiveInteger}
 
 A {\it balanced binary tree} is useful for doing modular computations.
+\footnote{\domainref{BalancedBinaryTree}}
 \index{balanced binary tree} Given a list $lm$ of moduli,
 \index{tree!balanced binary} {\bf modTree}$(a,lm)$ produces
 a balanced binary tree with the values $a \bmod m$ at its leaves.
@@ -4944,7 +4943,7 @@ corresponding structure like streams for infinite collections.
 
 Create sets using braces ``\{`` and ``\}'' rather than brackets.
 
-\spadcommand{fs := set[1/3,4/5,-1/3,4/5]}
+\spadcommand{fs := set [1/3,4/5,-1/3,4/5]}
 $$
 \left\{
 -{\frac{1}{3}},  {\frac{1}{3}},  {\frac{4}{5}}