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

Diff for /OpenXM/doc/Papers/Attic/dag-noro-proc.tex between version 1.1 and 1.11

version 1.1, 2001/11/19 01:02:30 version 1.11, 2002/02/25 01:02:14
Line 1 
Line 1 
 % $OpenXM$  % $OpenXM: OpenXM/doc/Papers/dag-noro-proc.tex,v 1.10 2002/01/04 06:06:09 noro Exp $
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % This is a sample input file for your contribution to a multi-  % This is a sample input file for your contribution to a multi-
 % author book to be published by Springer Verlag.  % author book to be published by Springer Verlag.
Line 60 
Line 60 
 \usepackage{epsfig}  \usepackage{epsfig}
 \def\cont{{\rm cont}}  \def\cont{{\rm cont}}
 \def\GCD{{\rm GCD}}  \def\GCD{{\rm GCD}}
   \def\Q{{\bf Q}}
 %  %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   
Line 76 
Line 77 
 % allows abbreviation of title, if the full title is too long  % allows abbreviation of title, if the full title is too long
 % to fit in the running head  % to fit in the running head
 %  %
 \author{Masayuki Noro\inst{1}}  \author{Masayuki Noro}
 %  %
 %\authorrunning{Masayuki Noro}  %\authorrunning{Masayuki Noro}
 % if there are more than two authors,  % if there are more than two authors,
