Schoonschip, probably the first CAS

[Ondřej Čertík]

Hi,

I just found full source codes of perhaps the first computer algebra
system (CAS) ever, Schoonschip from 1963 by M. Veltman [1] (and
improvements later by other people), that's 52 years ago:

http://www-personal.umich.edu/~williams/archive/schoonschip/index.html

See the source code:

http://www-personal.umich.edu/~williams/archive/schoonschip/SchipSrc-CR.tar.gz

written in assembly language... Moore info about the code:

http://www-personal.umich.edu/~williams/archive/schoonschip/README.txt
http://www-personal.umich.edu/~williams/archive/schoonschip/README-src.txt

And a detailed manual:

http://www-personal.umich.edu/~williams/archive/schoonschip/schipman.pdf

The manual is especially interesting to see how the program was used
and what features it had, and it has lots of info how to implement
tensors, gamma matrices etc. in particle physics. I think there is
lots of stuff to learn from it, I am going to read it carefully.

Veltman himself talks about the code on the page 4 at [2].

Ondrej

[1] http://en.wikipedia.org/wiki/Martinus_J._G._Veltman

[2] http://www.nobelprize.org/nobel_prizes/physics/laureates/1999/veltman-lecture.pdf

[Aaron Meurer]

That's very cool.

It's worth pointing out that John McCarthy's original 1960 LISP paper
(http://www-formal.stanford.edu/jmc/recursive.html) shows how to take
what are effectively symbolic derivatives:

Our differentiation formula, which gives the derivative of y with
respect to x, is

diff [y; x] = [atom [y] → [eq [y; x] → ONE; T → ZERO]; eq [car [Y];
PLUS] → cons [PLUS; maplist [cdr [y]; λ[[z]; diff [car [z]; x]]]];
eq[car [y]; TIMES] → cons[PLUS; maplist[cdr[y]; λ[[z]; cons [TIMES;
maplist[cdr [y]; λ[[w]; ¬ eq [z; w] → car [w]; T → diff [car [[w];
x]]]]]]]

The derivative of the expression (TIMES, X, (PLUS, X, A), Y), as
computed by this formula, is

(PLUS, (TIMES, ONE, (PLUS, X, A), Y), (TIMES, X, (PLUS, ONE, ZERO),
Y), (TIMES, X, (PLUS, X, A), ZERO))

Aaron Meurer

> --
> You received this message because you are subscribed to the Google Groups "sympy" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to sympy+un...@googlegroups.com.
> To post to this group, send email to sy...@googlegroups.com.
> Visit this group at http://groups.google.com/group/sympy.
> To view this discussion on the web visit https://groups.google.com/d/msgid/sympy/CADDwiVAqbWpmyDaUbrT1W70piTOf8Vb2E-K-Cu8WPBDS%3DO0nGw%40mail.gmail.com.
> For more options, visit https://groups.google.com/d/optout.

[Richard Fateman]

I would not think it was "the first CAS"...  but maybe the first at something..

There were quite a few systems way back then. A big conference

with lots of system descriptions in papers was held in 1966.

 The structure of the

Lisp simplifier written by Knut Korsvold (circa 1963) is still in Maxima.

The rather more sophisticated systems by William A. Martin and

Joel Moses came just a bit later (1966 or so).  Their theses include

source code.  But there were others from that time

like FORMAC  (August, 1962)

http://dl.acm.org/citation.cfm?id=807969

and there was also Reduce and CAMAL

Schoonschip had a particular niche and was successful in it.

As an inspiration for other 'CAS' implementers, I think it

fell way short of what Veltman believed to be the case.

Running initially on CDC computers, written in assembler,

and aimed at problems where sorting of large numbers of terms

was critical, it probably could do computations that no other

system could do.  On the other hand, all numbers were 

(still are?) machine floats.  And Veltman was not keen on

notions like "user-friendly" interfaces.

[Ondřej Čertík]

Hi Richard,

On Fri, Feb 6, 2015 at 6:07 PM, Richard Fateman <fat...@gmail.com> wrote:
> I would not think it was "the first CAS"... but maybe the first at
> something..
>
> There were quite a few systems way back then. A big conference
> with lots of system descriptions in papers was held in 1966.

Did you attend it? You would be 20 at that time.

>
> The structure of the
> Lisp simplifier written by Knut Korsvold (circa 1963) is still in Maxima.
> The rather more sophisticated systems by William A. Martin and
> Joel Moses came just a bit later (1966 or so). Their theses include
> source code. But there were others from that time
> like FORMAC (August, 1962)

I am aware of Joel Moses' code, called SIN, described in his thesis,
available at [3].

>
> http://dl.acm.org/citation.cfm?id=807969

But I wasn't aware of FORMAC. Thanks for the paper link, I'll read it on Monday.

> and there was also Reduce and CAMAL

Yes, I think Both Reduce and CAMAL started in 1968.

>
> Schoonschip had a particular niche and was successful in it.
> As an inspiration for other 'CAS' implementers, I think it
> fell way short of what Veltman believed to be the case.
> Running initially on CDC computers, written in assembler,
> and aimed at problems where sorting of large numbers of terms
> was critical, it probably could do computations that no other
> system could do. On the other hand, all numbers were
> (still are?) machine floats. And Veltman was not keen on
> notions like "user-friendly" interfaces.

Indeed, I think it was used to compute quite a few results in particle
physics, so I would think that it was very successful at this. I think
the de-factor successor of Schoonschip is FORM [1], started in 1984,
but it is still maintained, I just compiled it today and played with
it a bit, it works great. Everything is expanded and FORM can only do
term by term operations, so it can do various substitutions and
expansions, but no factoring, and also it has no series expansion
(unless you code it yourself), limits, integration, none of it. I
think Schoonschip was probably similar, so it is a specialized CAS for
a specific purpose, it's not a general purpose CAS. I thought the
speed of FORM was very good, but I am aware of your article [2] and
the section "An anecdote about FORM".

[1] http://en.wikipedia.org/wiki/FORM_%28symbolic_manipulation_system%29,
https://github.com/vermaseren/form

[2] Fateman, R. (2003). Comparing the speed of programs for sparse
polynomial multiplication. ACM SIGSAM Bulletin, 37(1), 4.
doi:10.1145/844076.844080

[3] http://www.softwarepreservation.org/projects/LISP/MIT/MIT-LCS-TR-047-corrected-ocr.pdf