[Axiom-developer] RE: DistributedExpression (was: How can I get every term of an expression ?)

[Page, Bill]

On Wednesday, September 21, 2005 1:30 PM C Y wrote:
> 
> I agree. User comprehension is not merely a superficial convenience
> of a CAS - it's a fundamental necessity.  UI design and formatting
> of output are two components of this, and cannot be overlooked.

Well, this is user interface and then there is output formatting
... these are not really the same thing. For example, requiring a
user to write

  x^2

and then seeing

  2
 x
            Type: Polynomial Integer

displayed on the screen is what I would call UI. Having Axiom
generate LaTeX output via

  )set output tex on

and getting

  $$
  x \sp 2
  \leqno(3)
  $$
             Type: Polynomial Integer

Aside: Wouldn't it make better sense if we got only LaTeX
formatted output when we set output tex on? Maybe the above
should be more like:

  \axiomtext{Loading C:/Program Files/axiom/mnt/windows/algebra/UNISEG.o
      for domain UniversalSegment}
  $$
  x \sp 2
  \leqno(3)
  $$
  \axiomtype{Polynomial Integer}

If Axiom did this it would be much easier to parse it's
output for applications like MathAction and TeXmacs.

-------

Having MathAction or TeXmacs display this graphically is
still UI.

On the other hand when you input

  (x+y)*(z+w)::Expression Integer

and Axiom replies

  (y + x)z + w y + w x
                       Type: Expression Integer

then the display of whatever internal representation is
used by Axiom for type 'Polynomial Integer' is controlled by
the implied coercion to the special type OutputForm. This is
really all that is different between the type Expression Integer
and Martin's new type DistributedExpression Integer. The
internal representation happens to be the same (but need not
be) but the function which provides coercion to OutputForm
has been replaced with one that causes Axiom to reply

  xz + xw + yz + yw
                       Type: DistributedExpression Integer

----------

The type OutputForm which doesn't actually show up here is
used internally when Axiom formats it's output for display.
Although this is certainly output formatting, I don't think
I want to call this a User Interface issue as such. The idea
that (y + x)z + w y + w x and  xz + xw + yz + yw can be both
be external representations of the same thing is more a matter
of mathematics than cosmetics.

> I think there is a tendency for mathematical people to think
> only in terms of the mathematics itself - a critical thing to
> remember, once in a while anyway, is that correct mathematics
> is completely useless if it cannot be used and built on, and
> the harder it is to understand it the less useful it is in
> those regards.

I would take a stronger stand and say that some mathematics
is essentially impossible unless you have the right notation.
For example perhaps one reason that the Romans did not spend
much time doing algebra was that it was too much of a pain to
learn the multiple (iiix) by (cxx). :)

> So the best possible presentation of results is of paramount
> importance, as is an incremental approach to using the full
> power (and attendant complexity) of Axiom.
> 
> That's why I like the idea of building "user friendly" 
> environments for users, which operate pretty much as expected,
> but set up those environments by making assumptions which are
> implicit in normal operation explicit via the implementation
> of the environment.

This is what Richard Fateman has called the "principle of
least surprize" applied to computer algebra systems. I think
that currently the Axiom interpreter fails rather badly on
this principle in quite a few situations. Very often is is
quite difficult to explain to a new user of Axiom why Axiom
produces the output that it does in certain cases because
the explanation necessarily involves some rather deep knowledge
of how Axiom operates. This is bad for new users and is one
of the things that makes Axiom better suited as a research
platform than for the casual weekend computer algebra user.

> This lets people function more or less normally, but as they
> have a need for more generality they can make fewer assumptions
> in their default environment, and incrementally bring online
> the new syntax and increased care needed for real correctness.
> 

I think that this is an ideal that is very hard to achieve
(maybe impossible) but is certainly a goal to work towards.
One of the problems with computer algebra systems is that
they are trying to do something that (most) people already
find rather hard to do - not just multiplying 7*120. Often
they are learning the subject (mathematics) at the same time
as learning to use the computer system. That makes it at
least doubly hard.

Regards,
Bill Page.