Computer Algebra Systems

Two Kinds of Arithmetic

Most scientific computing is numerical: it turns everything into floating-point numbers and accepts a small error in exchange for an answer. Ask a numerical system for the square root of 2 and it gives 1.4142135, a decimal that is close but wrong. A computer algebra system keeps √2 as √2, an exact object it can square back to precisely 2. It manipulates variables, functions, and equations as structured expressions, applying the same rewrite rules a person applies with pencil and paper: expand, factor, differentiate, integrate, simplify, solve.

That distinction, symbolic against numerical, splits the whole field of mathematical software. Numerical computing (see Scientific and Numerical Computing) answers “how much”; symbolic computing answers “what is the formula.” The symbolic side is harder for a machine because an expression can grow explosively during a calculation, and because deciding whether two formulas are equal is, in general, undecidable. The early systems were built by people who ran into that wall in their day jobs.

The Physicists Who Needed It

The first working system came from a physicist who was tired of the arithmetic. Martinus Veltman, a Dutch theorist, wrote Schoonschip in 1963, first on an IBM 7094 and then on the CDC 6600. The name is Dutch for making a clean sweep, chosen, Veltman said, partly to annoy everyone who could not pronounce it. Its job was the enormous algebra of particle-physics calculations, expressions that ran to tens of thousands of terms and would take a lifetime to expand by hand. Veltman used it through the work that let him and his student Gerardus ’t Hooft prove the electroweak theory renormalizable, the calculation that won them the 1999 Nobel Prize in Physics. A tool built to save a physicist’s afternoons ended up under a Nobel.

The other physics-driven system was REDUCE, begun by Anthony Hearn at Stanford in 1963 for computing with Feynman diagrams. Hearn wrote it in Lisp, on top of an ALGOL-like layer called RLISP, and passed it hand to hand around the physics community for decades before it went open source in December 2008. Both systems answered the same need from the same corner of science: the mathematics of the very small produces algebra too big for a human.

Macsyma

The other root was artificial intelligence. To the researchers at MIT’s Project MAC, symbolic integration was not a chore to automate but a benchmark for machine intelligence: if a program could integrate the way a calculus student does, by pattern and strategy rather than by rote, that would say something about reasoning. In July 1968 Carl Engelman, William Martin, and Joel Moses started Macsyma, short for Project MAC’s Symbolic Manipulator. Moses wrote the integration engine and directed the project from 1971 to 1982.

Macsyma was written in Maclisp and became one of the largest Lisp programs in existence, possibly the largest of its time. It could simplify expressions, solve equations, work with polynomials, and integrate functions that defeated most humans, and for years it defined what a computer algebra system could do. Nearly every later system borrowed from it. But Macsyma needed a big, expensive machine, and its ownership was tangled: MIT licensed it to Symbolics in 1982, the same company whose Lisp-machine business was about to collapse (see The Lisp Machine Era). By the time Macsyma, Inc. was spun out in 1992, its share of the market had fallen from about 70 percent in 1987 to roughly 1 percent. The two systems that took the market away had both been designed to escape exactly the hardware Macsyma was chained to.

The code outlived the companies. Bill Schelter had maintained a version for the US Department of Energy, and in 1999 he released it under the GPL as Maxima, which is still developed today.

Escaping the Lisp Machine

In late 1980 a group at the University of Waterloo wanted to run Macsyma and found it needed a computer they could not afford to give every student. Rather than buy the hardware, they wrote their own system to run on cheap machines. That was Maple, led by Keith Geddes and Gaston Gonnet in Waterloo’s Symbolic Computation Group. To stay portable they wrote its kernel in C and kept it small, pushing most of the mathematics into a library written in Maple’s own language. A first limited version worked within three weeks; by the end of 1983 more than fifty universities had it installed. Waterloo Maple, later Maplesoft, was founded in 1988 to sell it.

Maple’s design choice, a small fast kernel plus a large open library, was the direct answer to Macsyma’s weight. It let the same system run on a departmental minicomputer and, before long, on a personal computer.

Mathematica

Stephen Wolfram came to the field through physics and through an earlier system of his own called SMP, which he built at Caltech between 1979 and 1981 and which left him in a dispute with the university over who owned it. He founded Wolfram Research in 1987 and released Mathematica 1.0 on 23 June 1988. It combined symbolic algebra, numerical computation, and graphics in one notebook interface, and it was bundled with the NeXT computer, which put it in front of exactly the technical users who wanted it. Wolfram had talked with Veltman about Schoonschip years earlier; a line runs from the physicist’s term-crunching assembly program to the polished product that made “Mathematica” a verb in engineering departments.

