[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.9 and 1.12

version 1.9, 2001/12/28 06:06:15 version 1.12, 2002/02/25 07:56:16
Line 1 
Line 1 
 % $OpenXM: OpenXM/doc/Papers/dag-noro-proc.tex,v 1.8 2001/11/30 02:08:46 noro Exp $  % $OpenXM: OpenXM/doc/Papers/dag-noro-proc.tex,v 1.11 2002/02/25 01:02:14 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 87 
Line 88 
   
 \maketitle              % typesets the title of the contribution  \maketitle              % typesets the title of the contribution
   
 \begin{abstract}  %\begin{abstract}
 Risa/Asir is software for polynomial computation. It has been  %Risa/Asir is software for polynomial computation. It has been
 developed for testing experimental polynomial algorithms, and now it  %developed for testing experimental polynomial algorithms, and now it
 acts also as a main component in the OpenXM package \cite{OPENXM}.  %acts also as a main component in the OpenXM package \cite{noro:OPENXM}.
 OpenXM is an infrastructure for exchanging mathematical  %OpenXM is an infrastructure for exchanging mathematical
 data.  It defines a client-server architecture for parallel and  %data.  It defines a client-server architecture for parallel and
 distributed computation. In this article we present an overview of  %distributed computation. In this article we present an overview of
 Risa/Asir and review several techniques for improving performances of  %Risa/Asir and review several techniques for improving performances of
 Groebner basis computation over {\bf Q}. We also show Risa/Asir's  %Groebner basis computation over {\bf Q}. We also show Risa/Asir's
 OpenXM interfaces and their usages.  %OpenXM interfaces and their usages.
 \end{abstract}  %\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 OpenXM API, a communication interface 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.
   %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.
   All these functions can be called from other applications via OpenXM API.
   OpenXM \cite{noro:RFC100} is a protocol for client-server
   communications for mathematical software systems.  We are distributing
   OpenXM package \cite{noro:OPENXM}, which is a collection of various
   clients and servers compliant 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
 built-in 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 called Asir language. Asir language can be regarded as C  %$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 without type declaration of variables, with list processing,  %$B7W;;$K4X$7$F(B, $B$=$N4pK\$*$h$S(B {\bf Q} $B>e$G$N7W;;$N:$Fq$r9nI~$9$k$?$a$N(B
 and with automatic garbage collection. A built-in {\tt gdb}-like user  %$B$5$^$6$^$J9)IW$*$h$S$=$N8z2L$K$D$$$F=R$Y$k(B.  $B$^$?(B, Risa/Asir $B$O(B OpenXM
 language debugger is available. Risa/Asir is open source and the  %package $B$K$*$1$k<gMW$J(B component $B$N0l$D$G$"$k(B. Risa/Asir $B$r(B client $B$"(B
 source code and binaries are available via {\tt ftp} or {\tt CVS}.  %$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.
 Risa/Asir is not only a standalone computer algebra system but also a  Risa/Asir has been used for implementing and testing experimental
 main component in OpenXM package \cite{OPENXM}, which is a collection  algorithms such as polynomial factorizations, splitting field and
 of various software compliant to OpenXM protocol specification.  Galois group computations \cite{noro:ANY}, Groebner basis computations
 OpenXM is an infrastructure for exchanging mathematical data and  \cite{noro:REPL,noro:NOYO}, primary ideal decomposition \cite{noro:SY}
 Risa/Asir has three kinds of OpenXM interfaces : as a client, as a  and cryptgraphy \cite{noro:IKNY}.  In these applications two major
 server, and as a subroutine library. Our goals of developing Risa/Asir  functions of Risa/Asir, polynomial factorization and Groebner basis
 are as follows:  computation play important roles. We focus on Groebner basis
   computation and we review its 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.
   
 \begin{enumerate}  \section{Efficient Groebner basis computation over {\bf Q}}
 \item Providing a platform for testing new algorithms  \label{tab:gbtech}
   
 Risa/Asir has been a platform for testing experimental algorithms in  
 polynomial factorization, Groebner basis computation,  
 cryptography and quantifier elimination. As to Groebner basis, we have  
 been mainly interested in problems over {\bf Q} and we tried applying  
 various modular techniques to overcome difficulties caused by huge  
 intermediate coefficients. We have had several results and they have  
 been implemented in Risa/Asir with other known methods.  
   
 \item General purpose open system  
   
 We need a lot of functions to make Risa/Asir a general purpose  
 computer algebra system.  In recent years we can make use of 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 clients as the OpenXM package in 1997. Risa/Asir  
 is now a main client in the package.  
   
 \item Environment for parallel and distributed computation  
   
 The ancestor of OpenXM is a protocol designed for doing parallel  
 distributed computations by connecting multiple Risa/Asir's over  
 TCP/IP. OpenXM is also designed to provide an environment for  
 efficient parallel distributed computation. Currently only  
 client-server communication is available, but we are preparing a  
 specification OpenXM-RFC 102 allowing client-client communication,  
 which will enable us to execute wider range of parallel algorithms  
 requiring collective operations efficiently.  
 \end{enumerate}  
   
 \subsection{Groebner basis and the related computation}  
   
 Currently Risa/Asir can only deal with polynomial ring. Operations on  
 modules over polynomial rings have not yet supported.  However, both  
 commutative polynomial rings and Weyl algebra are supported and one  
 can compute Groebner basis in both rings over {\bf Q}, fields of  
 rational functions and finite fields. In the early stage of our  
 development, our effort was mainly devoted to improve the efficiency  
 of computation over {\bf Q}. 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 are hard to compute without  
 such a combination.  Our modular method can be applied to the change  
 of ordering algorithm\cite{FGLM} and rational univariate  
 representation \cite{RUR}.  We also made a test implementation of  
 $F_4$ algorithm \cite{F4}. In the later section we will show timing  
 data on Groebner basis computation.  
   
 \subsection{Polynomial factorization}  
   
 Here we briefly review functions on polynomial factorization.  For  
 univariate factorization over {\bf Q}, the classical  
 Berlekamp-Zassenhaus algorithm is implemented.  Efficient algorithms  
 recently proposed have not yet implemented.  For univariate  
 factorization over algebraic number fields, Trager's algorithm  
 \cite{TRAGER} is implemented with some modifications.  Its major  
 applications are splitting field and Galois group computation of  
 polynomials over {\bf Q} \cite{ANY}. For such purpose a tower of  
 simple extensions are suitable because factors represented over a  
 simple extension often have huge coefficients.  For univariate  
 factorization over finite fields, equal degree factorization and  
 Cantor-Zassenhaus algorithm are implemented. We can use various  
 representation of finite fields: $GF(p)$ with a machine integer prime  
 $p$, $GF(p)$ and $GF(p^n)$ with any odd prime $p$, $GF(2^n)$ with a  
 bit-array representation of polynomials over $GF(2)$ and $GF(p^n)$  
 with small $p^n$ represented by a primitive root.  For multivariate  
 factorization over {\bf Q}, the classical EZ(Extended  
 Zassenhaus) type algorithm is implemented.  
   
 \subsection{Other functions}  
 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 decomposition is written in the user language.  
 Splitting field and Galois group computation \cite{ANY} are closely  
 related and are also important applications of polynomial  
 factorization.  
   
 \section{Techniques for efficient Groebner basis computation over {\bf Q}}  
 \label{gbtech}  
   
 In this section we review several practical techniques to improve  In this section we review several practical techniques to improve
 Groebner basis computation over {\bf Q}, which are easily  Groebner basis computation over {\bf Q}, which are easily
 implemented but may not be well known.  implemented but may not be well known.
Line 253  while \= $D \neq \emptyset$ do \\
Line 205  while \= $D \neq \emptyset$ do \\
 end do\\  end do\\
 return G  return G
 \end{tabbing}  \end{tabbing}
 Though this algorithm gives a Groebner basis of $Id(F)$,  From the practical point of view, the above algorithm is too naive to
 it is not practical at all. We need lots of techniques to make  compute real problems and lots of improvements have been proposed.
 it practical. The following are major improvements:  The following are major ones:
 \begin{itemize}  \begin{itemize}
 \item Useless pair detection  \item Useless pair detection
   
 We don't have to process all the pairs in $D$ and several useful  We don't have to process all the pairs in $D$ and several useful
 criteria for detecting useless pairs were proposed.  criteria for detecting useless pairs were proposed (cf. \cite{noro:BW}).
   
 \item Selection strategy  \item Selection strategy
   
 The selection of $\{f,g\}$ greatly affects the subsequent computation.  The selection of $\{f,g\}$ greatly affects the subsequent computation.
 The typical strategies are the normal startegy and the sugar strategy.  The typical strategies are the normal startegy
   and the sugar strategy \cite{noro:SUGAR}.
 The latter was proposed for efficient computation under a non  The latter was proposed for efficient computation under a non
 degree-compatible order.  degree-compatible order.
   
Line 273  degree-compatible order.
Line 226  degree-compatible order.
   
 Even if we apply several criteria, it is difficult to detect all pairs  Even if we apply several criteria, it is difficult to detect all pairs
 whose S-polynomials are reduced to zero, and the cost to process them  whose S-polynomials are reduced to zero, and the cost to process them
 often occupies a major part in the whole computation. The trace algorithms  often occupies a major part in the whole computation. The trace
 were proposed to reduce such cost. This will be explained in more detail  algorithms \cite{noro:TRAV} were proposed to reduce such cost. This
 in Section \ref{gbhomo}.  will be explained in more detail in Section \ref{sec:gbhomo}.
   
 \item Change of ordering  \item Change of ordering
   
 For elimination, we need a Groebner basis with respect to a non  For elimination, we need a Groebner basis with respect to a non
 degree-compatible order, but it is often hard to compute it by  degree-compatible order, but it is often hard to compute it by a
 the Buchberger algorithm. If the ideal is zero dimensional, we  direct application of the Buchberger algorithm. If the ideal is zero
 can apply a change of ordering algorithm for a Groebner basis  dimensional, we can apply a change of ordering algorithm called FGLM
 with respect to any order and we can obtain a Groebner basis  \cite{noro:FGLM}. First of all we compute a Groebner basis with
 with respect to a desired order.  respect to some order. Then we can obtain a Groebner basis with respect
   to a desired order by a linear algebraic method.
   
 \end{itemize}  \end{itemize}
 By implementing these techniques, one can obtain Groebner bases for  By implementing these techniques, one can obtain Groebner bases for
Line 293  problems with these classical tools. In the subsequent
Line 247  problems with these classical tools. In the subsequent
 we show several methods for further improvements.  we show several methods for further improvements.
   
 \subsection{Combination of homogenization and trace lifting}  \subsection{Combination of homogenization and trace lifting}
 \label{gbhomo}  \label{sec:gbhomo}
   
 Traverso's trace lifting algorithm can be  The trace lifting algorithm can be
 formulated in an abstract form as follows (c.f. \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 326  $G \leftarrow G \setminus \{g \in G| \exists h \in G \
Line 280  $G \leftarrow G \setminus \{g \in G| \exists h \in G \
 such that $HT(h)|HT(g)$ \}  such that $HT(h)|HT(g)$ \}
 \end{tabbing}  \end{tabbing}
 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 homogenization may increase the
 increase by the homogenization, but they are detected over  number of normal forms reduced to zero, but they can be
 $GF(p)$. Finally, by dehomogenizing the candidate we can expect that  detected over by the computations over $GF(p)$. Finally, by
 lots of redundant elements can be removed.  dehomogenizing the candidate we can expect that lots of redundant
   elements are removed and the subsequent check are made easy.
   
 \subsection{Minimal polynomial computation by modular method}  \subsection{Minimal polynomial computation by a 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 applying FGLM partially, 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.
Line 354  $GF(p)$ because $\phi_p(G)$ is a Groebner basis. Once 
Line 309  $GF(p)$ because $\phi_p(G)$ is a Groebner basis. Once 
 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, and it can be solved efficiently by $p$-adic method.  coefficient, and it can be solved efficiently by $p$-adic method.
 Arguments on \cite{NOYO} ensures that $m(x_i)$ is what we want if it  Arguments on \cite{noro:NOYO} ensures that $m(x_i)$ is what we want if it
 exists. Note that the full FGLM can also be computed by the same  exists. Note that the full FGLM can also be computed by the same
 method.  method.
   
 \subsection{Integer contents reduction}  \subsection{Integer contents reduction}
 \label{gbcont}  \label{sec:gbcont}
   
 In some cases the cost to remove integer contents during normal 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))$\\
Line 385  $g_0$ with high accuracy. Then other components are ea
Line 340  $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 Groebner basis computation  All the improvements in this sections have been implemented in
 and polynomial factorization. The measurements were made on  Risa/Asir. Besides we have a test implemention of $F_4$ algorithm
 a PC with PentiumIII 1GHz and 1Gbyte of main memory. Timings  \cite{noro:F4}, which is a new algorithm for computing Groebner basis
 are given in seconds. In the tables `---' means it was not  by various methods.  We show timing data on Risa/Asir for Groebner
 measured.  basis computation.  The measurements were made on a PC with PentiumIII
   1GHz and 1Gbyte of main memory. Timings are given in seconds. In the
   tables `exhasut' means memory exhastion.  $C_n$ is the cyclic $n$
   system and $K_n$ is the Katsura $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}.  The term order
   is graded reverse lexicographic order.  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{tab:gbq} shows
   timing data for Groebner basis computation over $\Q$, where we compare
   the timing data under various configuration of algorithms. {\bf TR},
   {\bf Homo}, {\bf Cont} means trace lifting, homogenization and
   contents reduction respectively.  Table \ref{tab:gbq} also shows
   timings of minimal polynomial computation for
   $C_7$, $K_7$ and $K_8$, which are zero-dimensional ideals.
   Table \ref{tab:gbq} shows that it is difficult or practically
   impossible to compute Groebner bases of $C_7$, $C_8$ and $McKay$
   without the methods described in Section \ref{sec:gbhomo} and
   \ref{sec:gbcont}.
   
 \subsection{Groebner basis computation}  Here we mension a result of $F_4$ over $\Q$.  Though $F_4$
   implementation in Risa/Asir over {\bf Q} is still experimental and its
   performance is poor in general, it can compute $McKay$ in 4939 seconds.
   Fig. \ref{tab:f4vsbuch} explains why $F_4$ is efficient in this case.
   The figure shows that the Buchberger algorithm produces normal forms
   with huge coefficients for S-polynomials after the 250-th one, which
   make subsequent computation hard.  Whereas $F_4$ algorithm
   automatically produces the reduced basis elements, and the reduced
   basis elements have much smaller coefficients after removing contents.
   Therefore the corresponding computation is quite easy in $F_4$.
   
 Table \ref{gbmod} and Table \ref{gbq} show timing data for Groebner  
 basis computation over $GF(32003)$ and over {\bf Q} respectively.  
 $C_n$ is the cyclic $n$ system and $K_n$ is the Katsura $n$ system,  
 both are famous bench mark problems \cite{BENCH}.  We also measured  
 the timing for $McKay$ system over {\bf Q} \cite{REPL}.  the term  
 order is graded reverse lexicographic order.  In the both tables, the  
 first three rows are timings for the Buchberger algorithm, and the  
 last two rows are timings for $F_4$ algorithm. As to the Buchberger  
 algorithm over $GF(32003)$, Singular\cite{SINGULAR} shows the best  
 performance among the three systems. $F_4$ implementation in Risa/Asir  
 is faster than the Buchberger algorithm implementation in Singular,  
 but it is still several times slower than $F_4$ implementation in FGb  
 \cite{FGB}.  In Table \ref{gbq}, Risa/Asir computed $C_7$ and $McKay$  
 by the Buchberger algorithm with the methods described in Section  
 \ref{gbhomo} and \ref{gbcont}.  It is obvious that $F_4$  
 implementation in Risa/Asir over {\bf Q} is too immature. Nevertheless  
 the timing of $McKay$ is greatly reduced.  Fig. \ref{f4vsbuch}  
 explains why $F_4$ is efficient in this case.  The figure shows that  
 the Buchberger algorithm produces normal forms with huge coefficients  
 for S-polynomials after the 250-th one, which are the computations in  
 degree 16.  However, we know that the reduced basis elements have much  
 smaller coefficients after removing contents.  As $F_4$ algorithm  
 automatically produces the reduced ones, 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 & $>$ 3h \\ \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|c|} \hline  \begin{tabular}{|c||c|c|c|c|c|} \hline
                 & $C_7$ & $Homog. C_7$ & $C_8$ & $K_7$ & $K_8$ & $McKay$ \\ \hline                  & $C_7$ & $C_8$ & $K_7$ & $K_8$ & $McKay$ \\ \hline
 Asir $Buchberger$       & 389 & 594 & 54000 & 29 & 299 & 34950 \\ \hline  {\bf TR}+{\bf Homo}+{\bf Cont} & 389 & 54000 & 35 & 351 & 34950 \\ \hline
 Singular & --- & 15247 & --- & 7.6 & 79 & $>$ 20h \\ \hline  {\bf TR}+{\bf Homo} & 1346 & exhaust & 35 & 352 & exhaust \\ \hline
 CoCoA 4 & --- & 13227 & --- & 57 & 709 & --- \\ \hline\hline  {\bf TR} & $> 3h $ & $>$ 1day & 36 & 372 & $>$ 1day \\ \hline
 Asir $F_4$      &  989 & 456 & --- & 90 & 991 & 4939 \\ \hline  %Asir $F_4$ &  989 & 456 & --- & 90 & 991 & 4939 \\ \hline \hline
 FGb(estimated)  & 8 &11 & 288 &  0.6 & 5 & 10 \\ \hline  {\bf Minipoly} & 14 & positive dim & 14 & 286 & positive dim \\ \hline
   %Singular & --- & 15247 & --- & 7.6 & 79 & $>$ 20h \\ \hline
   %CoCoA 4 & --- & 13227 & --- & 57 & 709 & --- \\ \hline\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]
Line 457  FGb(estimated) & 8 &11 & 288 &  0.6 & 5 & 10 \\ \hline
Line 418  FGb(estimated) & 8 &11 & 288 &  0.6 & 5 & 10 \\ \hline
 \epsffile{blen.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}
   
 Table \ref{minipoly} shows timing data for the minimal polynomial  %Table \ref{minipoly} shows timing data for the minimal polynomial
 computation over {\bf Q}. Singular provides a function {\tt finduni}  %computations of all variables over {\bf Q} by the modular method.
 for computing the minimal polynomial in each variable in ${\bf  %\begin{table}[hbtp]
 Q}[x_1,\ldots,x_n]/I$ for zero dimensional ideal $I$. The modular  %\begin{center}
 method used in Asir is efficient when the resulting minimal  %\begin{tabular}{|c||c|c|c|c|c|} \hline
 polynomials have large coefficients and we can verify the fact from Table  %               & $C_6$ & $C_7$ & $K_6$ & $K_7$ & $K_8$ \\ \hline
 \ref{minipoly}.  %Singular & 0.9 & 846 & 307 & 60880 & ---  \\ \hline
 \begin{table}[hbtp]  %Asir & 1.5 & 182 & 12 & 164 & 3420  \\ \hline
 \begin{center}  %\end{tabular}
 \begin{tabular}{|c||c|c|c|c|c|} \hline  %\end{center}
                 & $C_6$ & $C_7$ & $K_6$ & $K_7$ & $K_8$ \\ \hline  %\caption{Minimal polynomial computation}
 Singular & 0.9 & 846 & 307 & 60880 & ---  \\ \hline  %\label{minipoly}
 Asir & 1.5 & 182 & 12 & 164 & 3420  \\ \hline  %\end{table}
 \end{tabular}  
 \end{center}  
 \caption{Minimal polynomial computation}  
 \label{minipoly}  
 \end{table}  
   
 \subsection{Polynomial factorization}  %\subsection{Polynomial factorization}
   %
 %Table \ref{unifac} shows timing data for univariate factorization over  %Table \ref{unifac} shows timing data for univariate factorization over
 %{\bf Q}.  $N_{i,j}$ is an irreducible polynomial which are hard to  %{\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  %factor by the classical algorithm. $N_{i,j}$ is a norm of a polynomial
 %and $\deg(N_i) = i$ with $j$ modular factors. Risa/Asir is  %and $\deg(N_i) = i$ with $j$ modular factors. Risa/Asir is
 %disadvantageous in factoring polynomials of this type because the  %disadvantageous in factoring polynomials of this type because the
 %algorithm used in Risa/Asir has exponential complexity. In contrast,  %algorithm used in Risa/Asir has exponential complexity. In contrast,
 %CoCoA 4\cite{COCOA} and NTL-5.2\cite{NTL} show nice performances  %CoCoA 4\cite{noro:COCOA} and NTL-5.2\cite{noro:NTL} show nice performances
 %because they implement recently developed algorithms.  %because they implement recently developed algorithms.
 %  %
 %\begin{table}[hbtp]  %\begin{table}[hbtp]
Line 504  Asir & 1.5 & 182 & 12 & 164 & 3420  \\ \hline
Line 460  Asir & 1.5 & 182 & 12 & 164 & 3420  \\ \hline
 %\caption{Univariate factorization over {\bf Q}}  %\caption{Univariate factorization over {\bf Q}}
 %\label{unifac}  %\label{unifac}
 %\end{table}  %\end{table}
   %
 Table \ref{multifac} shows timing data for multivariate  %Table \ref{multifac} shows timing data for multivariate factorization
 factorization over {\bf Q}.  %over {\bf Q}.  $W_{i,j,k}$ is a product of three multivariate
 $W_{i,j,k}$ is a product of three multivariate polynomials  %polynomials $Wang[i]$, $Wang[j]$, $Wang[k]$ given in a data file {\tt
 $Wang[i]$, $Wang[j]$, $Wang[k]$ given in a data file  %fctrdata} in Asir library directory. It is also included in Risa/Asir
 {\tt fctrdata} in Asir library directory. It is also included  %source tree and located in {\tt asir2000/lib}.  These examples have
 in Risa/Asir source tree and located in {\tt asir2000/lib}.  %leading coefficients of large degree which vanish at 0 which tend to
 For these examples Risa/Asir shows reasonable performance  %cause so-called the leading coefficient problem the bad zero
 compared with other famous systems.  %problem. Risa/Asir's implementation carefully treats such cases and it
 \begin{table}[hbtp]  %shows reasonable performance compared with other famous systems.
 \begin{center}  %\begin{table}[hbtp]
 \begin{tabular}{|c||c|c|c|c|c|} \hline  %\begin{center}
         & $W_{1,2,3}$ & $W_{4,5,6}$ & $W_{7,8,9}$ & $W_{10,11,12}$ & $W_{13,14,15}$ \\ \hline  %\begin{tabular}{|c||c|c|c|c|c|} \hline
 variables & 3 & 5 & 5 & 5 & 4 \\ \hline  %       & $W_{1,2,3}$ & $W_{4,5,6}$ & $W_{7,8,9}$ & $W_{10,11,12}$ & $W_{13,14,15}$ \\ \hline
 monomials & 905 & 41369 & 51940 & 30988 & 3344 \\ \hline\hline  %variables & 3 & 5 & 5 & 5 & 4 \\ \hline
 Asir    & 0.2 & 4.7 & 14 & 17 & 0.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},  %As to univariate factorization over {\bf Q}, the univariate factorizer
 the univariate factorizer implements only classical  %implements old algorithms and its behavior is what one expects,
 algorithms and its behavior is what one expects,  %that is, it shows average performance in cases where there are little
 that is, it shows average performance in cases  %extraneous factors, but shows poor performance for hard to factor
 where there are little extraneous factors, but  %polynomials with many extraneous factors.
 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}
   
Line 543  many extraneous factors.
Line 498  many extraneous factors.
   
 OpenXM stands for Open message eXchange protocol for Mathematics.  OpenXM stands for Open message eXchange protocol for Mathematics.
 From the viewpoint of protocol design, it can be regarded as a child  From the viewpoint of protocol design, it can be regarded as a child
 of OpenMath \cite{OPENMATH}.  However our approach is somewhat  of OpenMath \cite{noro:OPENMATH}.  However our approach is somewhat
 different. Our main purpose is to provide an environment for  different. Our main purpose is to provide an environment for
 integrating {\it existing} mathematical software systems. OpenXM  integrating {\it existing} mathematical software systems. OpenXM
 RFC-100 \cite{RFC100} defines a client-server architecture.  Under  RFC-100 \cite{noro:RFC100} defines a client-server architecture.  Under
 this specification, a client invokes an OpenXM ({\it OX}) server.  The  this specification, a client invokes an OpenXM ({\it OX}) server.  The
 client can send OpenXM ({\it OX}) messages to the server.  OX messages  client can send OpenXM ({\it OX}) messages to the server.  OX messages
 consist of {\it data} and {\it command}. Data is encoded according to  consist of {\it data} and {\it command}. Data is encoded according to
Line 563  hybrid server.
Line 518  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 built-in interface  asir} can access to OpenXM servers via several built-in interface
Line 644  def gbcheck(B,V,O,Procs) {
Line 599  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} contains 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. There is  in {\tt ox\_asir} without accessing to {\tt ox\_asir} via
 also a stack, which can be manipulated by the library functions. In  TCP/IP. There is also a stack, which can be manipulated by the library
 order to make full use of this interface, one has to prepare  functions. In order to make full use of this interface, one has to
 conversion functions between CMO and the data structures proper to the  prepare conversion functions between CMO and the data structures
 application itself.  A function {\tt asir\_ox\_pop\_string()} is  proper to the application itself. However, if the application linking
 provided to convert CMO to a human readable form, which may be  {\tt libasir.a} can parse human readable outputs, a function {\tt
 sufficient for a simple use of this interface.  asir\_ox\_pop\_string()} will be sufficient for receiving results.
   The following program shows its usage.
   
   \begin{verbatim}
   /* $OpenXM: OpenXM/doc/oxlib/test.c,v 1.3 2002/02/25
      07:24:33 noro Exp $ */
   #include <asir/ox.h>
   
   main() {
     char ibuf[BUFSIZ];
     char *obuf;
     int len,len0;
   
     asir_ox_init(1);  /* Use the network byte order */
   
     len0 = BUFSIZ;
     obuf = (char *)malloc(len0);
     while ( 1 ) {
       printf("Input> ");
       fgets(ibuf,BUFSIZ,stdin);
       if ( !strncmp(ibuf,"bye",3) )
         exit(0);
       /* the string in ibuf is executed, and the result
          is pushed onto the stack */
       asir_ox_execute_string(ibuf);
       /* estimate the string length of the result */
       len = asir_ox_peek_cmo_string_length();
       if ( len > len0 ) {
         len0 = len;
         obuf = (char *)realloc(obuf,len0);
       }
       /* write the result to obuf as a string */
       asir_ox_pop_string(obuf,len0);
       printf("Output> %s\n",obuf);
     }
   }
   \end{verbatim}
   In this program, \verb+asir_ox_execute_string()+ executes an Asir command line
   in {\tt ibuf} and the result is pushed onto the stack as a CMO data.
   Then we prepare a buffer sufficient to hold the result and call
   \verb+asir_ox_pop_string()+, which pops the result from the stack
   and convert it to a human readable form. Here is an example of execution:
   \begin{verbatim}
   % cc test.c OpenXM/lib/libasir.a OpenXM/lib/libasir-gc.a -lm
   % a.out
   Input> A = -z^31-w^12*z^20+y^18-y^14+x^2*y^2+x^21+w^2;
   Output> x^21+y^2*x^2+y^18-y^14-z^31-w^12*z^20+w^2
   Input> B = 29*w^4*z^3*x^12+21*z^2*x^3+3*w^15*y^20-15*z^16*y^2;
   Output> 29*w^4*z^3*x^12+21*z^2*x^3+3*w^15*y^20-15*z^16*y^2
   Input> fctr(A*B);
   Output> [[1,1],[29*w^4*z^3*x^12+21*z^2*x^3+3*w^15*y^20
   -15*z^16*y^2,1],[x^21+y^2*x^2+y^18-y^14-z^31-w^12*z^20+w^2,1]]
   \end{verbatim}
   
 \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. Especially on  %open system and its total performance is not bad. Especially on
 Groebner basis computation over {\bf Q}, many techniques for improving  %Groebner basis computation over {\bf Q}, many techniques for improving
 practical performances have been implemented. As the OpenXM interface  %practical performances have been implemented. As the OpenXM interface
 specification is completely documented, we can easily add another  %specification is completely documented, we can easily add another
 function to Risa/Asir by wrapping an existing software system as an OX  %function to Risa/Asir by wrapping an existing software system as an OX
 server, and other clients can call functions in Risa/Asir by  %server, and other clients can call functions in Risa/Asir by
 implementing the OpenXM client interface.  With the remote debugging  %implementing the OpenXM client interface.  With the remote debugging
 and the function to reset servers, one will be able to enjoy parallel  %and the function to reset servers, one will be able to enjoy parallel
 and distributed computation with OpenXM facilities.  %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:BW}
   Becker, T., and Weispfenning, V. (1993)
   Groebner Bases.
   Graduate Texts in Math {\bf 141}. Springer-Verlag.
   
   \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:SUGAR}
   Giovini, A., Mora, T., Niesi, G., Robbiano, L., and Traverso, C. (1991).
   ``One sugar cube, please'' OR Selection strategies in the Buchberger algorithm.
   In Proc. ISSAC'91, ACM Press, 49--54.
   
   \bibitem{noro:IKNY}
   Izu, T., Kogure, J., Noro, M., Yokoyama, K. (1998)
   Efficient implementation of Schoof's algorithm.
   LNCS 1514 (Proc. ASIACRYPT'98), Springer, 66--79.
   
   \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{RUR}  \bibitem{noro:RUR}
 Rouillier, R. (1996)  Rouillier, R. (1996)
 R\'esolution des syst\`emes z\'ero-dimensionnels.  R\'esolution des syst\`emes z\'ero-dimensionnels.
 Doctoral Thesis(1996), University of Rennes I, France.  Doctoral Thesis(1996), University of Rennes I, France.
   
 \bibitem{SY}  \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{BENCH}  \bibitem{noro:BENCH}
 {\tt http://www.math.uic.edu/\~\,jan/demo.html}.  {\tt http://www.math.uic.edu/\~\,jan/demo.html}.
   
 \bibitem{COCOA}  \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.9  
changed lines
  Added in v.1.12
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>