===================================================================
RCS file: /home/cvs/OpenXM/doc/Papers/Attic/dagb-noro.tex,v
retrieving revision 1.1
retrieving revision 1.5
diff -u -p -r1.1 -r1.5
--- OpenXM/doc/Papers/Attic/dagb-noro.tex	2001/10/03 08:32:58	1.1
+++ OpenXM/doc/Papers/Attic/dagb-noro.tex	2001/10/09 01:44:21	1.5
@@ -1,288 +1,475 @@
-% $OpenXM$
+% $OpenXM: OpenXM/doc/Papers/dagb-noro.tex,v 1.4 2001/10/04 08:22:20 noro Exp $
 \setlength{\parskip}{10pt}
 
 \begin{slide}{}
-\fbox{A computer algebra system Risa/Asir}
+\begin{center}
+\fbox{\large Part I : OpenXM and Risa/Asir --- overview and history}
+\end{center}
+\end{slide}
 
-\begin{itemize}
-\item Old style software for polynomial computation
+\begin{slide}{}
+\fbox{OpenXM (Open message eXchange protocol for Mathematics) }
 
 \begin{itemize}
-\item Domain specification is not necessary prior to computation
-\item automatic conversion of inputs into internal canonical forms
+\item An environment for parallel distributed computation
+
+Both for interactive, non-interactive environment
+
+\item Client-server architecture
+
+Client $\Leftarrow$ OX (OpenXM) message $\Rightarrow$ Server
+
+OX (OpenXM) message : command and data
+
+\item Data
+
+Encoding : CMO (Common Mathematical Object format)
+
+Serialized representation of mathematical object
+
+--- Main idea was borrowed from OpenMath [OpenMath]
+\item Command
+
+stack machine command --- server is a stackmachine
+
++ server's own command sequences --- hybrid server
 \end{itemize}
+\end{slide}
 
-\item User language with C-like syntax
 
+\begin{slide}{}
+\fbox{OpenXM and OpenMath}
+
 \begin{itemize}
-\item No type declaration of variables
-\item Builtin debugger for user programs
+\item OpenMath
+
+\begin{itemize}
+\item A standard for representing mathematical objects
+
+\item CD (Content Dictionary) : assigns semantics to symbols
+
+\item Phrasebook : convesion between internal and OpenMath objects.
+
+\item Encoding : format for actual data exchange
 \end{itemize}
 
-\item Open source
+\item OpenXM
 
 \begin{itemize}
-\item Whole source tree is available via CVS
+\item Specification for encoding and exchanging messages
+
+\item It also specifies behavior of servers and session management
 \end{itemize}
 
+\end{itemize}
+\end{slide}
+\begin{slide}{}
+\fbox{A computer algebra system Risa/Asir}
+
+\begin{itemize}
+\item Old style software for polynomial computation
+
+No domain specification, automatic expansion
+
+\item User language with C-like syntax
+
+C language without type declaration, with list processing
+
+\item Builtin {\tt gdb}-like debugger for user programs
+
+\item Open source
+
+Whole source tree is available via CVS
+
 \item OpenXM interface
 
 \begin{itemize}
-\item As a client : can call procedures on other OpenXM servers
-\item As a server : offers all its functionalities to OpenXM clients
-\item As a library : OpenXM functionality is available via subroutine calls
+\item Risa/Asir is a main client in OpenXM package.
+\item An OpenXM server {\tt ox\_asir}
+\item An library with OpemXM library inteface {\tt libasir.a}
 \end{itemize}
 \end{itemize}
 \end{slide}
 
 \begin{slide}{}
-\fbox{Major functionalities}
+\fbox{Aim of developing Risa/Asir}
 
 \begin{itemize}
-\item Fundamental polynomial arithmetics
+\item Efficient implementation in specific area
 
-\begin{itemize}
-\item Internal form of a polynomial : recursive representaion or distributed
-representation
+Polynomial factorization, Groebner basis related computation
+
+$\Rightarrow$ serves as an OpenXM server/library
+
+\item Front-end of a general purpose math software
+
+Risa/Asir contains PARI library [PARI] from the very beginning
+
+It also acts as a main client of OpenXM package
+
 \end{itemize}
