[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Axiom-developer] [OpenMath] [OpenMath] (new)

From: M. Edward (Ed) Borasky
Subject: [Axiom-developer] [OpenMath] [OpenMath] (new)
Date: Wed, 05 Oct 2005 01:28:07 -0500

That URL ( doesn't work. :(

As to the difference between a CAS designed for mathematicians 
(theoretical, presumably) and one for engineers (or statisticians or 
applied mathematicians or "numericians" or whatever) I suspect it's not 
as large gap for the workers as you think. For example, I've seen 
FORTRAN numerical codes that did a little symbolic differentiation and 
some Taylor series calculations on their way to solving hairy ODEs.

I've done "number crunching" in Derive and it's not as inefficient as 
you might think. And I suspect I could do a computer performance 
modeling project / queuing network solver in Axiom, Maxima, Lisp, Ruby, 
Derive, Perl, Maple, Mathematica, R or Visual Basic with approximately 
the same level of efficiency of execution. Only direct compiled to 
hardware languages -- Forth, C or FORTRAN -- would be faster. If I 
needed to do a lot of text processing to get my data, that would narrow 
the field considerably -- down to R, Perl and Ruby, in fact.

Bill Page wrote:

>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.
>  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
>    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
>    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
>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
>    ...  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
>  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
>    ... 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
>Axiom-developer mailing list

M. Edward (Ed) Borasky

forwarded from

reply via email to

[Prev in Thread] Current Thread [Next in Thread]