Return to design-outline.tex CVS log

Up to [local] / OpenXM / doc / issac2000

Cosmetic changes.

% $OpenXM: OpenXM/doc/issac2000/design-outline.tex,v 1.8 2000/01/15 03:47:58 takayama Exp $

\section{Design Outline} 

As Schefstr\"om clarified in \cite{schefstrom},
integration of tools and softwares has three dimensions:
data, control, and user interface.

Data integration concerns with the exchange of data between different
softwares or same softwares.
OpenMath \cite{OpenMath} and MP (Multi Protocol) \cite{GKW} are,
for example, general purpose mathematical data protocols.
They provide standard ways to express mathematical objects.
For example,
\begin{verbatim}
 <OMOBJ>  <OMI> 123 </OMI> </OMOBJ>
\end{verbatim}
means the (OpenMath) integer $123$ in OpenMath/XML expression.

Control integration concerns with the establishment and management of
inter-software communications.
Control involves, for example, a way to ask computations to other processes
and a method to interrupt computations on servers from a client.
RPC, HTTP, MPI, PVM are regarded as a general purpose control protocols or
infrastructures.
MCP (Mathematical Communication Protocol)
by Wang \cite{iamc} is such a protocol specialized to mathematics.

Although, data and control are orthogonal to each other,
real world requires both.
NetSolve \cite{netsolve}, OpenMath$+$MCP, MP$+$MCP \cite{iamc},
and MathLink \cite{mathlink} provide both data and control integration.
Each integration method has their own features due to their
own design goals and design motivations.
OpenXM (Open message eXchange protocol for Mathematics)
is a project aiming to integrate data, control and user interfaces
with its own set of design goals.
To explain our design outline, we start with a list of
our motivations.
\begin{enumerate}
\item Noro has developed a general
purpose computer algebra system Risa/Asir \cite{asir}.
An interface for interactive distributed computations was introduced
in Risa/Asir version 950831 released in 1995.
The model of computation was RPC (remote procedure call)
and it had its own serialization.
A robust interruption method was provided by having two communication channels
like ftp.
As an application of this robust and the interactive distributed computation
system, speed-up was achieved for a huge Gr\"obner basis computation,
for example,
to determine all odd order replicable functions 
(Noro and McKay \cite{noro-mckay}).
However, the protocol was closed in Asir and we thought that we should
design an open protocol.
\item Takayama has developed
a special purpose computer algebra system Kan/sm1 \cite{kan},
which is a Gr\"obner engine for the ring of differential operators $D$. 
In order to implement algorithms in D-modules due to Oaku 
(see, e.g., \cite{sst-book}),
factorizations and primary ideal decompositions were necessary.
Kan/sm1 does not have an implementation for these and called
Risa/Asir as a UNIX external program.
This approach was not satisfactory.
Especially, we could not write a clean interface code between these
two systems.
We thought that it is necessary to provide a data and control protocol
for Risa/Asir to work as a server of factorization and primary ideal
decomposition.
\item The number of mathematical softwares is increasing rapidly in the last
decade of the 20th century.
These are usually ``expert'' systems in one area of mathematics
such as ideals, groups, numbers, polytopes, and so on.
They have their own interfaces and data formats.
Interfaces are sometimes specialized to a specific field of mathematics
or poor.
It is fine for intensive and serious users of these systems.
However, for users who want to explore a new area of mathematics with these
softwares or users who need these systems only occasionally,
a unified system will be more convenient.

\item  We believe that an open integrated system is a future of mathematical
softwares.
However, it might be just a dream without realizability.
We want to build a prototype system of such an open system by using
existing standards, technologies and several mathematical softwares.
We want to see how far we can go with this approach.
\end{enumerate}

Motivated with these, we started the OpenXM project with the following
fundamental architecture.
\begin{enumerate}
\item Communication is an exchange of messages. The messages are classified into
three types:
DATA, COMMAND, and others.
The messages are called OX (OpenXM) messages.
Mathematical data are wrapped with {\it OX messages}.
We use standards of mathematical data formats such as OpenMath and MP
and our own data format ({\it CMO --- Common Mathematical Object format})
as data expressions.
\item Servers, which provide services to other processes, are stack machines.
The stack machine is called the
{\it OX stack machine}.
Existing mathematical softwares are wrapped with this stack machine.
Minimal requirements for a target software wrapped with the OX stack machine
are as follows:
\begin{enumerate}
\item The target must have a serialized interface such as a character based
interface.
\item An output of the target must be understandable for computer programs;
it should follow a grammar that can be parsed with other softwares.
\end{enumerate}
\item Any server may have a hybrid interface;
it may accept and execute its original command sequences.
For example,
if we send the following string to ox\_asir server \\
\verb+        " fctr(x^10-y^10); "      + \\
and call the stanck machine command  \\
\verb+        SM\_executeStringByLocalParser    + \\ 
then the server executes the asir command \\
\verb+ fctr(x^10-y^10); + 
(factorize $x^10-y^10$ over ${\bf Q}$)
and push the result on the stack.
\end{enumerate}
OpenXM package  is based on above fundamental architecture.
For example, the following is a command sequence to ask $1+1$ from
the Asir client to the OX sm1 server:
\begin{verbatim}
  P = sm1_start();
  ox_push_cmo(P,1); ox_push_cmo(P,1);
  ox_execute_string(P,"add"); ox_pop_cmo(P);
\end{verbatim}
The current system, OpenXM on TCP/IP, 
uses client-server model and the TCP/IP is used for interprocess
communications.
The OpenXM on MPI \cite{MPI} is currently running on Risa/Asir
as we will see in Section \ref{section:homog}.
However, we focus only on the system based on TCP/IP in this paper.