+\end{slide}
 
+\begin{slide}{}
+\fbox{Capability for polynomial computation}
+
+\begin{itemize}
+\item Fundamental polynomial arithmetics
+
+recursive representaion and distributed representation
+
 \item Polynomial factorization
 
 \begin{itemize}
-\item Univariate factorization over the rationals, algebraic number fields and various finite fields
+\item Univariate : over {\bf Q}, algebraic number fields and finite fields
 
-\item Multivariate factorization over the rationals
+\item Multivariate : over {\bf Q}
 \end{itemize}
 
 \item Groebner basis computation
 
 \begin{itemize}
-\item Buchberger and $F_4$ algorithm
+\item Buchberger and $F_4$ [Faug\'ere] algorithm
 
-\item Change of ordering/RUR of 0-dimensional ideals
+\item Change of ordering/RUR [Rouillier] of 0-dimensional ideals
 
 \item Primary ideal decomposition
 
-\item Computation of $b$-function
+\item Computation of $b$-function (in Weyl Algebra)
 \end{itemize}
-
-\item PARI library interface 
-
-\item Paralell distributed computation under OpenXM 
 \end{itemize}
 \end{slide}
 
 \begin{slide}{}
-\fbox{History of development : ---1994}
+\fbox{History of development : Polynomial factorization}
 
 \begin{itemize}
-\item --1989
+\item 1989
 
-Several subroutines were developed for a Prolog program.
+Start of Risa/Asir with Boehm's conservative GC [Boehm]
 
-\item 1989--1992
+\item 1989-1992
 
-\begin{itemize}
-\item Reconfigured as Risa/Asir with the parser and Boehm's conservative GC.
+Univariate and multivariate factorizers over {\bf Q}
 
-\item Developed univariate and multivariate factorizers over the rationals.
-\end{itemize}
+\item 1992-1994
 
-\item 1992--1994
+Univariate factorization over algebraic number fields
 
-\begin{itemize}
-\item Started implementation of Groebner basis computation
+Intensive use of successive extension, non-squarefree norms
 
-User language $\Rightarrow$ rewritten in C (by Murao) $\Rightarrow$
-trace lifting
+\item 1996-1998
 
-\item Univariate factorization over algebraic number fields
+Univariate factorization over large finite fields
 
-Intensive use of successive extension, non-squarefree norms
-\end{itemize}
-\end{itemize}
+\item 2000-current 
 
+Multivariate factorization over small finite fields (in progress)
+\end{itemize}
 \end{slide}
 
 \begin{slide}{}
-\fbox{History of development : 1994-1996}
+\fbox{History of development : Groebner basis}
 
 \begin{itemize}
-\item Free distribution of binary versions
+\item 1992-1994
 
-\item Primary ideal decomposition
+User language $\Rightarrow$ C version; trace lifting [Traverso]
 
-\begin{itemize}
-\item Shimoyama-Yokoyama algorithm
+\item 1994-1996
+
+Trace lifting with homogenization
+
+Omitting GB check by compatible prime [NY]
+
+Modular change of ordering/RUR [NY]
+
+Primary ideal decompositon [SY]
+
+\item 1996-1998
+
+Effifcient content reduction during NF computation and its parallelization
+[Noro] (Solved {\it McKay} system for the first time)
+
+\item 1998-2000
+
+Test implementation of $F_4$
+
+\item 2000-current
+
+Buchberger algorithm in Weyl algebra [Takayama]
+
+Efficient $b$-function computation by a modular method
 \end{itemize}
+\end{slide}
 
-\item Improvement of Buchberger algorithm
+\begin{slide}{}
+\fbox{Performance --- Factorizer}
 
 \begin{itemize}
-\item Trace lifting+homogenization
+\item 4 years ago
 
-\item Omitting check by compatible prime
+Over {\bf Q} : fine compared with existing software
+like REDUCE, Mathematica, maple
 
-\item Modular change of ordering, Modular RUR
+Univarate, over algebraic number fields :
+fine because of some tricks for polynomials
+derived from norms.
 
-\item Noro met Faug\`ere at RISC-Linz and he mentioned $F_4$.
+\item Current
+
+Multivariate : not so bad
+
+Univariate : completely obsolete by M. van Hoeij's new algorithm
+[Hoeij]
 \end{itemize}
-\end{itemize}
 
 \end{slide}
 
 \begin{slide}{}
-\fbox{History of development : 1996-1998}
+\fbox{Performance --- Groebner basis related computation}
 
 \begin{itemize}
-\item Distributed compuatation
+\item 7 years ago
 
-\begin{itemize}
-\item A prototype of OpenXM
-\end{itemize}
+Trace lifting : rather fine but coefficient swells often occur
 
-\item Improvement of Buchberger algorithm
+Homogenization+trace lifting : robust and fast in the above cases
 
-\begin{itemize}
-\item Content reduction during nomal form computation
+\item 4 years ago
 
-\item Its parallelization by the above facility
+Modular RUR was comparable with Rouillier's implementation.
 
-\item Application : computation of odd order replicable functions
+DRL basis of {\it McKay}: 
 
-Risa/Asir : it took 5days to compute a DRL basis ({\it McKay})
+5 days on Risa/Asir, 53 seconds on Faugere FGb
+\item Current
 
-From Faug\`ere : computation of the DRL basis 53sec
-\end{itemize}
+$F_4$ in FGb : much more efficient than $F_4$ in Risa/Asir
 
+Buchberger in Singular [Singular] : faster than Risa/Asir
 
-\item Univariate factorization over large finite fields
+$\Leftarrow$ efficient monomial and polynomial representation
 
+\end{itemize}
+\end{slide}
+
+\begin{slide}{}
+\fbox{How do we proceed?}
+
 \begin{itemize}
-\item To implement Schoof-Elkies-Atkin algorithm 
+\item Developing new OpenXM servers
 
-Counting rational points on elliptic curves --- not free
+{ox\_NTL} for univariate factorization, 
 
-But related functions are freely available
+{ox\_FGb} for Groebner basis computation (is it possible?) etc.
+
+$\Rightarrow$ Risa/Asir can be a front-end of efficient servers
+
+\item Trying to improve our implementation
+
+Computation of $b$-function : still faster than any other system
+(Kan/sm1, Macaulay2) but not satisfactory
+
+$\Rightarrow$ Groebner basis computation in Weyl
+algebra should be improved
 \end{itemize}
-\end{itemize}
 
+\begin{center}
+\underline{In both cases, OpenXM interface is important}
+\end{center}
 \end{slide}
 
 \begin{slide}{}
-\fbox{History of development : 1998-2000}
+\fbox{OpenXM server interface in Risa/Asir}
+
 \begin{itemize}
-\item OpenXM
+\item TCP/IP stream
 
 \begin{itemize}
-\item OpenXM specification was written by Noro and Takayama
+\item Launcher
 
-\item Functions for distributed computation were rewritten
-\end{itemize}
+A client executes a launcher on a host.
 
-\item Risa/Asir on Windows
+The launcher launches a server on the same host.
 
-\begin{itemize}
-\item Requirement from a company for which Noro worked
+\item Server
 
-Written in Visual C++
+Reads from the descriptor 3
+
+Writes to the descriptor 4
+
 \end{itemize}
 
-\item Test implementation of $F_4$
+\item Subroutine call
 
-\begin{itemize}
-\item Over $GF(p)$ : pretty good
+In Risa/Asir subroutine library {\tt libasir.a}:
 
-\item Over the rationals : not so good except for {\it McKay}
+OpenXM functionalities are implemented as functon calls
+
+pushing and popping data, executing stack commands etc.
 \end{itemize}
-\end{itemize}
 \end{slide}
 
 \begin{slide}{}
-\fbox{History of development : 2000-current}
-\begin{itemize}
-\item The source code is freely available
+\fbox{OpenXM client interface in Risa/Asir}
 
 \begin{itemize}
-\item Noro moved from Fujitsu to Kobe university.
+\item Primitive interface functions
 
-\item Fujitsu kindly permitted to make Risa/Asir open source.
-\end{itemize}
+Pushing and popping data, sending commands etc.
 
-\item OpenXM
+\item Convenient functions
 
-\begin{itemize}
-\item Revising the specification : OX-RFC100, 101, (102)
+Launching servers,
 
-\item OX-RFC102 : ommunications between servers via MPI
-\end{itemize}
+Calling remote functions,
 
-\item Rings of differential operators
+Resetting remote executions etc.
 
-\begin{itemize}
-\item Buchberger algorithm
+\item Parallel distributed computation
 
-\item $b$-function computation
+Simple parallelization is practically important
 
-Minimal polynomial computation by modular method
+Competitive computation is easily realized ($\Rightarrow$ demo)
 \end{itemize}
-\end{itemize}
-
 \end{slide}
 
+
+%\begin{slide}{}
+%\fbox{CMO = Serialized representation of mathematical object}
+%
+%\begin{itemize}
+%\item primitive data
+%\begin{eqnarray*}
+%\mbox{Integer32} &:& ({\tt CMO\_INT32}, {\sl int32}\ \mbox{n}) \\
+%\mbox{Cstring}&:& ({\tt CMO\_STRING},{\sl int32}\,  \mbox{ n}, {\sl string}\, \mbox{s}) \\
+%\mbox{List} &:& ({\tt CMO\_LIST}, {\sl int32}\, len, ob[0], \ldots,ob[m-1])
+%\end{eqnarray*}
+%
+%\item numbers and polynomials
+%\begin{eqnarray*}
+%\mbox{ZZ}         &:& ({\tt CMO\_ZZ},{\sl int32}\, {\rm f}, {\sl byte}\, \mbox{a[1]}, \ldots
+%{\sl byte}\, \mbox{a[$|$f$|$]} ) \\
+%\mbox{Monomial32}&:& ({\tt CMO\_MONOMIAL32}, n, \mbox{e[1]}, \ldots, \mbox{e[n]}, \mbox{Coef}) \\
+%\mbox{Coef}&:& \mbox{ZZ} | \mbox{Integer32} \\
+%\mbox{Dpolynomial}&:& ({\tt CMO\_DISTRIBUTED\_POLYNOMIAL},\\
+%                  & & m, \mbox{DringDefinition}, \mbox{Monomial32}, \ldots)\\
+%\mbox{DringDefinition}
+%                  &:& \mbox{DMS of N variables} \\
+%                  & & ({\tt CMO\_RING\_BY\_NAME}, name) \\
+%                  & & ({\tt CMO\_DMS\_GENERIC}) \\
+%\end{eqnarray*}
+%\end{itemize}
+%\end{slide}
+%
+%\begin{slide}{}
+%\fbox{Stack based communication}
+%
+%\begin{itemize}
+%\item Data arrived a client
+%
+%Pushed to the stack
+%
+%\item Result
+%
+%Pushd to the stack
+%
+%Written to the stream when requested by a command
+%
+%\item The reason why we use the stack
+%
+%\begin{itemize}
+%\item Stack = I/O buffer for (possibly large) objects
+%
+%Multiple requests can be sent before their exection
+%
+%A server does not get stuck in sending results
+%\end{itemize}
+%\end{itemize}
+%\end{slide}
+
 \begin{slide}{}
-\fbox{Status of each component --- Factorizer}
+\fbox{Example of distributed computation --- $F_4$ vs. $Buchberger$ }
 
-\begin{itemize}
-\item 10 years ago
+\begin{verbatim}
+/* competitive Gbase computation over GF(M) */
+/* Cf. A.28 in SINGULAR Manual */
+/* Process list is specified as an option : grvsf4(...|proc=P) */
+def grvsf4(G,V,M,O)
+{
+  P = getopt(proc);
+  if ( type(P) == -1 ) return dp_f4_mod_main(G,V,M,O);
+  P0 = P[0]; P1 = P[1]; P = [P0,P1];
+  map(ox_reset,P);
+  ox_cmo_rpc(P0,"dp_f4_mod_main",G,V,M,O);
+  ox_cmo_rpc(P1,"dp_gr_mod_main",G,V,0,M,O);
+  map(ox_push_cmd,P,262); /* 262 = OX_popCMO */
+  F = ox_select(P); R = ox_get(F[0]);
+  if ( F[0] == P0 ) { Win = "F4"; Lose = P1;}
+  else { Win = "Buchberger"; Lose = P0; }
+  ox_reset(Lose); /* simply resets the loser */
+  return [Win,R];
+}
+\end{verbatim}
+\end{slide}
 
-its performace was fine compared with existing software
-like REDUCE, Maple, Mathematica.
+\begin{slide}{}
+\fbox{References}
 
-\item 4 years ago
+[Bernardin] L. Bernardin, On square-free factorization of 
+multivariate polynomials over a finite field, Theoretical
+Computer Science 187 (1997), 105-116.
 
-Univarate factorization over algebraic number fields was
-still fine because of some tricks on factoring polynomials
-derived from norms.
+[Boehm] {\tt http://www.hpl.hp.com/personal/Hans\_Boehm/gc}
 
-\item Current
+[Faug\`ere] J.C. Faug\`ere,
+A new efficient algorithm for computing Groebner bases  ($F_4$),
+Journal of Pure and Applied Algebra (139) 1-3 (1999), 61-88.
 
-Multivariate : not so bad
+[Hoeij] M. van Heoij, Factoring polynomials and the knapsack problem,
+to appear in Journal of Number Theory (2000).
 
-Univariate : completely obsolete by M. van Hoeij's new algorithm
-\end{itemize}
+[Noro] M. Noro, J. McKay,
+Computation of replicable functions on Risa/Asir.
+Proc. of PASCO'97, ACM Press, 130-138 (1997).
 
+[NY] M. Noro, K. Yokoyama, 
+A Modular Method to Compute the Rational Univariate
+Representation of Zero-Dimensional Ideals.
+J. Symb. Comp. {\bf 28}/1 (1999), 243-263.
 \end{slide}
 
 \begin{slide}{}
-\fbox{Status of each component --- Groebner basis related functions}
 
-\begin{itemize}
-\item 8 years ago
+[Oaku] T. Oaku, Algorithms for $b$-functions, restrictions and algebraic
+local cohomology groups of $D$-modules.
+Advancees in Applied Mathematics, 19 (1997), 61-105.
 
-The performace was poor with only the sugar strategy.
+[OpenMath] {\tt http://www.openmath.org}
 
-\item 7 years ago
+[OpenXM] {\tt http://www.openxm.org}
 
-Rather fine with trace lifting but Faug\`ere's (old)Gb was more
-efficient.  
+[PARI] {\tt http://www.parigp-home.de}
 
-Homogenization+trace lifting made it possible to compute
-wider range of Groebner bases.
+[Risa/Asir] {\tt http://www.math.kobe-u.ac.jp/Asir/asir.html}
 
-\item 4 years ago
+[Rouillier] F. Rouillier,
+R\'esolution des syst\`emes z\'ero-dimensionnels. 
+Doctoral Thesis(1996), University of Rennes I, France.
 
-Modular RUR was comparable with Rouillier's implementation.
+[SY] T. Shimoyama, K. Yokoyama, Localization and Primary Decomposition of Polynomial Ideals.  J. Symb. Comp. {\bf 22} (1996), 247-277.
 
-\item Current
+[Singular] {\tt http://www.singular.uni-kl.de}
 
-FGb seems much more efficient than our $F_4$ implementation.
+[Traverso] C. Traverso, \gr trace algorithms. Proc. ISSAC '88 (LNCS 358), 125-138.
 
-Singular's Groebner basis computation is also several times
-faster than Risa/Asir, because Singular seems to have efficient
-monomial and polynomial representation.
+\end{slide}
 
-\end{itemize}
+\begin{slide}{}
+\begin{center}
+\fbox{\large Part II : Algorithms and implementations in Risa/Asir}
+\end{center}
 \end{slide}
 
 \begin{slide}{}
@@ -340,9 +527,11 @@ DDF + Cantor-Zassenhaus; FFT for large finite fields
 
 Classical EZ algorithm
 
-\item Over finite fieds
+\item Over small finite fieds
 
-Modified Bernardin square free, bivariate Hensel
+Modified Bernardin's square free algorithm [Bernardin],
+
+possibly Hensel lifting over extension fields
 \end{itemize}
 
 \end{itemize}
@@ -365,12 +554,12 @@ Guess of a groebner basis by detecting zero reduction 
 Homogenization+guess+dehomogenization+check
 \end{itemize}
 
-\item Rings of differential operators
+\item Weyl Algebra
 
 \begin{itemize}
 \item Groebner basis of a left ideal
 
-An efficient implementation of Leibniz rule
+Key : an efficient implementation of Leibniz rule
 \end{itemize}
 
 \end{itemize}
@@ -381,7 +570,7 @@ An efficient implementation of Leibniz rule
 \begin{itemize}
 \item Over small finite fields ($GF(p)$, $p < 2^{30}$)
 \begin{itemize}
-\item More efficient than Buchberger algorithm
+\item More efficient than our Buchberger algorithm implementation
 
 but less efficient than FGb by Faugere
 \end{itemize}
@@ -391,16 +580,18 @@ but less efficient than FGb by Faugere
 \begin{itemize}
 \item Very naive implementation
 
+Modular computation + CRT + Checking the result at each degree
+
 \item Less efficient than Buchberger algorithm
 
-except for one example
+except for one example (={\it McKay})
 \end{itemize}
 
 \end{itemize}
 \end{slide}
 
 \begin{slide}{}
-\fbox{Change of ordering for zero-dimimensional ideals}
+\fbox{Change of ordering for zero-dimensional ideals}
 
 \begin{itemize}
 \item Any ordering to lex ordering
@@ -448,7 +639,7 @@ An ideal whose radical is prime
 \begin{slide}{}
 \fbox{Computation of $b$-function}
 
-$D$ : the ring of differential operators
+$D=K\langle x,\partial \rangle$ : Weyl algebra
 
 $b(s)$ : a polynomial of the smallest degree s.t.
 there exists $P(s) \in D[s]$, $P(s)f^{s+1}=b(s)f^s$
@@ -494,143 +685,10 @@ evaluated by {\tt eval()}
 
 The knapsack factorization is available via {\tt pari(factor,{\it poly})}
 \end{itemize}
-
-
 \end{itemize}
 \end{slide}
 
 \begin{slide}{}
-\fbox{OpenXM}
-
-\begin{itemize}
-\item An environment for parallel distributed computation
-
-Both for interactive, non-interactive environment
-
-\item Message passing
-
-OX (OpenXM) message : command and data
-
-\item Hybrid command execution
-
-\begin{itemize}
-\item Stack machine command
-
-push, pop, function execution, $\ldots$
-
-\item accepts its own command sequences
-
-{\tt execute\_string} --- easy to use
-\end{itemize}
-
-\item Data is represented as CMO
-
-CMO --- Common Mathematical Object format
-\end{itemize}
-\end{slide}
-
-\begin{slide}{}
-\fbox{OpenXM server interface in Risa/Asir}
-
-\begin{itemize}
-\item TCP/IP stream
-
-\begin{itemize}
-\item Launcher
-
-A client executes a launcher on a host.
-
-The launcher launches a server on the same host.
-
-\item Server
-
-A server reads from the descriptor 3, write to the descriptor 4.
-
-\end{itemize}
-
-\item Subroutine call
-
-Risa/Asir subroutine library provides interfaces corresponding to
-pushing and popping data and executing stack commands.
-\end{itemize}
-\end{slide}
-
-\begin{slide}{}
-\fbox{OpenXM client interface in Risa/Asir}
-
-\begin{itemize}
-\item Primitive interface functions
-
-Pushing and popping data, sending commands etc.
-
-\item Convenient functions
-
-Launching servers, calling remote functions,
- interrupting remote executions etc.
-
-\item Parallel distributed computation is easy
-
-Simple parallelization is practically important
-
-Competitive computation is easily realized 
-\end{itemize}
-\end{slide}
-
-
-\begin{slide}{}
-\fbox{CMO = Serialized representation of mathematical object}
-
-\begin{itemize}
-\item primitive data
-\begin{eqnarray*}
-\mbox{Integer32} &:& ({\tt CMO\_INT32}, {\sl int32}\ \mbox{n}) \\
-\mbox{Cstring}&:& ({\tt CMO\_STRING},{\sl int32}\,  \mbox{ n}, {\sl string}\, \mbox{s}) \\
-\mbox{List} &:& ({\tt CMO\_LIST}, {\sl int32}\, len, ob[0], \ldots,ob[m-1])
-\end{eqnarray*}
-
-\item numbers and polynomials
-\begin{eqnarray*}
-\mbox{ZZ}         &:& ({\tt CMO\_ZZ},{\sl int32}\, {\rm f}, {\sl byte}\, \mbox{a[1]}, \ldots
-{\sl byte}\, \mbox{a[$|$f$|$]} ) \\
-\mbox{Monomial32}&:& ({\tt CMO\_MONOMIAL32}, n, \mbox{e[1]}, \ldots, \mbox{e[n]}, \mbox{Coef}) \\
-\mbox{Coef}&:& \mbox{ZZ} | \mbox{Integer32} \\
-\mbox{Dpolynomial}&:& ({\tt CMO\_DISTRIBUTED\_POLYNOMIAL},\\
-                  & & m, \mbox{DringDefinition}, \mbox{Monomial32}, \ldots)\\
-\mbox{DringDefinition}
-                 &:& \mbox{DMS of N variables} \\
-		 & & ({\tt CMO\_RING\_BY\_NAME}, name) \\
-                 & & ({\tt CMO\_DMS\_GENERIC}) \\
-\end{eqnarray*}
-\end{itemize}
-\end{slide}
-
-\begin{slide}{}
-\fbox{Stack based communication}
-
-\begin{itemize}
-\item Data arrived a client
-
-Pushed to the stack
-
-\item Result
-
-Pushd to the stack
-
-Written to the stream when requested by a command
-
-\item The reason why we use the stack
-
-\begin{itemize}
-\item Stack = I/O buffer for (possibly large) objects
-
-Multiple requests can be sent before their exection
-
-A server does not get stuck in sending results
-\end{itemize}
-\end{itemize}
-\end{slide}
-
-\begin{slide}{}
 \fbox{Executing functions on a server (I) --- {\tt SM\_executeFunction}}
 
 \begin{enumerate}
@@ -663,35 +721,168 @@ $\Rightarrow$ Communication may be slow, but the clien
 enough to read the result.
 \end{slide}
 
-\begin{slide}{}
-\fbox{Example of distributed computation --- $F_4$ vs. $Buchberger$ }
-
-\begin{verbatim}
-/* competitive Gbase computation over GF(M) */
-/* Cf. A.28 in SINGULAR Manual */
-/* Process list is specified as an option : grvsf4(...|proc=P) */
-def grvsf4(G,V,M,O)
-{
-  P = getopt(proc);
-  if ( type(P) == -1 ) return dp_f4_mod_main(G,V,M,O);
-  P0 = P[0]; P1 = P[1]; P = [P0,P1];
-  map(ox_reset,P);
-  ox_cmo_rpc(P0,"dp_f4_mod_main",G,V,M,O);
-  ox_cmo_rpc(P1,"dp_gr_mod_main",G,V,0,M,O);
-  map(ox_push_cmd,P,262); /* 262 = OX_popCMO */
-  F = ox_select(P); R = ox_get(F[0]);
-  if ( F[0] == P0 ) { Win = "F4"; Lose = P1;}
-  else { Win = "Buchberger"; Lose = P0; }
-  ox_reset(Lose); /* simply resets the loser */
-  return [Win,R];
-}
-\end{verbatim}
-
-\end{slide}
-
-\begin{slide}{}
-\end{slide}
-
+%\begin{slide}{}
+%\fbox{History of development : ---1994}
+%
+%\begin{itemize}
+%\item --1989
+%
+%Several subroutines were developed for a Prolog program.
+%
+%\item 1989--1992
+%
+%\begin{itemize}
+%\item Reconfigured as Risa/Asir with a parser and Boehm's conservative GC [Boehm]
+%
+%\item Developed univariate and multivariate factorizers over the rationals.
+%\end{itemize}
+%
+%\item 1992--1994
+%
+%\begin{itemize}
+%\item Started implementation of Buchberger algorithm
+%
+%Written in user language $\Rightarrow$ rewritten in C (by Murao)
+%
+%$\Rightarrow$ trace lifting [Traverso]
+%
+%\item Univariate factorization over algebraic number fields
+%
+%Intensive use of successive extension, non-squarefree norms
+%\end{itemize}
+%\end{itemize}
+%
+%\end{slide}
+%
+%\begin{slide}{}
+%\fbox{History of development : 1994-1996}
+%
+%\begin{itemize}
+%\item Free distribution of binary versions from Fujitsu
+%
+%\item Primary ideal decomposition
+%
+%\begin{itemize}
+%\item Shimoyama-Yokoyama algorithm [SY]
+%\end{itemize}
+%
+%\item Improvement of Buchberger algorithm
+%
+%\begin{itemize}
+%\item Trace lifting+homogenization
+%
+%\item Omitting check by compatible prime
+%
+%\item Modular change of ordering, Modular RUR
+%
+%These are joint works with Yokoyama [NY]
+%\end{itemize}
+%\end{itemize}
+%
+%\end{slide}
+%
+%\begin{slide}{}
+%\fbox{History of development : 1996-1998}
+%
+%\begin{itemize}
+%\item Distributed compuatation
+%
+%\begin{itemize}
+%\item A prototype of OpenXM
+%\end{itemize}
+%
+%\item Improvement of Buchberger algorithm
+%
+%\begin{itemize}
+%\item Content reduction during nomal form computation
+%
+%\item Its parallelization by the above facility
+%
+%\item Computation of odd order replicable functions [Noro]
+%
+%Risa/Asir : it took 5days to compute a DRL basis ({\it McKay})
+%
+%Faug\`ere FGb : computation of the DRL basis 53sec
+%\end{itemize}
+%
+%
+%\item Univariate factorization over large finite fields
+%
+%\begin{itemize}
+%\item To implement Schoof-Elkies-Atkin algorithm 
+%
+%Counting rational points on elliptic curves
+%
+%--- not free But related functions are freely available
+%\end{itemize}
+%\end{itemize}
+%
+%\end{slide}
+%
+%\begin{slide}{}
+%\fbox{History of development : 1998-2000}
+%\begin{itemize}
+%\item OpenXM
+%
+%\begin{itemize}
+%\item OpenXM specification was written by Noro and Takayama
+%
+%Borrowed idea on encoding, phrase book from OpenMath [OpenMath]
+%
+%\item Functions for distributed computation were rewritten
+%\end{itemize}
+%
+%\item Risa/Asir on Windows
+%
+%\begin{itemize}
+%\item Requirement from a company for which Noro worked
+%
+%Written in Visual C++
+%\end{itemize}
+%
+%\item Test implementation of $F_4$
+%
+%\begin{itemize}
+%\item Implemented according to [Faug\`ere]
+%
+%\item Over $GF(p)$ : pretty good
+%
+%\item Over the rationals : not so good except for {\it McKay}
+%\end{itemize}
+%\end{itemize}
+%\end{slide}
+%
+%\begin{slide}{}
+%\fbox{History of development : 2000-current}
+%\begin{itemize}
+%\item The source code is freely available
+%
+%\begin{itemize}
+%\item Noro moved from Fujitsu to Kobe university
+%
+%Started Kobe branch [Risa/Asir]
+%\end{itemize}
+%
+%\item OpenXM [OpenXM]
+%
+%\begin{itemize}
+%\item Revising the specification : OX-RFC100, 101, (102)
+%
+%\item OX-RFC102 : communications between servers via MPI
+%\end{itemize}
+%
+%\item Weyl algebra
+%
+%\begin{itemize}
+%\item Buchberger algorithm [Takayama]
+%
+%\item $b$-function computation [Oaku]
+%
+%Minimal polynomial computation by modular method
+%\end{itemize}
+%\end{itemize}
+%
+%\end{slide}
 \begin{slide}{}
 \end{slide}