The author defines the focus of this book as follows: “the formulation of algorithms that solve symbolic mathematical problems...the implementation of these algorithms in terms of the operations and control structures available in computer algebra programming languages.” The book is suitable as preliminary reading for computer algebra courses.

Although this is a self-contained book, it is worth noting at the outset that it is Part 1 of a two-volume series; the other [1] focuses on mathematical methods. One of the book’s strengths is that it compares three computer algebra systems (Maple, Mathematica, and Mupad), and is therefore able to illustrate the point (made better than in most other texts) that there is more than one way of mapping mathematics into computer algebra. Several of the exercises are of the form “explore how your computer algebra system handles this concept,” emphasizing this point. The strongly typed systems, however (such as Axiom and Magma), with their greater emphasis on canonical forms, are not featured. The author’s capacity for abstracting from particular systems is well illustrated when he discusses the confusion between programming variables and mathematical variables (p. 139), although he could also have cited Moses [2].

The chapter headings give a feel for the content: “Introduction,” “Elementary Concepts,” “Recursive Structure of Mathematical Expressions,” “Elementary Mathematical Algorithms,” “Recursive Algorithms” (including a heuristic integrator), “Structure of Polynomials and Rational Expressions,” and “Exponential and Trigonometric Transformations” (but no description of logarithmic transformations, thereby silently side-stepping many issues of branch cuts and so on [3]).

The author says (p. 121) “in describing mathematical algorithms, we take a middle ground between the computer scientist’s need for precision and the mathematician’s need for practical approaches for solving a problem.” Apart from being a caricature of both sides, this also leads the author into describing “semantic capacity” (his phrase) in terms of “yes/no,” rather than, as we know from Richardson [4], “yes/no/cannot tell”: admittedly a fundamental problem for computer algebra as a whole, not just for this book. Similarly, the discussion of “simplification context” (p. 128) makes no mention of the concept of canonical forms, a concept conspicuous by its absence throughout the book: see the second display on p. 304, where the failure of the trigonometric simplifier is caused by the failure to invoke a canonical rational function simplifier. On page 9, the author asks, quite reasonably, “Is it possible to give a precise definition of simplify?” but fails to discuss this throughout the text, whereas it is a fundamental question in computer algebra.

The discussion of transformation rules in the context of differentiat ion (pp. 182-186) is good as far as it goes, but fails to make the fundamental point that a transformation rule approach can fundamentally change the modularity and extensibility of a computer algebra system. A procedural approach to differentiation means that the differentiate procedure has to know about the derivatives of all the functions, whereas in a rule-based approach, each new function can add its own differentiation rules. This moves us closer to an object orientation.

A good description of what can be achieved at this level can be found in the description of ordinary differential equations in 4.3. Conversely, the description of integration (p. 199) is flawed in several respects:

• The author arbitrarily prefers ln x to ln |x| as the integral of 1/x, without citing Stoutemyer [5].
• Equation 5.16 (∫ ∑ f_i = ∑ ∫ f_i) is quoted without citing the fact that if, as is implicit in this section, “∫” means “I can integrate”, this equation is only valid in the backwards direction: if the right-hand side integrates, then so does the left, but the left-hand side can integrate without each summand integrating.
• The author’s appraisal (pp. 207-8) of integration does not make any reference to deterministic theories, and a throwaway reference (p. 212) to Bronstein [6] (his reference 13) as a “theoretical discussion” does not help.

The author tries to avoid the usual problem in computer algebra of glossing over the difference between multi-valued “algebraically defined” functions (which most algebra systems manipulate) and single-valued “C → C” functions to which most users think they are referring [7]. However, he does this by saying that exp(ab) → exp(a)^b is valid for non-integer b “in real context,” without defining this. What would happen to exp((2&pgr;i)½)?

Despite the problems outlined above, this work is a good answer to the task the author sets himself, and I will be recommending it to my computer algebra class as preliminary reading.