Like all Computer Algebra Systems, Axiom has both online documentation, and various other web pages devoted to its description.

HyperDoc

If you are using Axiom under linux, or under Windows with the Xming X-server, you will have access to the HyperDoc help browser. Although this can look a little old-fashioned (in terms of its widgets), it is extraordinarily powerful, and very useful. It contains:

• the complete text of the book “Axiom: The Scientific Computation System” by Richard Jenks and Robert Sutor (Springer, 1992), in a convenient hypertext format
• masses of examples
• a useful search facility
• a browse system, where you can browse Axiom by commands, or libraries. For example, you can find all the commands which apply to finite fields, what they do, and how they can be used.

HyperDoc is started automatically when you start Axiom. Although HyperDoc can be used as a stand-alone help browser, it connects with Axiom using a socket, so it can run Axiom commands.

Here are a couple of screenshots; one with graphics, one with algebra (click on each image to show a full-sized version):

Other help from within Axiom

If you only have a console based Axiom, then there is limited help available from within Axiom itself. However, there are a few commands you can use to provide some information. Suppose, for example, you wish to list all operations containing the string “diff“. Then you enter

)wh op diff

which is an abbreviation for

)what operations diff

and receive the output

Operations whose names satisfy the above pattern(s):

diff              difference               differentialVariables
differentiate     exteriorDifferential     mergeDifference
setDifference     symmetricDifference      totalDifferential

      To get more information about an operation such as
      differentiate, issue the command
      )display op differentiate

To list domains, categories or packages, you can write

)wh do diff
)wh ca diff
)wh pa diff

The command

)wh th diff

which is an abbreviation for

)what things diff

lists everything which contains the substring “diff“.

Now suppose we want to find out about the operation “difference“:

)d op difference

which is an abbreviation for

)display operation difference

and which produces

There are 2 exposed functions called difference :
   [1] (D,D1) -> D from D if D has SETAGG D1 and D1 has SETCAT
   [2] (D,D) -> D from D if D has SETAGG D1 and D1 has SETCAT

If you want to find out what “difference” actually does, without using HyperDoc, and from within Axiom itself, you can’t.

However, a very handy command is show, which when applied to a domain lists all operations defined on that domain. Here for exmaple, we find out about Cliiford alegbras, whose type has abbreviation CLIF:

)sh CLIF

with output

CliffordAlgebra(n: PositiveInteger,K: Field,Q: QuadraticForm(n,K))
 is a constructor
 Abbreviation for CliffordAlgebra is CLIF
 This constructor is exposed in this frame.
 Issue )edit /usr/local/axiom/mnt/linux/../../src/algebra/CLIF.spad
to see source code for CLIF

------------------------------- Operations -------------------------------
 ?*? : (%,K) -> %                      ?*? : (K,%) -> %
 ?*? : (%,%) -> %                      ?*? : (Integer,%) -> %
 ?*? : (PositiveInteger,%) -> %        ?**? : (%,PositiveInteger) -> %
 ?+? : (%,%) -> %                      ?-? : (%,%) -> %
 -? : % -> %                           ?/? : (%,K) -> %
 ?=? : (%,%) -> Boolean                1 : () -> %
 0 : () -> %                           ?^? : (%,PositiveInteger) -> %
 coerce : K -> %                       coerce : Integer -> %
 coerce : % -> OutputForm              dimension : () -> CardinalNumber
 e : PositiveInteger -> %              hash : % -> SingleInteger
 latex : % -> String                   one? : % -> Boolean
 recip : % -> Union(%,"failed")        sample : () -> %
 zero? : % -> Boolean                  ?~=? : (%,%) -> Boolean
 ?*? : (NonNegativeInteger,%) -> %
 ?**? : (%,NonNegativeInteger) -> %
 ?^? : (%,NonNegativeInteger) -> %
 characteristic : () -> NonNegativeInteger
 coefficient : (%,List PositiveInteger) -> K
 monomial : (K,List PositiveInteger) -> %
 subtractIfCan : (%,%) -> Union(%,"failed")

It seems that we can add, subtract, multiply and divide elements in a Clifford algebra, as well as raising an element to an integer power. As well as other operations.

Local help outside Axiom

