While preparing my invited talk for a conference: http://atcm.mathandtech.org/ (you can see my name listed as an invited speaker), I started checking out Axiom, some software I last wrote about (and used) some seven or more years ago. At that time there was a great rift between the developers, all of whom disagreed about the directions of the project. Axiom thus forked into two new systems: FriCAS and OpenAxiom. Of those two, I believe that FriCAS is the most actively developed, and indeed seems to be growing considerably, given the relatively small number of developers (and users). Although Axiom (as well as its forks) is a mature system, it never really took off as its original developers (IBM, and then NAG) had hoped, hence its release as open source.

Beacuse of the forks, there is now some confusion of names. I have been in the habit of using “Axiom” to mean both the original Axiom, or Axiom and its forks. However, given the divergence between the systems, there needs to be some way of distinguishing what is common to all the systems, and what is particular to just one. The name “PanAxiom” has been proposed for the umbrella systems of Axiom, FriCAS and OpenAxiom. Since most people seem to stick within just one system, the term is not much used. I’m not sure however whether PanAxiom is singular or plural. I’m going for the former.

Since my talk is about open source systems in mathematics and mathematics education, I thought it sensible to see where the software has got to these days. Here’s some of what I know:

- Axiom and its forks are still, as far as I know, the
*only*open-source systems which support the complete Risch decision algorithm for integration of elementary functions. This is courtesy of some remarkable work, both theoretical and computational, by the brilliant Manuel Bronstein in the 1980’s and early 1990’s. Bronstein’s untimely death in 2005, at the age of only 41, robbed the world of symbolic computation of one of its great minds.

For example, look at the example on the Wikipedia Risch algorithm page. This is an integral most systems can’t manage. Axiom has no trouble. - FriCAS has now some support for special functions, which greatly enlarges the set of functions which have an integral expressed in functional form. For example, FriCAS returns an answer to

in terms of the Gamma function, whereas Axiom leaves this integral unevaluated. - FriCAS now has a recently developed note book interface, similar to that for Sage, which even includes graphics and typeset output. See http://kfp.bitbucket.org/tmp/version-0-9-2.html for examples. This is considered beta code only as yet, but I have found it robust and usable.
- FriCAS also has an Emacs mode with typeset output, similar to iMaxima.
- Documentation is still scattered and hard to find, but the old HyperDoc help interface, even though it looks clunky and old fashioned, is very powerful. Much to my delight I have recently found that user-code compiled in the system is automatically picked up an displayed in HyperDoc.
- Axiom is being reworked to use a browser as its front end, and HyperDoc is slowly being ported to xhtml. You can see its current state here.
- FriCAS now has a documentation web page which includes an API, so much of HyperDoc’s material is available here.
- Axiom and FriCAS are right pains to program in. This is because they are a mixture of Lisp, SPAD (a high level language developed for and with the system), and BOOT, a sort of simplified Lisp for low-level stuff. As I am very much of a Lisp newbie, I am finding “getting into” development very difficult. There is also the curious anomaly that whereas in Lisp lists are indexed starting at zero (such as with Python), in Axiom and FriCAS indexing starts at 1. But I guess Maxima is the same.
- There is a small but growing handful of new users and developers. One place well worth checking out is the site euclideanspace.
- PanAxiom is in my opinion a system worth keeping alive and worth wrestling with as it is the
*only*system with strong typing. Every object consists of a type, and types can be nested. So you can have, for example, matrices of polynomials over fractions of integers, objects of which would have the type`Matrix Polynomial Fraction Integer`

or in abbreviated form

`MATRIX POLY FRAC INT`

The use of types means a confusing and slow learning curve, but the resulting power is extraordinary. For an almost trivial example, you can factor a polynomial over different prime fields:`(1) -> ex:=x^8-1``Type: Polynomial(Integer)``(2) -> factor(ex)``Type: Factored(Polynomial(Integer))``(3) -> factor(ex::POLY PF 3)``Type: Factored(Polynomial(PrimeField(3)))``(4) -> factor(ex::POLY PF 17)``Type: Factored(Polynomial(PrimeField(17)))`You can do similar things in other systems, but not with the same robust power as in PanAxiom.

There is much more happening all the time, although slowly, due to the very small number of users and developers. Maybe the new browser interface will bring more people to use, and appreciate, PanAxiom.