Line 87 
Line 88 
   
 \maketitle              % typesets the title of the contribution  \maketitle              % typesets the title of the contribution
   
 \begin{abstract}  %\begin{abstract}
 OpenXM \cite{OPENXM} is an infrastructure for exchanging mathematical  %Risa/Asir is software for polynomial computation. It has been
 data.  It defines a client-server architecture for parallel and  %developed for testing experimental polynomial algorithms, and now it
 distributed computation.  Risa/Asir is software for polynomial  %acts also as a main component in the OpenXM package \cite{noro:OPENXM}.
 computation. It has been developed for testing new algorithms, and now  %OpenXM is an infrastructure for exchanging mathematical
 it acts as both a client and a server in the OpenXM package. In this  %data.  It defines a client-server architecture for parallel and
 article we present an overview of Risa/Asir and its performances on  %distributed computation. In this article we present an overview of
 several functions.  We also show Risa/Asir's OpenXM interfaces and  %Risa/Asir and review several techniques for improving performances of
 examples of usages of them.  %Groebner basis computation over {\bf Q}. We also show Risa/Asir's
 \end{abstract}  %OpenXM interfaces and their usages.
   %\end{abstract}
   
 \section{A computer algebra system Risa/Asir}  \section{Introduction}
   
 \subsection{What is Risa/Asir?}  %Risa/Asir $B$O(B, $B?t(B, $BB?9`<0$J$I$KBP$9$k1i;;$r<BAu$9$k(B engine,
   %$B%f!<%68@8l$r<BAu$9$k(B parser and interpreter $B$*$h$S(B,
   %$BB>$N(B application $B$H$N(B interaction $B$N$?$a$N(B OpenXM interface $B$+$i$J$k(B
   %computer algebra system $B$G$"$k(B.
   Risa/Asir is a computer algebra system which consists of an engine for
   operations on numbers and polynomials, a parser and an interpreter for
   the user language, and a communication interface called OpenXM API for
   interaction with other applications.
   %engine $B$G$O(B, $B?t(B, $BB?9`<0$J$I$N(B arithmetics $B$*$h$S(B, $BB?9`<0(B
   %GCD, $B0x?tJ,2r(B, $B%0%l%V%J4pDl7W;;$,<BAu$5$l$F$$$k(B. $B$3$l$i$OAH$_9~$_4X?t(B
   %$B$H$7$F%f!<%68@8l$+$i8F$S=P$5$l$k(B.
   The engine implements fundamental arithmetics on numbers and polynomials,
   polynomial GCD, polynomial factorizations and Groebner basis computations,
   etc. These can be called from the user language as builtin functions.
   %Risa/Asir $B$N%f!<%68@8l$O(B C $B8@8l(B like $B$JJ8K!$r$b$A(B, $BJQ?t$N7?@k8@$,(B
   %$B$J$$(B, $B%j%9%H=hM}$*$h$S<+F0(B garbage collection $B$D$-$N%$%s%?%W%j%?(B
   %$B8@8l$G$"$k(B. $B%f!<%68@8l%W%m%0%i%`$O(B parser $B$K$h$jCf4V8@8l$K(B
   %$BJQ49$5$l(B, interpreter $B$K$h$j2r<a<B9T$5$l$k(B. interpreter $B$K$O(B
   %gdb $BIw$N(B debugger $B$,AH$_9~$^$l$F$$$k(B.
   The user language has C-like syntax, without type declarations
   of variables, with list processing and with automatic garbage collection.
   The interpreter is equipped with a {\tt gdb}-like debugger.
   %$B$3$l$i$N5!G=$O(B OpenXM interface $B$rDL$7$FB>$N(B application $B$+$i$b;HMQ2D(B
   %$BG=$G$"$k(B. OpenXM \cite{noro:RFC100} $B$O?t3X%=%U%H%&%'%"$N(B client-server
   %$B7?$NAj8_8F$S=P$7$N$?$a$N(B $B%W%m%H%3%k$G$"$k(B.
   These functions can be called from other applications via OpenXM API.
   OpenXM \cite{noro:RFC100} is a protocol for client-server
   communications between mathematical software.  We are distributing
   OpenXM package \cite{noro:OPENXM}, which is a collection of various
   clients and servers comlient to the OpenXM protocol specification.
   
 Risa/Asir \cite{RISA} is software mainly for polynomial  %Risa/Asir $B$OB?9`<00x?tJ,2r(B, $B%,%m%"727W;;(B \cite{noro:ANY}, $B%0%l%V%J4pDl(B
 computation. Its major functions are polynomial factorization and  %$B7W;;(B \cite{noro:NM,noro:NY}, $B=`AG%$%G%"%kJ,2r(B \cite{noro:SY}, $B0E9f(B
 Groebner basis computation, whose core parts are implemented as  %\cite{noro:IKNY} $B$K$*$1$k<B83E*%"%k%4%j%:%`(B $B$r%F%9%H$9$k$?$a$N%W%i%C%H(B
 builtin functions.  Some higher algorithms such as primary ideal  %$B%U%)!<%`$H$7$F3+H/$5$l$F$-$?(B. $B$^$?(B, OpenXM API $B$rMQ$$$F(B parallel
 decomposition or Galois group computation are built on them by the  %distributed computation $B$N<B83$K$bMQ$$$i$l$F$$$k(B.  $B:,44$r$J$9$N$OB?9`(B
 user language.  The user language is called Asir language. Asir  %$B<00x?tJ,2r$*$h$S%0%l%V%J4pDl7W;;$G$"$k(B.  $BK\9F$G$O(B, $BFC$K(B, $B%0%l%V%J4pDl(B
 language can be regarded as C language without type declaration of  %$B7W;;$K4X$7$F(B, $B$=$N4pK\$*$h$S(B {\bf Q} $B>e$G$N7W;;$N:$Fq$r9nI~$9$k$?$a$N(B
 variables, with list processing, and with automatic garbage  %$B$5$^$6$^$J9)IW$*$h$S$=$N8z2L$K$D$$$F=R$Y$k(B.  $B$^$?(B, Risa/Asir $B$O(B OpenXM
 collection. A builtin {\tt gdb}-like user language debugger is  %package $B$K$*$1$k<gMW$J(B component $B$N0l$D$G$"$k(B. Risa/Asir $B$r(B client $B$"(B
 available. It is open source and the source code and binaries are  %$B$k$$$O(B server $B$H$7$FMQ$$$kJ,;6JBNs7W;;$K$D$$$F(B, $B<BNc$r$b$H$K2r@b$9$k(B.
 available via ftp or CVS.  Risa/Asir has been used for implementing and testing experimental
 Risa/Asir is not only an standalone computer algebra system but also a  algorithms such as polynomial factorizations, splitting field and
 main component in OpenXM package \cite{OPENXM}, which is a collection  Galois group computations \cite{noro:ANY}, Groebner basis computations
 of software comliant to OpenXM protocol specification.  OpenXM is an  \cite{noro:REPL,noro:NOYO} primary ideal decomposition \cite{noro:SY}
 infrastructure for exchanging mathematical data and Risa/Asir has  and cryptgraphy \cite{noro:IKNY}.  In these applications the important
 three kind of OpenXM intefaces : an inteface as a server, as a cllient  funtions are polynomial factorization and Groebner basis
 and as a subroutine library. We will explain them in the later  computation. We focus on Groebner basis computation and we review its
 section.  fundamentals and vaious efforts for improving efficiency especially
   over $\Q$. Risa/Asir is also a main component of OpenXM package and
   it has been used for parallel distributed computation with OpenXM API.
   We will explain how one can execute parallel distributed computation
   by using Risa/Asir as a client or a server.
   
 Our goals of developing Risa/Asir are as follows:  \section{Efficient Groebner basis computation over {\bf Q}}
   \label{tab:gbtech}
   
 \begin{enumerate}  In this section we review several practical techniques to improve
 \item Providing a test bed of new algorithms  Groebner basis computation over {\bf Q}, which are easily
   implemented but may not be well known.
   We use the following notations.
   \begin{description}
   \item $<$ : a term order in the set of monomials. It is a total order such that
   
 Risa/Asir has been a platform for testing experimental algorithms in   $\forall t, 1 \le t$ and $\forall s, t, u, s<t \Rightarrow us<ut$.
 polynomial factorization, computation related to Groebner basis,  \item $Id(F)$ : a polynomial ideal generated by a polynomial set $F$.
 cryptography and quantifier elimination. As to Groebner basis, we have  \item $HT(f)$ : the head term of a polynomial with respect to a term order.
 been mainly interested in problems over {\bf Q} and we tried applying  \item $HC(f)$ : the head coefficient of a polynomial with respect to a term order.
 various modular techniques to overcome difficulties caused by huge  \item $T(f)$ : terms with non zero coefficients in $f$.
 intermediate coefficients. We have had several results and they have  \item $Spoly(f,g)$ : the S-polynomial of $\{f,g\}$
 been implemented in Risa/Asir.  
   
 \item Gereral purpose open system  $Spoly(f,g) = T_{f,g}/HT(f)\cdot f/HC(f) -T_{f,g}/HT(g)\cdot g/HC(g)$, where
   $T_{f,g} = LCM(HT(f),HT(g))$.
   \item $\phi_p$ : the canonical projection from ${\bf Z}$ onto $GF(p)$.
   \end{description}
   
 We need a lot of functions to make Risa/Asir a general purpose  \subsection{Groebner basis computation and its improvements}
 computer algebra system.  In recent years we can obtain various high  
 performance applications or libraries as free software. We wrapped  
 such software as OpenXM servers and we started to release a collection  
 of such servers and cleints as OpenXM package in 1997. Risa/Asir is  
 now a main client in the package.  
   
 \item Environment for parallel and distributed computation  A Groebner basis of an ideal $Id(F)$ can be computed by the Buchberger
   algorithm. The key oeration in the algorithm is the following
   division by a polynomial set.
   \begin{tabbing}
   while \= $\exists g \in G$, $\exists t \in T(f)$ such that $HT(g)|t$ do\\
         \> $f \leftarrow f - t/HT(g) \cdot c/HC(g) \cdot g$, \quad
         where $c$ is the coeffcient of $t$ in $f$
   \end{tabbing}
   This division terminates for any term order.
   With this division, we can show the most primitive version of the
   Buchberger algorithm.
   \begin{tabbing}
   Input : a finite polynomial set $F$\\
   Output : a Groebner basis $G$ of $Id(F)$ with respect to a term order $<$\\
   $G \leftarrow F$; \quad $D \leftarrow \{\{f,g\}| f, g \in G, f \neq g \}$\\
   while \= $D \neq \emptyset$ do \\
         \> $\{f,g\} \leftarrow$ an element of $D$; \quad
             $D \leftarrow D \setminus \{P\}$\\
         \> $R \leftarrow$ a remainder of $Spoly(f,g)$ on division by $G$\\
         \> if $R \neq 0$ then $D \leftarrow D \cup \{\{f,R\}| f \in G\}$; \quad
            $G \leftarrow G \cup \{R\}$\\
   end do\\
   return G
   \end{tabbing}
   Though this algorithm gives a Groebner basis of $Id(F)$,
   it is not practical at all. We need lots of techniques to make
   it practical. The following are major improvements:
   \begin{itemize}
   \item Useless pair detection
   
 The origin of OpenXM is a protocol for doing parallel distributed  We don't have to process all the pairs in $D$ and several useful
 compuatations by connecting multiple Risa/Asir. OpenXM is also  criteria for detecting useless pairs were proposed (cf. \cite{noro:BW}).
 designed to provide an enviroment efficient parallel distributed  
 computation. Currently only client-server communication is possible,  
 but we are preparing a specification OpenXM-RFC 102 allowing  
 client-client communication, which will enable us to execute  
 wider range of parallel algorithms efficiently.  
 \end{enumerate}  
   
 \subsection{Groebner basis and the related computation}  \item Selection strategy
   
 Currently Risa/Asir can only deal with polynomial ring. Operations on  The selection of $\{f,g\}$ greatly affects the subsequent computation.
 modules over polynomial rings have not yet supported.  However, both  The typical strategies are the normal startegy \cite{noro:BUCH}
 commutative polynomial rings and Weyl algebra are supported and one  and the sugar strategy \cite{noro:SUGAR}.
 can compute Groebner basis in both rings over the rationals, fields of  The latter was proposed for efficient computation under a non
 rational functions and finite fields. In the early stage of our  degree-compatible order.
 development, our effort was mainly devoted to improve the efficiency  
 of computation over the rationals. Our main tool is modular  
 computation. For Buchberger algorithm we adopted the trace lifting  
 algorithm by Traverso \cite{TRAV} and elaborated it by applying our  
 theory on a correspondence between Groebner basis and its modular  
 image \cite{NOYO}. We also combine the trace lifting with  
 homogenization to stabilize selection strategies, which enables us to  
 compute several examples efficiently which is hard to compute without  
 such a combination.  Our modular method can be applied to the change  
 of ordering algorithm and rational univariate representation.  We also  
 made a test implementation of $F_4$ algorithm \cite{F4}. Later we will  
 show timing data on Groebner basis computation.  
   
 \subsection{Polynomial factorization}  \item Modular methods
   
 Here we briefly review functions on polynomial factorization.  For  Even if we apply several criteria, it is difficult to detect all pairs
 univariate factorization over {\bf Q}, the classical  whose S-polynomials are reduced to zero, and the cost to process them
 Berlekamp-Zassenhaus algorithm is implemented.  Efficient algorithms  often occupies a major part in the whole computation. The trace
 recently proposed have not yet implemented.  For Univariate factorizer  algorithms \cite{noro:TRAV} were proposed to reduce such cost. This
 over algebraic number fields, Trager's algorithm \cite{TRAGER} is  will be explained in more detail in Section \ref{sec:gbhomo}.
 implemented with some modifications.  Its major applications are  
 splitting field and Galois group computation of polynomials over the  
 rationals. For such purpose a tower of simple extensions are suitable  
 because factors represented over a simple extension often have huge  
 coefficients \cite{ANY}.  For univariate factorization over finite  
 fields, equal degree factorization + Cantor-Zassenhaus algorithm is  
 implemented. We can use various representation of finite fields:  
 $GF(p)$ with a machine integer prime $p$, $GF(p)$, $GF(p^n)$ with any  
 odd prime $p$, $GF(2^n)$ with a bit representation of polynomials over  
 $GF(2)$ and $GF(p^n)$ with small $p^n$ represented by a primitive  
 root.  For multivariate factorization over the rationals, the  
 classical EZ(Extented Zassenhaus) type algorithm is implemented.  
   
 \subsection{Other functions}  \item Change of ordering
 By applying Groebner basis computation and polynomial factorization,  
 we have implemented several higher level algorithms. A typical  
 application is primary ideal decomposition of polynomial ideals over  
 {\bf Q}, which needs both functions.  Shimoyama-Yokoyama algorithm  
 \cite{SY} for primary decompsition is written in the user language.  
 Splitting field and Galois group computation are closely related and  
 are also important applications of polynomial factorization.  Our  
 implementation of Galois group computation algorithm \cite{ANY}  
 requires splitting field computation, which is written in the  
 user language.  
   
 \section{Techniques for efficient Groebner basis computation over {\bf Q}}  For elimination, we need a Groebner basis with respect to a non
 \label{gbtech}  degree-compatible order, but it is often hard to compute it by the
   Buchberger algorithm. If the ideal is zero dimensional, we can apply a
   change of ordering algorithm \cite{noro:FGLM} for a Groebner basis
   with respect to any order and we can obtain a Groebner basis with
   respect to a desired order.
   
 In this section we review several practical techniques to improve  \end{itemize}
 Groebner basis computation over {\bf Q}, which are easily  By implementing these techniques, one can obtain Groebner bases for
 implemented but may not be well known.  wider range of inputs. Nevertheless there are still intractable
 We use the following notations.  problems with these classical tools. In the subsequent sections
 \begin{description}  we show several methods for further improvements.
 \item $\phi_p$ : the canonical projection from ${\bf Z}$ onto $GF(p)$  
 \item $HT(f)$ : the head term of a polynomail with respect to a term order  
 \item $HC(f)$ : the head coefficient of a polynomail with respect to a term order  
 \end{description}  
   
 \subsection{Combination of homogenization and trace lifting}  \subsection{Combination of homogenization and trace lifting}
   \label{sec:gbhomo}
   
 Traverso's trace lifting algorithm can be  The trace lifting algorithm can be
 formulated in an abstract form as follows \cite{FPARA}.  formulated in an abstract form as follows (c.f. \cite{noro:FPARA}).
 \begin{tabbing}  \begin{tabbing}
 Input : a finite subset $F \subset {\bf Z}[X]$\\  Input : a finite subset $F \subset {\bf Z}[X]$\\
 Output : a Groebner basis $G$ of $Id(F)$ with respect to a term order $<$\\  Output : a Groebner basis $G$ of $Id(F)$ with respect to a term order $<$\\
Line 235  such that $\phi_p(G)$ \\
Line 261  such that $\phi_p(G)$ \\
 \>If $G$ passes the check return $G$\\  \>If $G$ passes the check return $G$\\
 end do  end do
 \end{tabbing}  \end{tabbing}
 We can apply various methods for {\tt guess} part of the above  We can apply various methods for {\it guess} part of the above
 algorithm.  Originally we guess the candidate by replacing zero normal  algorithm.  In the original algorithm we guess the candidate by
 form checks over {\bf Q} with those over $GF(p)$ in the Buchberger  replacing zero normal form checks over {\bf Q} with those over $GF(p)$
 algorithm, which we call {\it tl\_guess}. In Asir one can specify  in the Buchberger algorithm, which we call {\it tl\_guess}. In Asir
 another method {\it tl\_h\_guess\_dh}, which is a combination of  one can specify another method {\it tl\_h\_guess\_dh}, which is a
 {\it tl\_guess} and homogenization.  combination of {\it tl\_guess} and homogenization.
 \begin{tabbing}  \begin{tabbing}
 $tl\_h\_guess\_dh(F,p)$\\  $tl\_h\_guess\_dh(F,p)$\\
 Input : $F\subset {\bf Z}[X]$, a prime $p$\\  Input : $F\subset {\bf Z}[X]$, a prime $p$\\
Line 254  such that $HT(h)|HT(g)$ \}
Line 280  such that $HT(h)|HT(g)$ \}
 The input is homogenized to suppress intermediate coefficient swells  The input is homogenized to suppress intermediate coefficient swells
 of intermediate basis elements.  The number of zero normal forms may  of intermediate basis elements.  The number of zero normal forms may
 increase by the homogenization, but they are detected over  increase by the homogenization, but they are detected over
 GF(p). Finally, by dehomogenizing the candidate we can expect that  $GF(p)$. Finally, by dehomogenizing the candidate we can expect that
 lots of redundant elements can be removed.  We will show later that this is  lots of redundant elements can be removed.
 surely efficient for some input polynomial sets.  
   
 \subsection{Minimal polynomial computation by modular method}  \subsection{Minimal polynomial computation by modular method}
   
 Let $I$ be a zero-dimensional ideal in $R={\bf Q}[x_1,\ldots,x_n]$.  Let $I$ be a zero-dimensional ideal in $R={\bf Q}[x_1,\ldots,x_n]$.
 Then the minimal polynomial $m(x_i)$ of a variable $x_i$ in $R/I$ can  Then the minimal polynomial $m(x_i)$ of a variable $x_i$ in $R/I$ can
 be computed by a partial FGLM \cite{FGLM}, but it often takes long  be computed by a partial FGLM \cite{noro:FGLM}, but it often takes long
 time if one searches $m(x_i)$ incrementally over {\bf Q}.  In this  time if one searches $m(x_i)$ incrementally over {\bf Q}.  In this
 case we can apply a simple modular method to compute the minimal  case we can apply a simple modular method to compute the minimal
 polynomial.  polynomial.
 \begin{tabbing}  \begin{tabbing}
 Input : a Groebner basis $G$ of $I$, a variable $x_i$\\  Input : a Groebner basis $G$ of $I$, a variable $x_i$\\
 Output : the minimal polynomial of $x$ in $R/I$\\  Output : the minimal polynomial of $x_i$ in $R/I$\\
 do \= \\  do \= \\
 \> $p \leftarrow$ a new prime such that $p \not{|} HC(g)$ for all $g \in G$\\  \> $p \leftarrow$ a new prime such that $p \not{|} HC(g)$ for all $g \in G$\\
 \> $m_p \leftarrow$ the minimal polynomial of $x_i$ in $GF(p)[x_1,\ldots,x_n]/Id(\phi_p(G))$\\  \> $m_p \leftarrow$ the minimal polynomial of $x_i$ in $GF(p)[x_1,\ldots,x_n]/Id(\phi_p(G))$\\
Line 279  In this algorithm, $m_p$ can be obtained by a partial 
Line 305  In this algorithm, $m_p$ can be obtained by a partial 
 $GF(p)$ because $\phi_p(G)$ is a Groebner basis. Once we know the  $GF(p)$ because $\phi_p(G)$ is a Groebner basis. Once we know the
 candidate of $\deg(m(x_i))$, $m(x_i)$ can be determined by solving a  candidate of $\deg(m(x_i))$, $m(x_i)$ can be determined by solving a
 system of linear equations via the method of indeterminate  system of linear equations via the method of indeterminate
 coefficient. Arguments on \cite{NOYO} ensures that $m(x_i)$ is what we  coefficient, and it can be solved efficiently by $p$-adic method.
 want if it exists. Note that the full FGLM can also be computed by the  Arguments on \cite{noro:NOYO} ensures that $m(x_i)$ is what we want if it
 same method.  exists. Note that the full FGLM can also be computed by the same
   method.
   
 \subsection{Integer contents reduction}  \subsection{Integer contents reduction}
   \label{sec:gbcont}
   
 In some cases the cost to remove integer contents during nomal form  In some cases the cost to remove integer contents during normal form
 computations is dominant. We can remove the content of an integral  computations is dominant. We can remove the content of an integral
 polynomial $f$ efficiently by the following method \cite{REPL}.  polynomial $f$ efficiently by the following method \cite{noro:REPL}.
 \begin{tabbing}  \begin{tabbing}
 Input : an integral polynomial $f$\\  Input : an integral polynomial $f$\\
 Output : a pair $(\cont(f),f/\cont(f))$\\  Output : a pair $(\cont(f),f/\cont(f))$\\
 $g_0 \leftarrow$ an estimate of $\cont(f)$ such that $\cont(f)|g_0$\\  $g_0 \leftarrow$ an estimate of $\cont(f)$ such that $\cont(f)|g_0$\\
 Write $f$ as $f = g_0q+r$ by division with remainder for each coefficient\\  Write $f$ as $f = g_0q+r$ by division with remainder by $g_0$ for each coefficient\\
 If $r = 0$ then return $(g_0,q)$\\  If $r = 0$ then return $(g_0,q)$\\
 else return $(g,g_0/g \cdot q + r/g)$, where $g = \GCD(g_0,\cont(r))$  else return $(g,g_0/g \cdot q + r/g)$, where $g = \GCD(g_0,\cont(r))$
 \end{tabbing}  \end{tabbing}
 By serataing the set of coefficients of $f$ into two subsets and by  By separating the set of coefficients of $f$ into two subsets and by
 computing GCD of sums in the elements in the subsets we can estimate  computing GCD of sums of the elements in each subset we can estimate
 $g_0$ with high accuracy. Then other components are easily computed.  $g_0$ with high accuracy. Then other components are easily computed.
   
 %\subsection{Demand loading of reducers}  %\subsection{Demand loading of reducers}
 %An execution of the Buchberer algorithm may produce vary large number  %An execution of the Buchberger algorithm may produce vary large number
 %of intermediate basis elements. In Asir, we can specify that such  %of intermediate basis elements. In Asir, we can specify that such
 %basis elements should be put on disk to enlarge free memory space.  %basis elements should be put on disk to enlarge free memory space.
 %This does not reduce the efficiency so much because all basis elements  %This does not reduce the efficiency so much because all basis elements
Line 309  $g_0$ with high accuracy. Then other components are ea
Line 337  $g_0$ with high accuracy. Then other components are ea
 %cost for reading basis elements from disk is often negligible because  %cost for reading basis elements from disk is often negligible because
 %of the cost for coefficient computations.  %of the cost for coefficient computations.
   
 \section{Risa/Asir performance}  \subsection{Performances of Groebner basis computation}
   
 We show timing data on Risa/Asir for polynomial factorization  We show timing data on Risa/Asir for Groebner basis computation.  The
 and Groebner basis computation. The measurements were made on  measurements were made on a PC with PentiumIII 1GHz and 1Gbyte of main
 a PC with PentiumIII 1GHz and 1Gbyte of main memory. Timings  memory. Timings are given in seconds. In the tables `---' means it was
 are given in seconds. In the tables `---' means it was not  not measured.  $C_n$ is the cyclic $n$ system and $K_n$ is the Katsura
 measured.  $n$ system, both are famous bench mark problems \cite{noro:BENCH}.  $McKay$
   \cite{noro:REPL} is a system whose Groebner basis is hard to compute over
   {\bf Q}.  In Risa/Asir we have a test implemention of $F_4$ algorithm
   \cite{noro:F4} and we also show its current performance.  The term order is
   graded reverse lexicographic order.
   
 \subsection{Groebner basis computation}  Table \ref{tab:gbmod} shows timing data for Groebner basis computation
   over $GF(32003)$.  $F_4$ implementation in Risa/Asir outperforms
   Buchberger algorithm implementation, but it is still several times
   slower than $F_4$ implementation in FGb \cite{noro:FGB}.
   
 Table \ref{gbmod} and Table \ref{gbq} shows timing data for Groebner  Table \ref{tab:gbq} shows timing data for Groebner basis computation over
 basis compuation over $GF(32003)$ and over {\bf Q} respectively.  $\Q$, where we compare the timing data under various configuration of
 $C_n$ is the cyclic $n$ system and $K_n$ is the Katsura $n$ system,  algorithms. {\bf TR}, {\bf Homo}, {\bf Cont} means trace lifting,
 both are famous bench mark problems.  We also measured the timing for  homogenization and contents reduction respectively.
 $McKay$ system over {\bf Q} \cite{REPL}.  the term order is graded  \ref{tab:gbq} also shows timings of minimal polynomial
 reverse lexicographic order.  In the both tables, the first three rows  computation for zero-dimensional ideals.  Table \ref{tab:gbq} shows that
 are timings for the Buchberger algorithm, and the last two rows are  it is difficult or practically impossible to compute Groebner bases of
 timings for $F_4$ algorithm. As to the Buchberger algorithm over  $C_7$, $C_8$ and $McKay$ without the methods described in Section
 $GF(32003)$, Singular\cite{SINGULAR} shows the best performance among  \ref{sec:gbhomo} and \ref{sec:gbcont}.
 the three systems. $F_4$ implementation in Risa/Asir is faster than  Though $F_4$ implementation in Risa/Asir over {\bf Q} is still
 the Buchberger algorithm implementation in Singluar, but it is still  experimental, the timing of $McKay$ is greatly reduced.
 several times slower than $F_4$ implemenataion in FGb \cite{FGB}.  In  Fig. \ref{tab:f4vsbuch} explains why $F_4$ is efficient in this case.  The
 Table \ref{gbq}, $C_7$ and $McKay$ can be computed by the Buchberger  figure shows that the Buchberger algorithm produces normal forms with
 algorithm with the methods described in Section \ref{gbtech}.  It is  huge coefficients for S-polynomials after the 250-th one, which are
 obvious that $F_4$ implementation in Risa/Asir over {\bf Q} is too  the computations in degree 16.  However, we know that the reduced
 immature. Nevertheless the timing of $McKay$ is greatly reduced.  basis elements have much smaller coefficients after removing contents.
 Why is $F_4$ efficient in this case? The answer is in the right  As $F_4$ algorithm automatically produces the reduced ones, the degree
 half of Fig. \ref{f4vsbuch}. During processing S-polynomials of degree  16 computation is quite easy in $F_4$.
 16, the Buchberger algorithm produces intermediate polynomials with  
 huge coefficients, but if we compute normal forms of these polynomials  
 by using all subsequently generated basis elements, then their  
 coefficients will be reduced after removing contents. As $F_4$  
 algorithm automatically produces the reduced basis elements, the  
 degree 16 computation is quite easy in $F_4$.  
   
   
 \begin{table}[hbtp]  \begin{table}[hbtp]
 \begin{center}  \begin{center}
 \begin{tabular}{|c||c|c|c|c|c|c|c|} \hline  \begin{tabular}{|c||c|c|c|c|c|c|c|} \hline
                 & $C_7$ & $C_8$ & $K_7$ & $K_8$ & $K_9$ & $K_{10}$ & $K_{11}$ \\ \hline                  & $C_7$ & $C_8$ & $K_7$ & $K_8$ & $K_9$ & $K_{10}$ & $K_{11}$ \\ \hline
 Asir $Buchberger$       & 31 & 1687  & 2.6  & 27 & 294  & 4309 & --- \\ \hline  Asir $Buchberger$       & 31 & 1687  & 2.6  & 27 & 294  & 4309 & --- \\ \hline
 Singular & 8.7 & 278 & 0.6 & 5.6 & 54 & 508 & 5510 \\ \hline  %Singular & 8.7 & 278 & 0.6 & 5.6 & 54 & 508 & 5510 \\ \hline
 CoCoA 4 & 241 & $>$ 5h & 3.8 & 35 & 402 &7021  & --- \\ \hline\hline  %CoCoA 4 & 241 & $>$ 5h & 3.8 & 35 & 402 &7021  & --- \\ \hline\hline
 Asir $F_4$      & 5.3 & 129 & 0.5  & 4.5 & 31  & 273 & 2641 \\ \hline  Asir $F_4$      & 5.3 & 129 & 0.5  & 4.5 & 31  & 273 & 2641 \\ \hline
 FGb(estimated)  & 0.9 & 23 & 0.1 & 0.8 & 6 & 51 & 366 \\ \hline  FGb(estimated)  & 0.9 & 23 & 0.1 & 0.8 & 6 & 51 & 366 \\ \hline
 \end{tabular}  \end{tabular}
 \end{center}  \end{center}
 \caption{Groebner basis computation over $GF(32003)$}  \caption{Groebner basis computation over $GF(32003)$}
 \label{gbmod}  \label{tab:gbmod}
 \end{table}  \end{table}
   
 \begin{table}[hbtp]  \begin{table}[hbtp]
 \begin{center}  \begin{center}
 \begin{tabular}{|c||c|c|c|c|c|} \hline  \begin{tabular}{|c||c|c|c|c|c|} \hline
                 & $C_7$ & $Homog. C_7$ & $K_7$ & $K_8$ & $McKay$ \\ \hline                  & $C_7$ & $C_8$ & $K_7$ & $K_8$ & $McKay$ \\ \hline
 Asir $Buchberger$       & 389 & 594 & 29 & 299 & 34950 \\ \hline  TR+Homo+Cont & 389 & 54000 & 29 & 299 & 34950 \\ \hline
 Singular & --- & 15247 & 7.6 & 79 & $>$ 20h \\ \hline  TR+Homo & --- & --- & --- & --- & --- \\ \hline
 CoCoA 4 & --- & 13227 & 57 & 709 & --- \\ \hline\hline  TR & --- & --- & --- & --- & --- \\ \hline \hline
 Asir $F_4$      &  989 & 456 & 90 & 991 & 4939 \\ \hline  Minipoly & --- & --- & --- & --- & N/A \\ \hline
 FGb(estimated)  & 8 &11 & 0.6 & 5 & 10 \\ \hline  %Singular & --- & 15247 & --- & 7.6 & 79 & $>$ 20h \\ \hline
   %CoCoA 4 & --- & 13227 & --- & 57 & 709 & --- \\ \hline\hline
   %Asir $F_4$     &  989 & 456 & --- & 90 & 991 & 4939 \\ \hline
   %FGb(estimated) & 8 &11 & 288 &  0.6 & 5 & 10 \\ \hline
 \end{tabular}  \end{tabular}
 \end{center}  \end{center}
 \caption{Groebner basis computation over {\bf Q}}  \caption{Groebner basis and minimal polynomial computation over {\bf Q}}
 \label{gbq}  \label{tab:gbq}
 \end{table}  \end{table}
   
 \begin{figure}[hbtp]  \begin{figure}[hbtp]
 \begin{center}  \begin{center}
 \epsfxsize=12cm  \epsfxsize=12cm
 \epsffile{blenall.ps}  %\epsffile{../compalg/ps/blenall.ps}
   \epsffile{blen.ps}
 \end{center}  \end{center}
 \caption{Maximal coefficient bit length of intermediate bases}  \caption{Maximal coefficient bit length of intermediate bases}
 \label{f4vsbuch}  \label{tab:f4vsbuch}
 \end{figure}  \end{figure}
   
 \subsection{Polynomial factorization}  %Table \ref{minipoly} shows timing data for the minimal polynomial
   %computations of all variables over {\bf Q} by the modular method.
   %\begin{table}[hbtp]
   %\begin{center}
   %\begin{tabular}{|c||c|c|c|c|c|} \hline
   %               & $C_6$ & $C_7$ & $K_6$ & $K_7$ & $K_8$ \\ \hline
   %Singular & 0.9 & 846 & 307 & 60880 & ---  \\ \hline
   %Asir & 1.5 & 182 & 12 & 164 & 3420  \\ \hline
   %\end{tabular}
   %\end{center}
   %\caption{Minimal polynomial computation}
   %\label{minipoly}
   %\end{table}
   
 Table \ref{unifac} shows timing data for univariate factorization over  %\subsection{Polynomial factorization}
 {\bf Q}.  $N_{i,j}$ is an irreducible polynomial which are hard to  %
 factor by the classical algorithm. $N_{i,j}$ is a norm of a polynomial  %Table \ref{unifac} shows timing data for univariate factorization over
 and $\deg(N_i) = i$ with $j$ modular factors. Risa/Asir is  %{\bf Q}.  $N_{i,j}$ is an irreducible polynomial which are hard to
 disadvantageous in factoring polynomials of this type because the  %factor by the classical algorithm. $N_{i,j}$ is a norm of a polynomial
 algorithm used in Risa/Asir has exponential complexity. In contrast,  %and $\deg(N_i) = i$ with $j$ modular factors. Risa/Asir is
 CoCoA 4\cite{COCOA} and NTL-5.2\cite{NTL} show nice performances  %disadvantageous in factoring polynomials of this type because the
 because they implement recently developed algorithms.  %algorithm used in Risa/Asir has exponential complexity. In contrast,
   %CoCoA 4\cite{noro:COCOA} and NTL-5.2\cite{noro:NTL} show nice performances
 \begin{table}[hbtp]  %because they implement recently developed algorithms.
 \begin{center}  %
 \begin{tabular}{|c||c|c|c|c|} \hline  %\begin{table}[hbtp]
                 & $N_{105,23}$ & $N_{120,20}$ & $N_{168,24}$ & $N_{210,54}$ \\ \hline  %\begin{center}
 Asir    & 0.86  & 59 & 840 & hard \\ \hline  %\begin{tabular}{|c||c|c|c|c|} \hline
 Asir NormFactor & 1.6   & 2.2& 6.1& hard \\ \hline  %               & $N_{105,23}$ & $N_{120,20}$ & $N_{168,24}$ & $N_{210,54}$ \\ \hline
 %Singular& hard?        & hard?& hard? & hard? \\ \hline  %Asir   & 0.86  & 59 & 840 & hard \\ \hline
 CoCoA 4 & 0.2   & 7.1   & 16 & 0.5 \\ \hline\hline  %Asir NormFactor & 1.6  & 2.2& 6.1& hard \\ \hline
 NTL-5.2 & 0.16  & 0.9   & 1.4 & 0.4 \\ \hline  %%Singular& hard?       & hard?& hard? & hard? \\ \hline
 \end{tabular}  %CoCoA 4 & 0.2  & 7.1   & 16 & 0.5 \\ \hline\hline
 \end{center}  %NTL-5.2        & 0.16  & 0.9   & 1.4 & 0.4 \\ \hline
 \caption{Univariate factorization over {\bf Q}}  %\end{tabular}
 \label{unifac}  %\end{center}
 \end{table}  %\caption{Univariate factorization over {\bf Q}}
   %\label{unifac}
 Table \ref{multifac} shows timing data for multivariate  %\end{table}
 factorization over {\bf Q}.  %
 $W_{i,j,k}$ is a product of three multivariate polynomials  %Table \ref{multifac} shows timing data for multivariate factorization
 $Wang[i]$, $Wang[j]$, $Wang[k]$ given in a data file  %over {\bf Q}.  $W_{i,j,k}$ is a product of three multivariate
 {\tt fctrdata} in Asir library directory. It is also included  %polynomials $Wang[i]$, $Wang[j]$, $Wang[k]$ given in a data file {\tt
 in Risa/Asir source tree and located in {\tt asir2000/lib}.  %fctrdata} in Asir library directory. It is also included in Risa/Asir
 For these examples Risa/Asir shows reasonable performance  %source tree and located in {\tt asir2000/lib}.  These examples have
 compared with other famous systems.  %leading coefficients of large degree which vanish at 0 which tend to
   %cause so-called the leading coefficient problem the bad zero
 \begin{table}[hbtp]  %problem. Risa/Asir's implementation carefully treats such cases and it
 \begin{center}  %shows reasonable performance compared with other famous systems.
 \begin{tabular}{|c||c|c|c|c|c|} \hline  %\begin{table}[hbtp]
         & $W_{1,2,3}$ & $W_{4,5,6}$ & $W_{7,8,9}$ & $W_{10,11,12}$ & $W_{13,14,15}$ \\ \hline  %\begin{center}
 variables & 3 & 5 & 5 & 5 & 4 \\ \hline  %\begin{tabular}{|c||c|c|c|c|c|} \hline
 monomials & 905 & 41369 & 51940 & 30988 & 3344 \\ \hline\hline  %       & $W_{1,2,3}$ & $W_{4,5,6}$ & $W_{7,8,9}$ & $W_{10,11,12}$ & $W_{13,14,15}$ \\ \hline
 Asir    & 0.2 & 4.7 & 14 & 17 & 0.4 \\ \hline  %variables & 3 & 5 & 5 & 5 & 4 \\ \hline
   %monomials & 905 & 41369 & 51940 & 30988 & 3344 \\ \hline\hline
   %Asir   & 0.2 & 4.7 & 14 & 17 & 0.4 \\ \hline
 %Singular& $>$15min     & ---   & ---& ---& ---\\ \hline  %Singular& $>$15min     & ---   & ---& ---& ---\\ \hline
 CoCoA 4 & 5.2 & $>$15min        & $>$15min & $>$15min & 117 \\ \hline\hline  %CoCoA 4 & 5.2 & $>$15min       & $>$15min & $>$15min & 117 \\ \hline\hline
 Mathematica 4& 0.2      & 16    & 23 & 36 & 1.1 \\ \hline  %Mathematica 4& 0.2     & 16    & 23 & 36 & 1.1 \\ \hline
 Maple 7& 0.5    & 18    & 967  & 48 & 1.3 \\ \hline  %Maple 7& 0.5   & 18    & 967  & 48 & 1.3 \\ \hline
 \end{tabular}  %\end{tabular}
 \end{center}  %\end{center}
 \caption{Multivariate factorization over {\bf Q}}  %\caption{Multivariate factorization over {\bf Q}}
 \label{multifac}  %\label{multifac}
 \end{table}  %\end{table}
   %As to univariate factorization over {\bf Q}, the univariate factorizer
   %implements old algorithms and its behavior is what one expects,
   %that is, it shows average performance in cases where there are little
   %extraneous factors, but shows poor performance for hard to factor
   %polynomials with many extraneous factors.
   
 \section{OpenXM and Risa/Asir OpenXM interfaces}  \section{OpenXM and Risa/Asir OpenXM interfaces}
   
 \subsection{OpenXM overview}  \subsection{OpenXM overview}
   
 OpenXM stands for Open message eXchange protocol for Mathematics.  OpenXM stands for Open message eXchange protocol for Mathematics.
 Form the viewpoint of protocol design, it is a child of OpenMath  From the viewpoint of protocol design, it can be regarded as a child
 \cite{OPENMATH}.  However our approch is somewhat different. Our main  of OpenMath \cite{noro:OPENMATH}.  However our approach is somewhat
 purpose is to provide an environment for integrating {\it existing}  different. Our main purpose is to provide an environment for
 mathematical software systems. OpenXM RFC-100 \cite{RFC100} defines a  integrating {\it existing} mathematical software systems. OpenXM
 client-server architecture.  Under this specification, a client  RFC-100 \cite{noro:RFC100} defines a client-server architecture.  Under
 invokes an OpenXM (OX) server.  The client can send OpenXM (OX)  this specification, a client invokes an OpenXM ({\it OX}) server.  The
 messages to the server.  OX messages consist of {\it data} and {\it  client can send OpenXM ({\it OX}) messages to the server.  OX messages
 command}. Data is encoded according to the common mathematical object  consist of {\it data} and {\it command}. Data is encoded according to
 (CMO) format which defines serialized representation of mathematical  the common mathematical object ({\it CMO}) format which defines
 objects.  An OX server is a stackmachine. If data is sent as an OX  serialized representation of mathematical objects.  An OX server is a
 message, the server pushes the data onto its stack. There is a common  stackmachine. If data is sent as an OX message, the server pushes the
 set of stackmachine commands and all OX server understands its subset.  data onto its stack. There is a common set of stackmachine commands
 The command set includes commands for manipulating the stack and  and each OX server understands its subset. The command set includes
 requests for execution of a procedure. In addition, a server may  stack manipulating commands and requests for execution of a procedure.
 accept its own command sequences if the server wraps some interactive  In addition, a server may accept its own command sequences if the
 software. That is the server may be a hybrid server.  server wraps some interactive software. That is the server may be a
   hybrid server.
   
 OpenXM RFC-100 also defines methods for session management. In particular  OpenXM RFC-100 also defines methods for session management. In particular
 the method to reset a server is carefully designed and it provides  the method to reset a server is carefully designed and it provides
 a robust way of using servers both for interactive and non-interactive  a robust way of using servers both for interactive and non-interactive
 purposes.  purposes.
   
 \subsection{OpenXM client interface of {\tt asir}}  \subsection{OpenXM API in Risa/Asir user language}
   
 Risa/Asir is a main client in OpenXM package.  The application {\tt  Risa/Asir is a main client in OpenXM package.  The application {\tt
 asir} can access to OpenXM servers via several builtin interface  asir} can access to OpenXM servers via several built-in interface
 functions. and various inferfaces to existing OpenXM servers are  functions. and various interfaces to existing OpenXM servers are
 prepared as user defined functions written in Asir language.  We show  prepared as user defined functions written in Asir language.
 a typical OpenXM session.  We show a typical OpenXM session.
   
 \begin{verbatim}  \begin{verbatim}
 [1] P = ox_launch();  /* invoke an OpenXM asir server */  [1] P = ox_launch();  /* invoke an OpenXM asir server */
Line 483  a typical OpenXM session.
Line 534  a typical OpenXM session.
 [[1,1],[x^4+y*x^3+y^2*x^2+y^3*x+y^4,1],  [[1,1],[x^4+y*x^3+y^2*x^2+y^3*x+y^4,1],
 [x^4-y*x^3+y^2*x^2-y^3*x+y^4,1],[x-y,1],[x+y,1]]  [x^4-y*x^3+y^2*x^2-y^3*x+y^4,1],[x-y,1],[x+y,1]]
 [5] ox_cmo_rpc(P,"fctr,",x^10000-2^10000*y^10000);  [5] ox_cmo_rpc(P,"fctr,",x^10000-2^10000*y^10000);
 /* call factorizer; an utility function */  /* call factorizer; a utility function */
 0  0
 [6] ox_reset(P); /* reset the computation in the server */  [6] ox_reset(P); /* reset the computation in the server */
 1  1
Line 495  a typical OpenXM session.
Line 546  a typical OpenXM session.
   
 An application {\tt ox\_asir} is a wrapper of {\tt asir} and provides  An application {\tt ox\_asir} is a wrapper of {\tt asir} and provides
 all the functions of {\tt asir} to OpenXM clients. It completely  all the functions of {\tt asir} to OpenXM clients. It completely
 implements the OpenXM reset protocol and also provides remote  implements the OpenXM reset protocol and also allows remote
 debugging of user programs running on the server. We show a program  debugging of user programs running on the server. As an example we
 for checking whether a polynomial set is a Groebner basis or not. A  show a program for checking whether a polynomial set is a Groebner
 client executes {\tt gbcheck()} and servers execute {\tt  basis or not. A client executes {\tt gbcheck()} and servers execute
 sp\_nf\_for\_gbcheck()} which is a simple normal form computation of a  {\tt sp\_nf\_for\_gbcheck()} which is a simple normal form computation
 S-polynomial. First of all the client collects all critical pairs  of an S-polynomial. First of all the client collects all critical pairs
 necessary for the check. Then the client requests normal form  necessary for the check. Then the client requests normal form
 computations to idling servers. If there are no idling servers the  computations to idling servers. If there are no idling servers the
 clients waits for some servers to return results by {\tt  clients waits for some servers to return results by {\tt
 ox\_select()}, which is a wrapper of UNIX {\tt select()}. If we have  ox\_select()}, which is a wrapper of UNIX {\tt select()}. If we have
 large number of critcal pairs to be processed, we can expect  large number of critical pairs to be processed, we can expect good
 good load balancing by {\tt ox\_select()}.  load balancing by {\tt ox\_select()}.
   
 \begin{verbatim}  \begin{verbatim}
 def gbcheck(B,V,O,Procs) {  def gbcheck(B,V,O,Procs) {
Line 542  def gbcheck(B,V,O,Procs) {
Line 593  def gbcheck(B,V,O,Procs) {
 }  }
 \end{verbatim}  \end{verbatim}
   
 \subsection{Asir OpenXM library {\tt libasir.a}}  \subsection{OpenXM C language API in {\tt libasir.a}}
   
 Asir OpenXM library {\tt libasir.a} includes functions simulating the  Risa/Asir subroutine library {\tt libasir.a} contains functions
 stack machine commands supported in {\tt ox\_asir}.  By linking {\tt  simulating the stack machine commands supported in {\tt ox\_asir}.  By
 libasir.a} an application can use the same functions as in {\tt  linking {\tt libasir.a} an application can use the same functions as
 ox\_asir} without accessing to {\tt ox\_asir} via TCP/IP.  in {\tt ox\_asir} without accessing to {\tt ox\_asir} via
   TCP/IP. There is also a stack, which can be manipulated by the library
   functions. In order to make full use of this interface, one has to
   prepare conversion functions between CMO and the data structures
   proper to the application itself.  A function {\tt
   asir\_ox\_pop\_string()} is provided to convert CMO to a human
   readable form, which may be sufficient for a simple use of this
   interface.
   
 \section{Concluding remarks}  \section{Concluding remarks}
 We have shown the current status of Risa/Asir and its OpenXM  %We have shown the current status of Risa/Asir and its OpenXM
 interfaces. As a result of our policy of development, it is true that  %interfaces. As a result of our policy of development, it is true that
 Risa/Asir does not have abundant functions. However it is a completely  %Risa/Asir does not have abundant functions. However it is a completely
 open system and its total performance is not bad. As OpenXM interface  %open system and its total performance is not bad. Especially on
 specification is completely documented, we can add another function to  %Groebner basis computation over {\bf Q}, many techniques for improving
 Risa/Asir by wrapping an existing software system as an OX server and  %practical performances have been implemented. As the OpenXM interface
 vice versa. User program debugger can be used both for local and  %specification is completely documented, we can easily add another
 remote debugging. By combining the debugger and the function to reset  %function to Risa/Asir by wrapping an existing software system as an OX
 servers, one will be able to enjoy parallel and distributed  %server, and other clients can call functions in Risa/Asir by
 computation.  %implementing the OpenXM client interface.  With the remote debugging
   %and the function to reset servers, one will be able to enjoy parallel
   %and distributed computation with OpenXM facilities.
 %  %
   We have shown that many techniques for
   improving practical performances are implemented in Risa/Asir's
   Groebner basis engine.  Though another important function, the
   polynomial factorizer only implements classical algorithms, its
   performance is comparable with or superior to that of Maple or
   Mathematica and is still practically useful.  By preparing OpenXM
   interface or simply linking the Asir OpenXM library, one can call
   these efficient functions from any application.  Risa/Asir is a
   completely open system.  It is open source software
   and the OpenXM interface specification is completely documented, one
   can easily write interfaces to call functions in Risa/Asir and one
   will be able to enjoy parallel and distributed computation.
   
   
 \begin{thebibliography}{7}  \begin{thebibliography}{7}
 %  %
 \addcontentsline{toc}{section}{References}  \addcontentsline{toc}{section}{References}
   
 \bibitem{ANY}  \bibitem{noro:ANY}
 Anay, H., Noro, M., Yokoyama, K. (1996)  Anay, H., Noro, M., Yokoyama, K. (1996)
 Computation of the Splitting fields and the Galois Groups of Polynomials.  Computation of the Splitting fields and the Galois Groups of Polynomials.
 Algorithms in Algebraic geometry and Applications,  Algorithms in Algebraic geometry and Applications,
 Birkh\"auser (Proceedings of MEGA'94), 29--50.  Birkh\"auser (Proceedings of MEGA'94), 29--50.
   
 \bibitem{FPARA}  \bibitem{noro:FPARA}
 Jean-Charles Faug\`ere (1994)  Jean-Charles Faug\`ere (1994)
 Parallelization of Groebner basis.  Parallelization of Groebner basis.
 Proceedings of PASCO'94, 124--132.  Proceedings of PASCO'94, 124--132.
   
 \bibitem{F4}  \bibitem{noro:F4}
 Jean-Charles Faug\`ere (1999)  Jean-Charles Faug\`ere (1999)
 A new efficient algorithm for computing Groebner bases  ($F_4$).  A new efficient algorithm for computing Groebner bases  ($F_4$).
 Journal of Pure and Applied Algebra (139) 1-3 , 61--88.  Journal of Pure and Applied Algebra (139) 1-3 , 61--88.
   
 \bibitem{FGLM}  \bibitem{noro:FGLM}
 Faug\`ere, J.-C. et al. (1993)  Faug\`ere, J.-C. et al. (1993)
 Efficient computation of zero-dimensional Groebner bases by change of ordering.  Efficient computation of zero-dimensional Groebner bases by change of ordering.
 Journal of Symbolic Computation 16, 329--344.  Journal of Symbolic Computation 16, 329--344.
   
 \bibitem{RFC100}  \bibitem{noro:RFC100}
 M. Maekawa, et al. (2001)  M. Maekawa, et al. (2001)
 The Design and Implementation of OpenXM-RFC 100 and 101.  The Design and Implementation of OpenXM-RFC 100 and 101.
 Proceedings of ASCM2001, World Scientific, 102--111.  Proceedings of ASCM2001, World Scientific, 102--111.
   
 \bibitem{RISA}  \bibitem{noro:RISA}
 Noro, M. et al. (1994-2001)  Noro, M. et al. (1994-2001)
 A computer algebra system Risa/Asir.  A computer algebra system Risa/Asir.
 {\tt http://www.openxm.org}, {\tt http://www.math.kobe-u.ac.jp/Asir/asir.html}.  {\tt http://www.openxm.org}, {\tt http://www.math.kobe-u.ac.jp/Asir/asir.html}.
   
 \bibitem{REPL}  \bibitem{noro:REPL}
 Noro, M., McKay, J. (1997)  Noro, M., McKay, J. (1997)
 Computation of replicable functions on Risa/Asir.  Computation of replicable functions on Risa/Asir.
 Proceedings of PASCO'97, ACM Press, 130--138.  Proceedings of PASCO'97, ACM Press, 130--138.
   
 \bibitem{NOYO}  \bibitem{noro:NOYO}
 Noro, M., Yokoyama, K. (1999)  Noro, M., Yokoyama, K. (1999)
 A Modular Method to Compute the Rational Univariate  A Modular Method to Compute the Rational Univariate
 Representation of Zero-Dimensional Ideals.  Representation of Zero-Dimensional Ideals.
 Journal of Symbolic Computation, 28, 1, 243--263.  Journal of Symbolic Computation, 28, 1, 243--263.
   
 \bibitem{OPENXM}  \bibitem{noro:OPENXM}
 OpenXM committers (2000-2001)  OpenXM committers (2000-2001)
 OpenXM package.  OpenXM package.
 {\tt http://www.openxm.org}.  {\tt http://www.openxm.org}.
   
 \bibitem{SY}  \bibitem{noro:RUR}
   Rouillier, R. (1996)
   R\'esolution des syst\`emes z\'ero-dimensionnels.
   Doctoral Thesis(1996), University of Rennes I, France.
   
   \bibitem{noro:SY}
 Shimoyama, T., Yokoyama, K. (1996)  Shimoyama, T., Yokoyama, K. (1996)
 Localization and Primary Decomposition of Polynomial Ideals.  Localization and Primary Decomposition of Polynomial Ideals.
 Journal of Symbolic Computation, 22, 3, 247--277.  Journal of Symbolic Computation, 22, 3, 247--277.
   
 \bibitem{TRAGER}  \bibitem{noro:TRAGER}
 Trager, B.M. (1976)  Trager, B.M. (1976)
 Algebraic Factoring and Rational Function Integration.  Algebraic Factoring and Rational Function Integration.
 Proceedings of SYMSAC 76, 219--226.  Proceedings of SYMSAC 76, 219--226.
   
 \bibitem{TRAV}  \bibitem{noro:TRAV}
 Traverso, C. (1988)  Traverso, C. (1988)
 Groebner trace algorithms.  Groebner trace algorithms.
 LNCS {\bf 358} (Proceedings of ISSAC'88), Springer-Verlag, 125--138.  LNCS {\bf 358} (Proceedings of ISSAC'88), Springer-Verlag, 125--138.
   
 \bibitem{COCOA}  \bibitem{noro:BENCH}
   {\tt http://www.math.uic.edu/\~\,jan/demo.html}.
   
   \bibitem{noro:COCOA}
 {\tt http://cocoa.dima.unige.it/}.  {\tt http://cocoa.dima.unige.it/}.
   
 \bibitem{FGB}  \bibitem{noro:FGB}
 {\tt http://www-calfor.lip6.fr/\~\,jcf/}.  {\tt http://www-calfor.lip6.fr/\~\,jcf/}.
   
 \bibitem{NTL}  %\bibitem{noro:NTL}
 {\tt http://www.shoup.net/}.  %{\tt http://www.shoup.net/}.
   
 \bibitem{OPENMATH}  \bibitem{noro:OPENMATH}
 {\tt http://www.openmath.org/}.  {\tt http://www.openmath.org/}.
   
 \bibitem{SINGULAR}  \bibitem{noro:SINGULAR}
 {\tt http://www.singular.uni-kl.de/}.  {\tt http://www.singular.uni-kl.de/}.
   
 \end{thebibliography}  \end{thebibliography}
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.11
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>