If you have a complete Axiom system, or have compiled it from scratch and also compiled the documentation, you’ll find some useful files in the

mnt/linux/doc

directory, of which the most important and useful are:

Rosetta.dvi

This is the “Rosetta Stone” and provides a “collection of synonyms for various operations in the computer algebra systems Axiom, Derive, GAP, Gmp, DoCon,
Macsyma, Magnus, Maxima, Maple, Mathematica, MuPAD, Octave, Pari, Reduce, Scilab, Sumit and Yacas.” Without being comprehensive, it is nonetheless an incredibly useful document, especially if you’re coming to a new CAS after experience with another.

book.dvi

This is the Jenks/Sutor book, with additions – 1136 pages! Not for printing!

bookvol1.dvi

This is a Tutorial volume, and a very good starting place for learning about Axiom. It exists also in printed form, available from lulu.com.

Online help

There is also some very good material online. First off is an xhtml version of the Jenks/Sutor book, at http://axiom-wiki.newsynthesis.org/uploads/contents.xhtml

Complete pdf files of all Axiom user documentation are available at
http://www.axiom-developer.org/axiom-website/documentation.html
This page also contains a link to the beginnings of a new browser-based interface to the HyperDoc material.

For tutorials, the best one in English is by Martin Dunstan, from as long ago as 1996, at
http://www.dcs.st-and.ac.uk/~mnd/documentation/axiom_tutorial.

There are some excellent tutorials in French, by Daniel Augot at
http://www-rocq.inria.fr/codes/Daniel.Augot/axiom_intro.pdf
and by Christophe Conil and Quentin Carpent at
http://la.riverotte.free.fr/axiom.

Now – get out there and learn about Axiom!

(It’s been a while since I posted about Axiom – that’s what exam marking does!)

Axiom has a full and complete, and well-structured programming language. Rather than describe it in detail, I’ll just make a few general remarks, and provide a few examples.

A simple function

Here’s an example of a simple program, to solve an equation numerically by the bisection method. We implement the following algorithm:

INPUT: function f,
       values a,b for which f(a)f(b)< 0,
       a tolerance eps
WHILE f(a)>eps REPEAT
  c = (a+b)/2
  IF sign(f(a))=sign(f(c))
    THEN a = c
    ELSE b = c
RETURN a

For this algorithm at least, the program is very similar in Axiom:

bisect(f,a,b,eps) ==
  local c
  while abs(f(a))>eps repeat
    c:=numeric (a+b)/2
    if sign(f(a))=sign(f(c)) then
      a:=c
    else
      b:=c
  return(a)

Note that for ease of exposition I’ve done no sign checking on the values of f(a) and f(b). This little program can be saved in a file called bisect.input and read into Axiom with the command

)read bisect

And now it can be used:

Note the use of anonymous functions.

Axiom programs are made of blocks, which are groups of statements all with the same indentation, or alternatively delineated with parentheses; the statements being separated with semicolons. The above program could be entered as

bisect2(f,a,b,eps) == (while abs(f(a))>eps repeat (c:=numeric (a+b)/2;if sign(f(a))=sign(f(c)) then a:=c else b:=c),return a)

This is equally correct, but less readable.

Axiom contains the usual programming constructs: loops with for and while, branching, and recursion. The above program shows several of these.

An algebraic problem

If you factorize for a few values of , each factor seems to have non-zero coefficients only of 1 or -1. This might lead us to conjecture that this is the case for all . We can write some functions and programs to test this. First, the maximum coefficient of a polynomial:

maxCoeff(p) ==
  reduce(max,map(abs,coefficients(p)))

Next, the maximum coefficient taken over all factors of a polynomial:

maxFactCoeff(q) ==
  reduce(max,[maxCoeff(nthFactor(q,j)) for j in 1..numberOfFactors(q)])

Finally, the “driver” program which simply lists all values of for which the factorization of contains a factor one of whose coefficients has an absolute value greater than 1:

testCoeff() ==
  for k in 1.. repeat
    if maxFactCoeff(factor(x^(k::PI)-1))>1 then print(k)

Put all these into a single file, called say maxFactor.input, read it into Axiom with

)read maxFactor

and run it with

testCoeff()

You will obtain the following values:

   105
   165
   195
   210
   255
   273
   285
   315
   330
   345
   357

