% $OpenXM: OpenXM/doc/ascm2001p/design-outline.tex,v 1.3 2001/06/20 02:40:09 takayama Exp $

\section{Design Outline and OpenXM Request for Comments (OpenXM-RFC)} 

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

Data integration concerns with the exchange of data between different
software or same software.
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} and OMEI \cite{omei} are such protocols for 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 determined by their
own design goals.
OpenXM (Open message eXchange protocol for Mathematics)
is a project aiming to integrate data, control and user interfaces
started by Noro and Takayama.

Noro has been involved in the development of 
a computer algebra system Risa/Asir \cite{asir}.
An interface for interactive distributed computations was introduced
to Risa/Asir in 1995.
The model of computation was RPC.
A robust interruption protocol was provided 
by  two communication channels like ftp.
As an application of this protocol,
a parallel speed-up was achieved for a Gr\"obner basis computation
to determine all odd order replicable functions 
(Noro and McKay \cite{noro-mckay}).
Takayama has developed
a special purpose system Kan/sm1 \cite{kan},
which is a Gr\"obner engine for the ring of differential operators $D$
and designed as a component of a larger system. 

Noro and Takayama firstly tried to integrate these existing two
software systems.
We believe that an open integrated system is a future of mathematical
software.
However, we found that it might be just a dream without realizability
and that it is an important research subject to
build a prototype of such an integrated system. % Project X

We started the OpenXM project with the following
fundamental architecture, which is currently described in
OpenXM-RFC 100  proposed standard %% ``draft standard'' and ``standard''
\cite{ox-rfc-100}.
\begin{enumerate}
\item Communication is an exchange of messages. The messages are classified into
three types:
DATA, COMMAND, and SPECIAL.
They are called OX (OpenXM) messages.
Among the three types,
{\it OX data messages} wrap mathematical data.
We use standards of mathematical data formats such as OpenMath and MP
as well as our own data format {\it CMO}
({\it Common Mathematical Object format}),
which can be expressed in terms of XML.
\item Servers, which provide services to other processes, are stack machines.
The stack machine is called the
{\it OX stack machine}.
Existing mathematical software systems 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 software.
\end{enumerate}
\item Any server may have a hybrid interface;
it may accept and execute not only stack machine commands, 
but also its original command sequences.
For example,
if we send the following string to the {\tt ox\_asir} server 
(OpenXM server of Risa/Asir) \\
\verb+        " fctr(x^100-y^100); "      + \\
and call the stack machine command  \\
\verb+        SM_executeStringByLocalParser    + \\ 
then the server executes the asir command \\
\verb+ fctr(x^100-y^100); + 
(factorize $x^{100}-y^{100}$ over ${\bf Q}$)
and pushes the result onto the stack.
\end{enumerate}
OpenXM package  implements the OpenXM-RFC 100 \cite{ox-rfc-100}
and 101 \cite{ox-rfc-101} based on
the above fundamental architecture.
In this paper, we discuss mainly on systems implementing
OpenXM-RFC 100 and 101 on TCP/IP.
For example, the following is a command sequence to ask $1+1$ from
the Asir client to the {\tt ox\_sm1} server through TCP/IP:
\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}
Here, {\tt ox\_sm1} is an OpenXM server of Kan/sm1.

Our project of integrating mathematical software
systems is taking the ``RFC'' approach, which has been
used to develop internet protocols.
We think that ``RFC'' approach is an excellent way and
we hope that other groups, who are working on standard protocols,
take this ``RFC'' approach, too.

The OpenXM on MPI \cite{MPI} is currently running on Risa/Asir
as we will see in Section \ref{section:homog}.
We are now preparing the OpenXM-RFC 102 ``Mathematical communication
on MPI'' (draft protocol)
based on our experiments on MPI.

In the rest of the paper, we abbreviate
OpenXM-RFC 100 and 101 to OpenXM if no confusion arises.