[BACK]Return to dagb-noro.tex CVS log [TXT][DIR] Up to [local] / OpenXM / doc / Papers

Diff for /OpenXM/doc/Papers/Attic/dagb-noro.tex between version 1.1 and 1.5

version 1.1, 2001/10/03 08:32:58 version 1.5, 2001/10/09 01:44:21
Line 1 
Line 1 
 % $OpenXM$  % $OpenXM: OpenXM/doc/Papers/dagb-noro.tex,v 1.4 2001/10/04 08:22:20 noro Exp $
 \setlength{\parskip}{10pt}  \setlength{\parskip}{10pt}
   
 \begin{slide}{}  \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}  \begin{slide}{}
 \item Old style software for polynomial computation  \fbox{OpenXM (Open message eXchange protocol for Mathematics) }
   
 \begin{itemize}  \begin{itemize}
 \item Domain specification is not necessary prior to computation  \item An environment for parallel distributed computation
 \item automatic conversion of inputs into internal canonical forms  
   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{itemize}
   \end{slide}
   
 \item User language with C-like syntax  
   
   \begin{slide}{}
   \fbox{OpenXM and OpenMath}
   
 \begin{itemize}  \begin{itemize}
 \item No type declaration of variables  \item OpenMath
 \item Builtin debugger for user programs  
   \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}  \end{itemize}
   
 \item Open source  \item OpenXM
   
 \begin{itemize}  \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{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  \item OpenXM interface
   
 \begin{itemize}  \begin{itemize}
 \item As a client : can call procedures on other OpenXM servers  \item Risa/Asir is a main client in OpenXM package.
 \item As a server : offers all its functionalities to OpenXM clients  \item An OpenXM server {\tt ox\_asir}
 \item As a library : OpenXM functionality is available via subroutine calls  \item An library with OpemXM library inteface {\tt libasir.a}
 \end{itemize}  \end{itemize}
 \end{itemize}  \end{itemize}
 \end{slide}  \end{slide}
   
 \begin{slide}{}  \begin{slide}{}
 \fbox{Major functionalities}  \fbox{Aim of developing Risa/Asir}
   
 \begin{itemize}  \begin{itemize}
 \item Fundamental polynomial arithmetics  \item Efficient implementation in specific area
   
 \begin{itemize}  Polynomial factorization, Groebner basis related computation
 \item Internal form of a polynomial : recursive representaion or distributed  
 representation  $\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{itemize}
   \end{slide}
   
   \begin{slide}{}
   \fbox{Capability for polynomial computation}
   
   \begin{itemize}
   \item Fundamental polynomial arithmetics
   
   recursive representaion and distributed representation
   
 \item Polynomial factorization  \item Polynomial factorization
   
 \begin{itemize}  \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}  \end{itemize}
   
 \item Groebner basis computation  \item Groebner basis computation
   
 \begin{itemize}  \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 Primary ideal decomposition
   
 \item Computation of $b$-function  \item Computation of $b$-function (in Weyl Algebra)
 \end{itemize}  \end{itemize}
   
 \item PARI library interface  
   
 \item Paralell distributed computation under OpenXM  
 \end{itemize}  \end{itemize}
 \end{slide}  \end{slide}
   
 \begin{slide}{}  \begin{slide}{}
 \fbox{History of development : ---1994}  \fbox{History of development : Polynomial factorization}
   
 \begin{itemize}  \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}  Univariate and multivariate factorizers over {\bf Q}
 \item Reconfigured as Risa/Asir with the parser and Boehm's conservative GC.  
   
 \item Developed univariate and multivariate factorizers over the rationals.  \item 1992-1994
 \end{itemize}  
   
 \item 1992--1994  Univariate factorization over algebraic number fields
   
 \begin{itemize}  Intensive use of successive extension, non-squarefree norms
 \item Started implementation of Groebner basis computation  
   
 User language $\Rightarrow$ rewritten in C (by Murao) $\Rightarrow$  \item 1996-1998
 trace lifting  
   
 \item Univariate factorization over algebraic number fields  Univariate factorization over large finite fields
   
 Intensive use of successive extension, non-squarefree norms  \item 2000-current
 \end{itemize}  
 \end{itemize}  
   
   Multivariate factorization over small finite fields (in progress)
   \end{itemize}
 \end{slide}  \end{slide}
   
 \begin{slide}{}  \begin{slide}{}
 \fbox{History of development : 1994-1996}  \fbox{History of development : Groebner basis}
   
 \begin{itemize}  \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 1994-1996
 \item Shimoyama-Yokoyama algorithm  
   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{itemize}
   \end{slide}
   
 \item Improvement of Buchberger algorithm  \begin{slide}{}
   \fbox{Performance --- Factorizer}
   
 \begin{itemize}  \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{itemize}  
   
 \end{slide}  \end{slide}
   
 \begin{slide}{}  \begin{slide}{}
 \fbox{History of development : 1996-1998}  \fbox{Performance --- Groebner basis related computation}
   
 \begin{itemize}  \begin{itemize}
 \item Distributed compuatation  \item 7 years ago
   
 \begin{itemize}  Trace lifting : rather fine but coefficient swells often occur
 \item A prototype of OpenXM  
 \end{itemize}  
   
 \item Improvement of Buchberger algorithm  Homogenization+trace lifting : robust and fast in the above cases
   
 \begin{itemize}  \item 4 years ago
 \item Content reduction during nomal form computation  
   
 \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  $F_4$ in FGb : much more efficient than $F_4$ in Risa/Asir
 \end{itemize}  
   
   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}  \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}
 \end{itemize}  
   
   \begin{center}
   \underline{In both cases, OpenXM interface is important}
   \end{center}
 \end{slide}  \end{slide}
   
 \begin{slide}{}  \begin{slide}{}
 \fbox{History of development : 1998-2000}  \fbox{OpenXM server interface in Risa/Asir}
   
 \begin{itemize}  \begin{itemize}
 \item OpenXM  \item TCP/IP stream
   
 \begin{itemize}  \begin{itemize}
 \item OpenXM specification was written by Noro and Takayama  \item Launcher
   
 \item Functions for distributed computation were rewritten  A client executes a launcher on a host.
 \end{itemize}  
   
 \item Risa/Asir on Windows  The launcher launches a server on the same host.
   
 \begin{itemize}  \item Server
 \item Requirement from a company for which Noro worked  
   
 Written in Visual C++  Reads from the descriptor 3
   
   Writes to the descriptor 4
   
 \end{itemize}  \end{itemize}
   
 \item Test implementation of $F_4$  \item Subroutine call
   
 \begin{itemize}  In Risa/Asir subroutine library {\tt libasir.a}:
 \item Over $GF(p)$ : pretty good  
   
 \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{itemize}  
 \end{slide}  \end{slide}
   
 \begin{slide}{}  \begin{slide}{}
 \fbox{History of development : 2000-current}  \fbox{OpenXM client interface in Risa/Asir}
 \begin{itemize}  
 \item The source code is freely available  
   
 \begin{itemize}  \begin{itemize}
 \item Noro moved from Fujitsu to Kobe university.  \item Primitive interface functions
   
 \item Fujitsu kindly permitted to make Risa/Asir open source.  Pushing and popping data, sending commands etc.
 \end{itemize}  
   
 \item OpenXM  \item Convenient functions
   
 \begin{itemize}  Launching servers,
 \item Revising the specification : OX-RFC100, 101, (102)  
   
 \item OX-RFC102 : ommunications between servers via MPI  Calling remote functions,
 \end{itemize}  
   
 \item Rings of differential operators  Resetting remote executions etc.
   
 \begin{itemize}  \item Parallel distributed computation
 \item Buchberger algorithm  
   
 \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{itemize}  
   
 \end{slide}  \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}{}  \begin{slide}{}
 \fbox{Status of each component --- Factorizer}  \fbox{Example of distributed computation --- $F_4$ vs. $Buchberger$ }
   
 \begin{itemize}  \begin{verbatim}
 \item 10 years ago  /* 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  \begin{slide}{}
 like REDUCE, Maple, Mathematica.  \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  [Boehm] {\tt http://www.hpl.hp.com/personal/Hans\_Boehm/gc}
 still fine because of some tricks on factoring polynomials  
 derived from norms.  
   
 \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  [Noro] M. Noro, J. McKay,
 \end{itemize}  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}  \end{slide}
   
 \begin{slide}{}  \begin{slide}{}
 \fbox{Status of each component --- Groebner basis related functions}  
   
 \begin{itemize}  [Oaku] T. Oaku, Algorithms for $b$-functions, restrictions and algebraic
 \item 8 years ago  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  [PARI] {\tt http://www.parigp-home.de}
 efficient.  
   
 Homogenization+trace lifting made it possible to compute  [Risa/Asir] {\tt http://www.math.kobe-u.ac.jp/Asir/asir.html}
 wider range of Groebner bases.  
   
 \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  \end{slide}
 faster than Risa/Asir, because Singular seems to have efficient  
 monomial and polynomial representation.  
   
 \end{itemize}  \begin{slide}{}
   \begin{center}
   \fbox{\large Part II : Algorithms and implementations in Risa/Asir}
   \end{center}
 \end{slide}  \end{slide}
   
 \begin{slide}{}  \begin{slide}{}
Line 340  DDF + Cantor-Zassenhaus; FFT for large finite fields
Line 527  DDF + Cantor-Zassenhaus; FFT for large finite fields
   
 Classical EZ algorithm  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}
   
 \end{itemize}  \end{itemize}
Line 365  Guess of a groebner basis by detecting zero reduction 
Line 554  Guess of a groebner basis by detecting zero reduction 
 Homogenization+guess+dehomogenization+check  Homogenization+guess+dehomogenization+check
 \end{itemize}  \end{itemize}
   
 \item Rings of differential operators  \item Weyl Algebra
   
 \begin{itemize}  \begin{itemize}
 \item Groebner basis of a left ideal  \item Groebner basis of a left ideal
   
 An efficient implementation of Leibniz rule  Key : an efficient implementation of Leibniz rule
 \end{itemize}  \end{itemize}
   
 \end{itemize}  \end{itemize}
Line 381  An efficient implementation of Leibniz rule
Line 570  An efficient implementation of Leibniz rule
 \begin{itemize}  \begin{itemize}
 \item Over small finite fields ($GF(p)$, $p < 2^{30}$)  \item Over small finite fields ($GF(p)$, $p < 2^{30}$)
 \begin{itemize}  \begin{itemize}
 \item More efficient than Buchberger algorithm  \item More efficient than our Buchberger algorithm implementation
   
 but less efficient than FGb by Faugere  but less efficient than FGb by Faugere
 \end{itemize}  \end{itemize}
Line 391  but less efficient than FGb by Faugere
Line 580  but less efficient than FGb by Faugere
 \begin{itemize}  \begin{itemize}
 \item Very naive implementation  \item Very naive implementation
   
   Modular computation + CRT + Checking the result at each degree
   
 \item Less efficient than Buchberger algorithm  \item Less efficient than Buchberger algorithm
   
 except for one example  except for one example (={\it McKay})
 \end{itemize}  \end{itemize}
   
 \end{itemize}  \end{itemize}
 \end{slide}  \end{slide}
   
 \begin{slide}{}  \begin{slide}{}
 \fbox{Change of ordering for zero-dimimensional ideals}  \fbox{Change of ordering for zero-dimensional ideals}
   
 \begin{itemize}  \begin{itemize}
 \item Any ordering to lex ordering  \item Any ordering to lex ordering
Line 448  An ideal whose radical is prime
Line 639  An ideal whose radical is prime
 \begin{slide}{}  \begin{slide}{}
 \fbox{Computation of $b$-function}  \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.  $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$  there exists $P(s) \in D[s]$, $P(s)f^{s+1}=b(s)f^s$
Line 494  evaluated by {\tt eval()}
Line 685  evaluated by {\tt eval()}
   
 The knapsack factorization is available via {\tt pari(factor,{\it poly})}  The knapsack factorization is available via {\tt pari(factor,{\it poly})}
 \end{itemize}  \end{itemize}
   
   
 \end{itemize}  \end{itemize}
 \end{slide}  \end{slide}
   
 \begin{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}}  \fbox{Executing functions on a server (I) --- {\tt SM\_executeFunction}}
   
 \begin{enumerate}  \begin{enumerate}
Line 663  $\Rightarrow$ Communication may be slow, but the clien
Line 721  $\Rightarrow$ Communication may be slow, but the clien
 enough to read the result.  enough to read the result.
 \end{slide}  \end{slide}
   
 \begin{slide}{}  %\begin{slide}{}
 \fbox{Example of distributed computation --- $F_4$ vs. $Buchberger$ }  %\fbox{History of development : ---1994}
   %
 \begin{verbatim}  %\begin{itemize}
 /* competitive Gbase computation over GF(M) */  %\item --1989
 /* Cf. A.28 in SINGULAR Manual */  %
 /* Process list is specified as an option : grvsf4(...|proc=P) */  %Several subroutines were developed for a Prolog program.
 def grvsf4(G,V,M,O)  %
 {  %\item 1989--1992
   P = getopt(proc);  %
   if ( type(P) == -1 ) return dp_f4_mod_main(G,V,M,O);  %\begin{itemize}
   P0 = P[0]; P1 = P[1]; P = [P0,P1];  %\item Reconfigured as Risa/Asir with a parser and Boehm's conservative GC [Boehm]
   map(ox_reset,P);  %
   ox_cmo_rpc(P0,"dp_f4_mod_main",G,V,M,O);  %\item Developed univariate and multivariate factorizers over the rationals.
   ox_cmo_rpc(P1,"dp_gr_mod_main",G,V,0,M,O);  %\end{itemize}
   map(ox_push_cmd,P,262); /* 262 = OX_popCMO */  %
   F = ox_select(P); R = ox_get(F[0]);  %\item 1992--1994
   if ( F[0] == P0 ) { Win = "F4"; Lose = P1;}  %
   else { Win = "Buchberger"; Lose = P0; }  %\begin{itemize}
   ox_reset(Lose); /* simply resets the loser */  %\item Started implementation of Buchberger algorithm
   return [Win,R];  %
 }  %Written in user language $\Rightarrow$ rewritten in C (by Murao)
 \end{verbatim}  %
   %$\Rightarrow$ trace lifting [Traverso]
 \end{slide}  %
   %\item Univariate factorization over algebraic number fields
 \begin{slide}{}  %
 \end{slide}  %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}{}  \begin{slide}{}
 \end{slide}  \end{slide}
   
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.5
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>