# Main Page

### From Omath

**omath** is an open computer algebra system. It's under development, and not really in a useful state, but there is a demonstration applet, and lots of ways you can help out!

## Contents |

## Status

**omath** version <math>10^{-17}</math> is available now. See the release notes.

Either:

- Have a look at the example sessions to see what you can do already.
- Try the applet (you'll need java 1.5 hooked up to your browser).
- Download the command line interface (including all source code and javadocs), as an executable jar file (instruction).
- Check out the project from the subversion repository (and get help on hacking omath using Eclipse).
- Have a look at our jira server, which tracks bugs, issues, and new work.
- Sign up on the announce@lists.omath.org (low volume version announcements) or dev@lists.omath.org mailing lists.

The roadmap for version <math>10^{-16}</math>, and later, is in progress, there's a todo list, and then of course there are Dror's omath hopes and dreams.

## Project goals

The **omath** project hopes to provide a free computer algebra system (free as in speech, and as in beer -- free beer is always good), based on similar principles to Mathematica's. In particular, many simple programs written in Mathematica will run on **omath**. However, it is *not* a Mathematica emulator; many things you can do in Mathematica will never work in **omath**, and we intend to (eventually!) provide something much better than Mathematica. Unlike some, we won't try to redefine 'bugs' as 'features'.

If **omath** succeeds, it will succeed because users of computer algebra systems, like you, will appreciate the value of an *open*, *extensible* computer algebra system. There are many ways in which you can contribute right away -- from contributing code to the core (the function definitions and rules which provide a usable environment for doing mathematics), testing and bug reports, editing the wiki, or even hacking the kernel.

### Licensing and all that

We haven't really discussed licensing issues much at this point. However, we're committed to making **omath** as open as possible. We will always welcome (need!) input from the mathematical and computer science communities -- commit access to the source code is yours for the asking, right now. The program will always be available under a free license, and quite possible released to the public domain.

Following the lead of KnotTheory`, which is adopting the MIT license, omath quite likely will too.

### Developers

At this point, almost all code has been written by Yossi and Scott (focusing on the parser and the kernel respectively). Dror is providing hosting, planning on writing a user interface, and has some hopes and dreams.

At some point we need to do some recruiting, and contact various people.

- Alex Gittens (rubberduckie (at-sign) gmail (dot) com) has written a Mathematica parser [1] [2], and hopefully might be interested in helping out on the parser work. (I wrote him an email recently --Scott 15:53, 28 October 2005 (EDT))
- Richard Fateman is a CS professor at Berkeley, who long ago wrote MockMMA in Lisp. (The matching code.) He also wrote an amazing, and still relevant review of Mathematica 2.0.
- Dylan and the other Yossi?
- ...

## Extending the core

The 'core' provides all the functions you'd expect in a computer algebra package. At present, it's closely modelled on the functions available in Mathematica, although very incomplete. Typical examples include Set, SetDelayed, Table, Apply, Expand, Binomial, CompoundExpression, Cases, Sort and DownValues (all implemented, more or less; follow the links for source code), along with FixedPoint, Integrate, Select and so on (not yet implemented). I'm about to write a tutorial on extending the core, in which we'll walk through the process of implementing some of these functions.

## Kernel hacking

I'm beginning to write a tutorial for would be kernel hackers. This is a great place to start if you're interested in how the kernel works, interesting in improving the current kernel, or writing alternative implementations of part of all the kernel. On the other hand, if you'd like to extend the core (the collection of functions available in an omath session) you should look at the core tutorial instead! (Modifying the core is much more straightforward!)

## Omath specifications

Unlike some other computer algebra systems, omath (one day) comes with a specification, fully describing the kernel's "evaluation loop", the built in "pattern matcher", and the behaviour of the "rule tables".

## Project structure

The **omath** project is divided into several components

- omath.org/wiki
- This wiki, which will (one day) be the home of all the user documentation for omath. At present, it mostly contains notes written by and for active developers.

- interfaces
- A collection of java code describing what a 'kernel' should look like, as well as interfaces describing almost everything else; 'expressions', 'rules', 'patterns', and so on. If you'd like to write some code for
**omath**, it wouldn't hurt (but probably isn't necessary) to at least briefly familiarise yourself with these interfaces. In order to help write the 'core' (see below), you'll only need to understand the use of these interfaces, not the particular implementations provided by the Tungsten kernel. This component of**omath**is relatively stable.

- core
- A (huge) collection of code, and tests for that code, implementing the mathematical environment expected by a user of a computer algebra system. Thus the core contains implementations of things like Mathematica's 'Plus', 'SetDelayed', 'Table', 'Cases', 'FixedPoint', and eventually (maybe, one day) things like 'ListPlot', 'SurfacePlot', 'Import', and so on. Extending the core is fairly straightforward; we're putting a lot of work into making it easy for you to help out here. You can write code in either
**omath**, java, or jython, (and perhaps others, if you explain to us how to integrate them!) and there will soon be tutorials and code generation tools to help you out.

- parser
- The 'parser', a complicated machine for turning the types of things you expect to be able to type into a computer algebra system, like
`x_h?(#>1&)`

, which has to be turned into the internal representation (like Mathematica's`FullForm`

)`PatternTest[Pattern[x, Blank[h]], Function[Greater[Slot[1], 1]]]`

- kernel
- The 'kernel', which maintains tables of definitions, runs the evaluation loop, and provides pattern matching. It's pretty cool :-) The current implementation of the kernel is called Tungsten. (get it?)

- user interface
- The only user interface available at the moment is presently kinda 1970s looking; just a 'command line' interface, even if it is wrapped up as an applet, so you can use it over the web. Have a look at the design goals.

## External Resources

- Matching in flat theories by Temur Kutsia.
- A detailed description of Mathematica's flat pattern matching. (But quite technical!) (original link)

- Mathematica as a Rewrite Language by Bruno Buchberger.

- On the implementation of a rule-based programming system and some of its applications by Mircea Marin and Temur Kutsia.
- These people obviously understand Mathematica's pattern matching enumeration system backwards.

### MathLink

### Legal questions

- Richard Fateman received a few letters from Wolfram over MockMMA.
- An interesting thread on USENET sci.math.symbolic quoting the original letter from Wolfram to Fateman over MockMMA. The thread continues with some interesting tidbits: [3] [4].
- An epic USENET thread on whether languages can be copyrighted.
- The wikipedia page on Public Domain.

### Other Computer Algebra Programs

(a Rosetta Stone for CASs.)

- SAGE (GPL)
- Yacas (GPL)
- Maxima (GPL)
- Pari (GPL)
- GAP (GPL)
- Axiom (modified BSD)
- Magma (closed)
- Reduce (closed)
- Macsyma (closed)
- Maple (closed)
- Mathematica (closed)
- MathCAD (closed)
- Derive (closed, window$ only)

#### Others

Gmp, DoCon, Magnus, MuPAD, Octave, Scilab, Sumit, Macauley2, Singular, Euler

## Server tools

We are currently running:

- Wiki at http://omath.org/wiki
- SVN repository at http://svn.omath.org
- You can use this to browse all the source code (and indeed to check it out into eclipse, or your favourite IDE). If you'd like commit access, just introduce yourself!
- Mailing lists at http://lists.omath.org
- We have three mailing lists at the moment; dev, announce and commit-log (automatic logging of SVN commits).
- Jira at http://omath.org/jira/
- Thanks to Atlassian for the open source license!
- If you mention a jira issue tag in an svn commit, the revision will automatically get linked to from the issue.
- Jira is also hooked up to Fisheye, displaying diffs on svn revisions.
- CruiseControl at http://omath.org:8080/cruisecontrol/
- (not much use for anything yet -- need to start migrating tests to 'stable')
- (not in use at all; need to change the port now that Jira is on 8080)

## Old stuff

Feel free to delete, refactor, or relocate anything below!

## See also

- the Mathematica evaluation procedure
- A baby version of Mathematica, written in Python.
- [5]
- The difficulties of translating Mathematica programs into Macsyma.
- jython integration is easy. Go yossi, go!
- MathEclipse is a similar system written in Java

## Random things to categorise somewhere

- JavaView is great; it's free, but not open. If it were open source, it would be exactly what we need. Oh well.
- Wolfram offers a 15-day saved-disabled trial version of Mathematica, at [6].

## Mathematica quirks to watch out for

### Mathematica parser bugs

a+?"f"+b parses incorrectly as

Notice the strange behaviour of

f[x:((y:A)|(z:B))]:=g[{x},{y},{z}] f[A] f[B]

The current implementation of the pattern matcher will never be able to reproduce this.

Infinity-Infinity f[Infinity]-f[Infinity]

whoa -- what's this about:

Clear[cef] cef[_]:=True Clear[ef] ef[x_]/;cef[x]:=(Print[x];cef[x]=False;ef[x]) t=Table[ef[i],{i,1,5}] t t[[1]] ef[1]

'Local' variables in Block:

g[x_]:=Block[{a},a=1+x] g[2] g[x] g[a]