and so on, until either you hit CTRL-c to abort the program, or you hit your computer with a heavy brick. (I suggest the first method).

This problem can be equivalently stated in terms of the coefficients of cyclotomic polynomials, and in fact the sequence generated above is sequence A013590 in the Online Encyclopaedia of Integer Sequences: “Orders of cyclotomic polynomials containing a coefficient >= 2.”

So far, Axiom does most of the calculation we would expect of any computer algebra system. But now we look at an aspect of Axiom which sets it apart from other systems: its use of types. In Axiom, “type” is another word for “domain”, or “domain of computation”, which is a method of organizing all objects. Objects include standard mathematical constructs such as matrices, functions, integers, abelian groups; data structures such as lists and arrays; as well as constructs built up from other constructs. Thus in Axiom we can create and use the type: “List of square matrices of polynomials over integer fractions”. The type of the operand indicates the type of the operation: a simple multiplication * will have a different interpretation depending on whether the operands are integers, real numbers (floats), matrices, elements of a finite field, or many other types.

There are three special symbols which are used when dealing with types:

::

This is used for converting from one type to another. In the form object::type it takes the object object and converts it to type type.

$

This means to take the operation as defined for objects of the given type. It is used in the form (operand1 operation operand2)$type.

@

This means to choose the operation (and possibly convert the types of the objects, if needed) so that the result is of the given type.

As examples of the use and misuse of these symbols, let’s investigate the calculation

The type we will use is IntegerMod, which can be abbreviated ZMOD:

What is happening here? In the first command, we deliberately ask that the power be taken from its ZMOD definition; that is, using the well-known fast algorithm. In the second command, the 3 was defined as being of type “ZMOD 1048576” before the power was attempted. This means that any further arithmetic on the 3 will use versions taken from their ZMOD definitions. The last command says, in effect: “First work out the value of 3^1000000000, and then convert that to a value modulo 1048576.” Needless to say, this is wasteful of time and memory, and will probably cause an overflow and crash Axiom.

Here’s another example of type conversion, this time using prime fields. The abbreviation for the finite field of residues modulo a prime p is PF p.

Note that we are using a type built of other types here: we have to convert the polynomial p to the type POLY PF 5 to indicate that the type we want is polynomials defined over the finite field .

An example using matrices:

Note that again we had to give the full type of A. If we tried to convert A to type “PF 11” Axiom would return an error message saying that the particular conversion is not possible.

Finally, some examples of “package calling” – calling a command with the same name (in this case random) but from different packages. The first command requests a random integer; the second a random residue from the finite field , and the last a random element from the finite field :

Moving right on, from http://amca01.wordpress.com/2008/05/29/an-introduction-to-axiom-4/ this post will be a simple introduction to Axiom’s graphics.

To obtain graphics, you need to run Axiom in Linux, or in windows within an X-windows system, such as Xming. At the time of writing, there is no native windows graphics subsystem for Axiom.

Having said that, Axiom’s graphics are sophisticated and powerful. In the plane you can draw:

• graphs of functions
• parametric graphs
• graphs defined algebraically
• graphs defined with polar, bipolar, elliptic or parabolic coordinates

In three-dimensions, you can have

• surfaces defined by
• parametric space curves
• surfaces defined parametrically
• curves or surfaces defined with other coordinate systems, including cylindrical, spherical, paraboloidal, conical

The command to produce any such graphic is draw. The graphic can be changed in numerous ways, either by adding a parameter to the draw command, or by using the associated control panel.

Here are two elementary examples: plane curves, one the graph of a cubic polynomial in cartesian coordinates, the other a trisectrix given in polar coordinates:

Associated with any such graphic is a control panel, which can be displayed by clicking on the graphic:

The panel allows you to change the size and position of the graphic, whether or not you want points shown (the default is to show points on the curve), whether or not you want a bounding box, or axes, or scales…

Now for some three-dimensional surfaces, each one given in the form . The first is Scherk’s minimal surface, defined implicitly by , and the second is the “monkey saddle” surface defined by :

Associated with a 3D graphic is a control panel, which allows you to change much of the appearance of the graphic, as well as its orientation:

A second control panel, accessed from the first, allows you to change the bounds of the graphic, and its perspective:

