[Axiom-developer] [OpenMath] (new)

[Bill Page]

Changes http://wiki.axiom-developer.org/OpenMath/diff
--
http://www.openmath.org

The OpenMath Society

  OpenMath is an emerging standard for representing mathematical
objects with their semantics, allowing them to be exchanged between
computer programs, stored in databases, or published on the worldwide
web. While the original designers were mainly developers of computer
algebra systems, it is now attracting interest from other areas of
scientific computation and from many publishers of electronic
documents with a significant mathematical content. There is a strong
relationship to the MathML recommendation from the Worldwide Web
Consortium, and a large overlap between the two developer communities.
MathML deals principally with the presentation of mathematical objects,
while OpenMath is solely concerned with their semantic meaning or
content. While MathML does have some limited facilities for dealing
with content, it also allows semantic information encoded in OpenMath
to be embedded inside a MathML structure. Thus the two technologies
may be seen as highly complementary.

Mathematical objects encoded in OpenMath can be

* displayed in a browser

* exchanged between software systems

* cut and pasted for use in different contexts

* verified as being mathematically sound (or not!)

* used to make interactive documents really interactive.

OpenMath is highly relevant for persons working with mathematics on
computers, for those working with large documents (e.g. databases,
manuals) containing mathematical expressions, and for technical and
mathematical publishing.

Comments

  From an email by Tim Daly on Tue, 10 Dec 2002 20:26:57 -0500

    Subject: Axiom and OpenMath/MathML

    ... the fundamental idea is that there are libraries of semantics
that define what the symbols used in a communication mean. That
way the sender and receiver have a common point of reference.
I suppose this might be possible but it would be a fundamentally
hard problem.

    Just to get down to cases lets assume that Maple, for example
(and I confess that it is years since I've actually used Maple so
my examples might no longer hold true) and Axiom. Let me try to 
illustrate why *I* believe the problem is harder than you might
suspect.

    First, there is the fundamental mismatch of the designs of
the systems. I classify Maple as an "Engineering" system. That
is, the Maple system is designed for ease of use. It strives to
make the answers "work out ok". A subtle side-effect of this
design are cases where you subtract two matrices and get a
0 integer rather than the 0 matrix. This zero integer can be
used in further computations unrelated to matrices.

    I classify Axiom as a "theory" system. That is, Axiom is
designed for correctness. It strives to make the answers match
the theory. Thus, subtracting two matrices will give you a
0 matrix. This strong typing is anything but easy to use. 

    So the two systems started with different mindsets and
virtually every level of the design is constructed to support
that mindset. What is easy to write in 5 lines of Maple can
take a great deal of struggle in Axiom. The reverse is also
true.

    OpenMath presumes that there are two systems that support
its semantic definitions. That can be very hard for Maple if
the semantics are deeply related to the type. It can be very
hard for Axiom is the semantics are type-ambiguous.

    Second, there is the semantic mismatch between Maple and
Axiom. Axiom's mathematics assume an inheritance model, local
scoping of variables in algebra code, etc. Maple's mathematics
don't support inheritance, variables have global scope, etc.
It's like the difference between Java and Basic. You made the
point that surely Maple could be programmed to accept Axiom's
types. Yes, it could but you'd end up building an Axiom
interpreter in Maple's interpreter language. I fail to see
how OpenMath would address such wildly differing environments
like Java and Basic or like Maple and Axiom. A great deal of
the semantics in Axiom's answers is encoded in the type. If
I send an equation to Maple I need the correct type returned.
It can't be lost or I've lost fundamental semantics.

    Third, there is the syntactic mismatch. For primitive math
you might hope that Maple and Axiom use the same notation, at
least. Unfortunately this isn't true. Life gets much worse when
you try to represent higher objects like Ideals or a Groebner
basis.

Even the integrate function, which they both support heavily,
shares little, if any, syntax.

    OpenMath is a good idea and is supported by a lot of clever
people. It might succeed. I could even be classified as a 
"mild supporter". But it doesn't stir my blood to want to write
code for it. If you're interested, however, I'm willing to
discuss ways to experiment with it. It is, after all, leading
edge research (my definition of research is doing something no
one in the world knows how to do) and Axiom has always been a
great platform for doing research.

  On Thu, 13 May 2004 10:03:12 +0100 Mike Dewar wrote:

    There are two separate issues here.  The first is the problem
of reading and writing streams of OpenMath tokens.  It is this
which uses the underlying C Library code (which by the way will
probably be obsolote soon: we are hoping to finalise OpenMath 2
in the next week or two).

The second is the question of serialising Axiom objects in
OpenMath encodings.  This is done in Axiom code via the OpenMath
category, but is only implemented for a few domains.

  On Thu, May 13, 2004 at 09:47:00AM -0400, Tim Daly wrote:

    Where can I get the new library?

  On Thu, 13 May 2004 15:40:57 +0100 Mike Dewar wrote:

    There isn't one as yet.  I don't know whether a library similar
to the old INRIA one will be produced, the world has moved on and
people tend to be using OpenMath much more as a document format
than an interchange mechanism.  For those that do want to use it
as an interchange mechanism, Java libraries that use mechanisms
like SOAP, XML-RPC etc. are more useful than the old TCP/IP-based
one.  
 
    ...  Everything else that you need is already freely available
in browsers, implemented according to defined or de-facto standards.
You can do text layout in XHTML, implement fancy folding menus
with javascript, handle graphics with plug-ins to get interactivity
and render the Maths with MathML.  If you want a hard-copy on the
other hand, then its very easy to write an XSL stylesheet to
produce LaTeX from your original document, or you can probably
find existing tools to do this on the web.  This isn't fantasy
by the way, its exactly what we are doing at NAG with our
documentation and its proving very successful.

    ... based on XML and thats just Lisp with fancy brackets :-)

  On Thu, May 13, 2004 at 09:47:00AM -0400, Tim Daly wrote:

    I don't see how to carry Axiom's Types in OpenMath's data
representation.

  On Thu, 13 May 2004 15:40:57 +0100 Mike Dewar wrote:

    You use the OMATTR constructor to attribute the object with
its Axiom type.  (In OpenMath 2 you can make this stronger by
declaring it to be a semantic attribute.)  MathML has an element
called "semantics" which allows you to do a similar thing, there
is a whole document devoted to this problem at
http://www.w3.org/TR/mathml-types

    ... if I were in your position I would try and use generic
technologies inside a browser, rather than do something ad-hoc.

See also:

  AxiomUI
--
forwarded from http://wiki.axiom-developer.org/address@hidden