[Axiom-developer] Parallelism in mathematical languages

[Tim Daly]

One thought about parallelism is that you've implicitly
introduced a serial idea when you do computation by
a series of assignments. This seriously inhibits your
ability to think and program in parallel. Instead of
the serial assignment model of programming you might
consider thinking in terms of conditions on the initial and
final states of a computation.

Within a mathematical based language (e.g. Axiom)
it would be more natural and reasonable to introduce
parallelism by using PROVISOS..

A proviso is a set of conditions attached to a particular
equation. For instance, you often see in mathematical
textbooks statements of the form:

   1/x provided x <> 0

A study I did shows that about 80% of all of the provisos
attached to mathematical statements in books can be written in
interval form. The above could be expressed as a statement
with two interval conditions

 1/x provided ([-\infty < x < 0] or [0 > x > \infty])

These provisos are naturally added by operators (e.g. division)

Now this statement naturally breaks into two disjoint parts.
If you assume that this statement arises in the middle of a
mathematical computation you have a natural branch point
for parallel computations, the "left branch" computing under
the proviso

 1/x provided [-\infty < x < 0]

and the "right branch" computing under the proviso

 1/x provided [0 > x > \infty]

assuming further that another division occurs, perchance by y
we might find the left branch computation continued as

 (1/x provided [-\infty < x < 0])/y provided
      ([-\infty < y < 0] or [0 > y > \infty])

which naturally branches again giving 4 disjoint paths for
the computation. Thus mathematical computation
under provisos creates natural parallel tree structures.

Combining branches on the tree involves two kinds of  computation...
computing "with" provisos and computing "of" provisos.

Computing "with" provisos creates the branching structure above.
Computing "of" provisos involves combination within the provisos
portion so that we might find combinations like:

   ((foo(x) provided [3 < x < 4]) provided [3 < x < 4])

which trivially collapses into

   (foo(x) provided [3 < x < 4])

While not interesting mathematically we have just managed to
combine two branches of the tree into a single branch, thus
creating a "join" condition using provisos. Computation "of"
provisos also introduces a natural place to generate program
proofs. The language of the proviso can be very logic based
yielding the ability to use ACL2 (Univ. of Texas work).



The whole idea is too large to fit into this margin but you can
see infer some interesting features.

* parallel computations arise naturally.
* branch cuts, poles, properties (e.g. entire, meromorphic) can be 
expressed as provisos.
* computations carry assumptions and ranges of validity
* multi-valued answers (e.g. piecewise equations) are natural
* computational ranges are easily expressed (e.g. [minint <= x <= maxint])


I'm concerned that you're creating your own box by deciding to
follow the standard model of serial programming. Under the
assumption that this language is used for mathematics the proviso
model is much more natural and powerful.

Tim Daly
address@hidden