Mathematica and Maple became the two systems most students met, and the split between them, one a single tightly controlled commercial product, the other also commercial but rooted in an open library and university ties, defined the mainstream of computer algebra for the next thirty years. Wolfram later rebranded the underlying notation as the Wolfram Language and, in 2009, launched Wolfram Alpha to answer plain-language questions from the same engine.

Algebra in a Calculator

The systems so far all assumed a real computer. The pair that did not were muMATH and its successor Derive, written by David Stoutemyer and Albert Rich at Soft Warehouse in Honolulu. Derive, released for MS-DOS in 1988 and implemented in a compact Lisp, needed so little memory that it ran on machines everything else had outgrown. That frugality made it the first computer algebra system small enough to fit inside a calculator. Texas Instruments licensed the technology and built it into the TI-89 and TI-92 graphing calculators, so a high-school student could factor a polynomial on a device in their backpack. TI bought Derive outright and then discontinued it on 29 June 2007, folding its symbolic engine into the newer TI-Nspire line. A generation of students used a full computer algebra system without ever knowing its name.

Dead End: Axiom

The most ambitious design of them all started at IBM and never found its market. Scratchpad began at IBM Research in 1965 under James Griesmer, written in Fortran and never released. In 1977 Richard Jenks started Scratchpad II at the Thomas J. Watson Research Center, and it took a path no other system did. Where Maple and Mathematica let you type an expression and get an answer, Scratchpad II was built on a strongly typed hierarchy of mathematical structures: categories and domains, so that “integers modulo 7” or “polynomials over a field” were first-class types with their own operations, and the system knew algebraically what kind of object it was holding. This was, in effect, generic programming with rigorous mathematical types, years before mainstream languages reached the same ideas.

Around 1990 IBM renamed it Axiom and turned it into a commercial product, then sold it to the Numerical Algorithms Group. It failed to sell. Most users did not want to declare the algebraic type of everything they touched; they wanted to type an integral and get a formula, which Maple and Mathematica let them do without a lecture on category theory. In 2001 Axiom was withdrawn from the market and re-released under a BSD license, taken up by Tim Daly, who rebuilt it around literate programming and the goal of making its mathematics formally verifiable. In 2007 disagreements over direction split it into two forks, FriCAS and OpenAxiom, and the three descendants have carried on as small open-source projects since.

Axiom is the field’s clearest case of the best design losing. Its type system was more principled than anything its rivals had, and pieces of that thinking turned up later in serious programming languages. What it never had was a user who found it easier than the alternatives. Mathematical elegance and market survival turned out to be different problems.

The Open Generation

The commercial systems left room underneath them, and the free ones filled it. Maxima carried Macsyma forward. SymPy, a symbolic library written in pure Python, let algebra live inside ordinary programs and data-science notebooks. SageMath, started by William Stein in 2005, took a different tack: rather than reinvent every algorithm, it wrapped Maxima, GAP, PARI, Singular, and dozens of other specialized tools behind one Python interface, assembling a free alternative to Maple and Mathematica out of the open-source pieces the research community had already built. Specialized systems, GAP for group theory, PARI for number theory, Singular for algebraic geometry, went deeper in their corners than any general system could.

Sixty years on, the two questions that started it all are still the split in the field: the physicists’ problem of algebra too big to do by hand, and the AI researchers’ problem of teaching a machine to reason with symbols. Both got usable answers. Neither got a final one.

📚 Sources

• Computer algebra system (Wikipedia) — symbolic vs. numerical, timeline of major systems, earliest work
• Macsyma (Wikipedia) — Project MAC origins 1968, Engelman/Martin/Moses, Maclisp, Symbolics license, market-share collapse, Maxima release
• Schoonschip (Wikipedia) — Veltman 1963, IBM 7094/CDC 6600, particle-physics algebra, name origin, Nobel connection
• REDUCE (Wikipedia) — Anthony Hearn 1963, Feynman diagrams, RLISP, 2008 open-source release
• Maple (Wikipedia) — Waterloo 1980, Geddes and Gonnet, small-kernel design, Maplesoft founding
• Wolfram Mathematica (Wikipedia) — SMP and the Caltech dispute, Wolfram Research 1987, Mathematica 1.0 June 1988, NeXT, Wolfram Alpha
• Axiom (Wikipedia) — Scratchpad 1965/Griesmer, Scratchpad II 1977/Jenks, category-domain type system, NAG commercialization and 2001 withdrawal, FriCAS/OpenAxiom forks
• Derive (Wikipedia) — Soft Warehouse, muMATH successor, 1988 release, TI-89/TI-92 licensing, 2007 discontinuation
• The 1999 Nobel Prize in Physics — ’t Hooft and Veltman for the electroweak theory