It’s quite easy to build a complicated graphic by plotting several surfaces or shapes on the one set of axes. The following commands illustrate how to set up a graphic consisting of two interlocked tori:

and the result:

Finally, a couple of knots; first a trefoil knot, constructed parametrically with

and a figure of eight knot with

(I found these equations at http://www.infradead.org/~wmp/proj_knots.html.)

Here they are:

Following on from http://amca01.wordpress.com/2008/05/26/an-introduction-to-axiom-3/,
here’s the fourth installment – lists, matrices and linear algebra.

Lists are a standard data structure in most CAS’s, and Axiom is no exception. A list is delineated with square brackets, and can either be defined by listing it in full, or by iterating a function over a range of integers.

Given a list X, its i-th element is obtained with X.i. The first examples show the creation of a list, and some operations on it:

There are a few things to note here:

• reduce extends a binary operation to a list, working its way through the list taking an extra element each time.
• The final operation shows an example of an “anonymous function”; that is, a function which hasn’t been given a name. The use of the +-> is useful when you want to use a function “on the fly” or when you are only to going to need it once. The last operation could have been done with

  f(x)==x^2+1
map(f,L)


  but that requires defining function first.

Matrices are defined as lists of lists. All arithmetic is supported, and inversion, if the matrix is square and non-singular.

Here’s a matrix inversion, with a coercion to a matrix of floats:

Axiom can do all the things you’d expect on matrices: find the determinant and permanent, eigenvalues and eigenvectors, row-echelon form, null space… To finish here, a little example of the Cayley-Hamilton theorem, and a solution of a set of linear equations, using matrices:

The output of the last command is given using Axiom’s Record data structure. To isolate individual parts of this output, we refer to them by name. So to obtain the y value (the second value), we would use

%%(64).particular.2

Here the “particular” is a particular example of a solution, and “basis” the basis for the set of solutions. This is an easy and elegant way of describing multiple solutions to a linear system.

This is the third in a sequence of posts about the open source CAS Axiom. The previous post can be found at http://amca01.wordpress.com/2008/05/25/an-introduction-to-axiom-2/.

In this post I shall be looking at Axiom’s calculus abilities, starting with every beginning student’s love, limits:

Note here the use of %plusInfinity which is positive infinity. Axiom also has %minusInfinity. Limits are also possible for complex variables, using complexLimit, and %infinity for complex infinity.

After limits there are derivatives, implemented in Axiom with D. A third optional parameter gives the order of the derivative:

Integration is performed with the integrate command. Sometimes Axiom gets worried that an integrand may have a pole in the region of integration, in which case the addition of the string "noPole" will alleviate its fears:

Now for some series. There are several different commands for producing a power series, of which series is the most general. The following three commands show some of the power of Axiom’s type system. Since the first two outputs are of type UnivariatePuiseuxSeries, arithmetic on them will produce an output also of that type. Thus the division command produces the series for :

As an example of Axiom’s calculus power, let’s use the series command as a generating function. In particular we shall construct the Euler polynomials
defined by

So first create the series, and then extract a particular polynomial from it:

Finally, some differential equations. Note the use of the solve command – since the equation to be solved is a differential equation, solveproduces an appropriate solution. The main thing to note here is the prior definition of the unknown function as an operator:

This is the second in a sequence of posts about the open source CAS Axiom. The first can be found at http://amca01.wordpress.com/2008/05/25/an-introduction-to-axiom-1/

Axiom variables are created using the “colon equals” method of many other computer languages, and user defined functions with a double equals:

Note that for the last example, the expression involving radicals can be simplified directly, but it requires playing around with types.

Expansion, factorization and simplification of all sorts of expressions can be accomplished easily:

Axiom has powerful algorithms to solve polynomial equations, systems of polynomials, and linear system. There are in fact several different solve functions:

solve

Basic solve function: will produce real solutions. The precision of the solution can be adjusted by including an extra parameter

complexSolve

The complex version of solve – will produce complex solutions, also with an adjustable numerical precision

radicalSolve

As its name implies, solutions in the form of radicals, if such can be found.

Note that solve will in general produce numeric solutions, unless the equations are linear. When the precision is given, the list of variables need not be given explicitly, as, according to the documentation: “The list of variables would be redundant information since there can be no parameters for the numerical solver.”

This is the first of what I intend to be a series of posts, exploring the open source computer algebra system Axiom. Maxima has already been extremely well described on math-blog. I hope to do something similar for Axiom, but over several posts.

Obtaining and using Axiom

First: go to http://www.axiom-developer.org/ for a description and discussion, and then go to http://www.axiom-developer.org/axiom-website/download.html to find and download some binaries. Axiom works best under linux. Under windows you have several choices: you can run a native binary in console mode only, without graphics, or you can run Axiom inside an X-windows server for Windows such as Xming. The best interface for Axiom is to use it as a session within the TeXmacs editor. Screenshots of this can be seen here.

A note on Axiom and its forks

Owing to some disagreement among Axiom developers, the original Axiom has spawned two forks: FriCAS, and OpenAxiom. From the users’ point of view, there is not much to choose between the three. However, the development models and goals of the three are very different:

1. Axiom “is intended to support educational and research objectives”, and aims to be very slow and careful in its development, using literate programming, so the development done now will still be useful and readable in 30 years time. Thus Axiom puts great stress on provable correctness of algorithms, and readability of code. This can make adding new material non-trivial.
2. FriCAS “will use lightweight developement, allowing much faster evolution.” Also, FriCAS “add hooks which make adding alternative user interfaces easier.” FriCAS aims to be more user friendly than its parent, and in particular easier to extend.
3. OpenAxiom “aims at being the open source computer algebra system of choice for research, teaching, engineering, etc.” It differs from its parent in technical details.

I will use the term “Axiom” to mean either the original Axiom, or the user experience of using any of its forks.

In these posts, Axiom will be presented as a sequence of images, showing Axiom output TeX-ed up to look good. This is similar to what you would obtain using TeXmacs.

One very important aspect of Axiom is that it uses types extensively. Everything you do in Axiom takes an input of one of the many types defined in Axiom, and produces an output of a particular type. One of the greatest difficulties for the beginner (well, it was certainly hard for me!) is making sense of the types, and ensuring that your input type is commensurate with the mathematics you are trying to do with it. But this is also one of Axiom’s greatest strengths.

But let’s start simply: Axiom can be used like a calculator:

Axiom has all the standard functions:

Note that %pi produces , and %i the imaginary unit. Other constants include various infinities, which I’ll talk about in a further post.

Note that Axiom, like most computer algebra systems, will attempt to give a result in closed (symbolic) form. To force a floating point output, you need to include a floating point input, or use the numeric function, or coerce your input to be of type Float. (I’ll discuss types and coercion in a later post.)

Axiom has no trouble with integers of arbitrary size:

And Axiom can produce numeric output to arbitrary precision. The number of digits displayed is set by the digits function. The last two commands here are classic examples of “near integer” computations.

The next post can be found at http://amca01.wordpress.com/2008/05/25/an-introduction-to-axiom-2/

I have just written about the freeware CAS Maxima; this time it’s about Axiom. Axiom differs from most CAS’s in being strongly typed, in that each expression belongs to a particular type, such as the integers, or polynomials, or finite fields. One of the difficulties for a beginner with Axiom is using types correctly.

As with Maxima, here is a very small example: Newton’s method interactively:

First define the function:

(1) -> f:=x^5+x^2-1

         5    2
   (1)  x  + x  - 1

                     Type: Polynomial Integer

and its derivative

(2) -> d:=D(f,x)

          4
   (2)  5x  + 2x

                     Type: Polynomial Integer

Now put them together as in a Newton’s method, where function turns an expression into a function (similar in some respects to Maple’s unapply):

(3) -> function(x-f/d,'nr,'x)

   (3)  nr
                     Type: Symbol

And now, starting with 0.8, we can obtain iterations:

(4) -> nr(0.8)

Compiling function nr with type Float -> Float

   (4)  0.8088596491 2280701754
                     Type: Float
(5) -> nr(%)

   (5)  0.8087306283 5888432463
                     Type: Float

(6) -> nr(%)

   (6)  0.8087306004 7939331516
                     Type: Float

(7) -> nr(%)

   (7)  0.8087306004 7939201374
                     Type: Float

(8) -> nr(%)

   (8)  0.8087306004 7939201374
                     Type: Float

And there we are!