OpenXM/doc/Papers/dag-noro-proc.tex - diff

Return to dag-noro-proc.tex CVS log

Up to [local] / OpenXM / doc / Papers

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

version 1.2, 2001/11/19 10:00:02

version 1.8, 2001/11/30 02:08:46

Line 1

% $OpenXM: OpenXM/doc/Papers/dag-noro-proc.tex,v 1.1 2001/11/19 01:02:30 noro Exp $

% $OpenXM: OpenXM/doc/Papers/dag-noro-proc.tex,v 1.7 2001/11/30 02:02:09 noro Exp $

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% This is a sample input file for your contribution to a multi-

% author book to be published by Springer Verlag.

Line 76

% allows abbreviation of title, if the full title is too long

% to fit in the running head

\author{Masayuki Noro\inst{1}}

\author{Masayuki Noro}

%\authorrunning{Masayuki Noro}

% if there are more than two authors,

Line 88

\maketitle % typesets the title of the contribution

\begin{abstract}

OpenXM \cite{OPENXM} is an infrastructure for exchanging mathematical

Risa/Asir is software for polynomial computation. It has been

developed for testing experimental polynomial algorithms, and now it

acts also as a main component in the OpenXM package \cite{OPENXM}.

OpenXM is an infrastructure for exchanging mathematical

data. It defines a client-server architecture for parallel and

distributed computation. Risa/Asir is software for polynomial

distributed computation. In this article we present an overview of

computation. It has been developed for testing new algorithms, and now

Risa/Asir and review several techniques for improving performances of

it acts as both a client and a server in the OpenXM package. In this

Groebner basis computation over {\bf Q}. We also show Risa/Asir's

article we present an overview of Risa/Asir and its performances on

OpenXM interfaces and their usages.

several functions. We also show Risa/Asir's OpenXM interfaces and

examples of usages of them.

\end{abstract}

\section{A computer algebra system Risa/Asir}

Line 105 examples of usages of them.

Line 106 examples of usages of them.

Risa/Asir \cite{RISA} is software mainly for polynomial

computation. Its major functions are polynomial factorization and

Groebner basis computation, whose core parts are implemented as

builtin functions. Some higher algorithms such as primary ideal

built-in functions. Some higher algorithms such as primary ideal

decomposition or Galois group computation are built on them by the

user language. The user language is called Asir language. Asir

user language called Asir language. Asir language can be regarded as C

language can be regarded as C language without type declaration of

language without type declaration of variables, with list processing,

variables, with list processing, and with automatic garbage

and with automatic garbage collection. A built-in {\tt gdb}-like user

collection. A builtin {\tt gdb}-like user language debugger is

language debugger is available. Risa/Asir is open source and the

available. It is open source and the source code and binaries are

source code and binaries are available via {\tt ftp} or {\tt CVS}.

available via ftp or CVS.

Risa/Asir is not only a standalone computer algebra system but also a

Risa/Asir is not only an standalone computer algebra system but also a

main component in OpenXM package \cite{OPENXM}, which is a collection

of software comliant to OpenXM protocol specification. OpenXM is an

of various software compliant to OpenXM protocol specification.

infrastructure for exchanging mathematical data and Risa/Asir has

OpenXM is an infrastructure for exchanging mathematical data and

three kind of OpenXM intefaces : an inteface as a server, as a cllient

Risa/Asir has three kinds of OpenXM interfaces : as a client, as a

and as a subroutine library. We will explain them in the later

server, and as a subroutine library. Our goals of developing Risa/Asir

section.

are as follows:

Our goals of developing Risa/Asir are as follows:

\begin{enumerate}

\item Providing a test bed of new algorithms

\item Providing a platform for testing new algorithms

Risa/Asir has been a platform for testing experimental algorithms in

polynomial factorization, computation related to Groebner basis,

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.

been implemented in Risa/Asir with other known methods.

\item Gereral purpose open system

\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 obtain various high

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 cleints as OpenXM package in 1997. Risa/Asir is

of such servers and clients as the OpenXM package in 1997. Risa/Asir

now a main client in the package.

is now a main client in the package.

\item Environment for parallel and distributed computation

The origin of OpenXM is a protocol for doing parallel distributed

The ancestor of OpenXM is a protocol designed for doing parallel

compuatations by connecting multiple Risa/Asir. OpenXM is also

distributed computations by connecting multiple Risa/Asir's over

designed to provide an enviroment efficient parallel distributed

TCP/IP. OpenXM is also designed to provide an environment for

computation. Currently only client-server communication is possible,

efficient parallel distributed computation. Currently only

but we are preparing a specification OpenXM-RFC 102 allowing

client-server communication is available, but we are preparing a

client-client communication, which will enable us to execute

specification OpenXM-RFC 102 allowing client-client communication,

wider range of parallel algorithms efficiently.

which will enable us to execute wider range of parallel algorithms

requiring collective operations efficiently.

\end{enumerate}

\subsection{Groebner basis and the related computation}

Line 159 wider range of parallel algorithms efficiently.

Line 158 wider range of parallel algorithms efficiently.

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 the rationals, fields of

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 the rationals. Our main tool is modular

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 is hard to compute without

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 and rational univariate representation. We also

of ordering algorithm\cite{FGLM} and rational univariate

made a test implementation of $F_4$ algorithm \cite{F4}. Later we will

representation \cite{RUR}. We also made a test implementation of

show timing data on Groebner basis computation.

$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 factorizer

recently proposed have not yet implemented. For univariate

over algebraic number fields, Trager's algorithm \cite{TRAGER} is

factorization over algebraic number fields, Trager's algorithm

implemented with some modifications. Its major applications are

\cite{TRAGER} is implemented with some modifications. Its major

splitting field and Galois group computation of polynomials over the

applications are splitting field and Galois group computation of

rationals. For such purpose a tower of simple extensions are suitable

polynomials over {\bf Q} \cite{ANY}. For such purpose a tower of

because factors represented over a simple extension often have huge

simple extensions are suitable because factors represented over a

coefficients \cite{ANY}. For univariate factorization over finite

simple extension often have huge coefficients. For univariate

fields, equal degree factorization + Cantor-Zassenhaus algorithm is

factorization over finite fields, equal degree factorization and

implemented. We can use various representation of finite fields:

Cantor-Zassenhaus algorithm are implemented. We can use various

$GF(p)$ with a machine integer prime $p$, $GF(p)$, $GF(p^n)$ with any

representation of finite fields: $GF(p)$ with a machine integer prime

odd prime $p$, $GF(2^n)$ with a bit representation of polynomials over

$p$, $GF(p)$ and $GF(p^n)$ with any odd prime $p$, $GF(2^n)$ with a

$GF(2)$ and $GF(p^n)$ with small $p^n$ represented by a primitive

bit-array representation of polynomials over $GF(2)$ and $GF(p^n)$

root. For multivariate factorization over the rationals, the

with small $p^n$ represented by a primitive root. For multivariate

classical EZ(Extented Zassenhaus) type algorithm is implemented.

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 decompsition is written in the user language.

\cite{SY} for primary decomposition is written in the user language.

Splitting field and Galois group computation are closely related and

Splitting field and Galois group computation \cite{ANY} are closely

are also important applications of polynomial factorization. Our

related and are also important applications of polynomial

implementation of Galois group computation algorithm \cite{ANY}

factorization.

requires splitting field computation, which is written in the

user language.

\section{Techniques for efficient Groebner basis computation over {\bf Q}}

\label{gbtech}

Line 214 Groebner basis computation over {\bf Q}, which are eas

Line 213 Groebner basis computation over {\bf Q}, which are eas

implemented but may not be well known.

We use the following notations.

\begin{description}

\item $Id(F)$ : a polynomial ideal generated by a polynomial set $F$

\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 $HT(f)$ : the head term of a polynomial with respect to a term order

\item $HC(f)$ : the head coefficient of a polynomail with respect to a term order

\item $HC(f)$ : the head coefficient of a polynomial with respect to a term order

\end{description}

\subsection{Combination of homogenization and trace lifting}

\label{gbhomo}

Traverso's trace lifting algorithm can be

formulated in an abstract form as follows \cite{FPARA}.

formulated in an abstract form as follows (c.f. \cite{FPARA}).

\begin{tabbing}

Input : a finite subset $F \subset {\bf Z}[X]$\\

Output : a Groebner basis $G$ of $Id(F)$ with respect to a term order $<$\\

Line 235 such that $\phi_p(G)$ \\

Line 236 such that $\phi_p(G)$ \\

\>If $G$ passes the check return $G$\\

end do

\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}

$tl\_h\_guess\_dh(F,p)$\\

Input : $F\subset {\bf Z}[X]$, a prime $p$\\

Line 254 such that $HT(h)|HT(g)$ \}

Line 255 such that $HT(h)|HT(g)$ \}

The input is homogenized to suppress intermediate coefficient swells

of intermediate basis elements. The number of zero normal forms may

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}

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

be computed by a partial FGLM \cite{FGLM}, but it often takes long

Line 267 case we can apply a simple modular method to compute t

Line 268 case we can apply a simple modular method to compute t

polynomial.

\begin{tabbing}

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 \= \\

\> $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))$\\

Line 279 In this algorithm, $m_p$ can be obtained by a partial

Line 280 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

candidate of $\deg(m(x_i))$, $m(x_i)$ can be determined by solving a

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{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}

\label{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

polynomial $f$ efficiently by the following method \cite{REPL}.

\begin{tabbing}

Input : an integral polynomial $f$\\

Output : a pair $(\cont(f),f/\cont(f))$\\

$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)$\\

else return $(g,g_0/g \cdot q + r/g)$, where $g = \GCD(g_0,\cont(r))$

\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.

%\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

%basis elements should be put on disk to enlarge free memory space.

%This does not reduce the efficiency so much because all basis elements

Line 311 $g_0$ with high accuracy. Then other components are ea

Line 314 $g_0$ with high accuracy. Then other components are ea

\section{Risa/Asir performance}

We show timing data on Risa/Asir for polynomial factorization

We show timing data on Risa/Asir for Groebner basis computation

and Groebner basis computation. The measurements were made on

and polynomial factorization. The measurements were made on

a PC with PentiumIII 1GHz and 1Gbyte of main memory. Timings

are given in seconds. In the tables `---' means it was not

measured.

\subsection{Groebner basis computation}

Table \ref{gbmod} and Table \ref{gbq} shows timing data for Groebner

Table \ref{gbmod} and Table \ref{gbq} show timing data for Groebner

basis compuation over $GF(32003)$ and over {\bf Q} respectively.

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. We also measured the timing for

both are famous bench mark problems \cite{BENCH}. We also measured

$McKay$ system over {\bf Q} \cite{REPL}. the term order is graded

the timing for $McKay$ system over {\bf Q} \cite{REPL}. the term

reverse lexicographic order. In the both tables, the first three rows

order is graded reverse lexicographic order. In the both tables, the

are timings for the Buchberger algorithm, and the last two rows are

first three rows are timings for the Buchberger algorithm, and the

timings for $F_4$ algorithm. As to the Buchberger algorithm over

last two rows are timings for $F_4$ algorithm. As to the Buchberger

$GF(32003)$, Singular\cite{SINGULAR} shows the best performance among

algorithm over $GF(32003)$, Singular\cite{SINGULAR} shows the best

the three systems. $F_4$ implementation in Risa/Asir is faster than

performance among the three systems. $F_4$ implementation in Risa/Asir

the Buchberger algorithm implementation in Singluar, but it is still

is faster than the Buchberger algorithm implementation in Singular,

several times slower than $F_4$ implemenataion in FGb \cite{FGB}. In

but it is still several times slower than $F_4$ implementation in FGb

Table \ref{gbq}, $C_7$ and $McKay$ can be computed by the Buchberger

\cite{FGB}. In Table \ref{gbq}, Risa/Asir computed $C_7$ and $McKay$

algorithm with the methods described in Section \ref{gbtech}. It is

by the Buchberger algorithm with the methods described in Section

obvious that $F_4$ implementation in Risa/Asir over {\bf Q} is too

\ref{gbhomo} and \ref{gbcont}. It is obvious that $F_4$

immature. Nevertheless the timing of $McKay$ is greatly reduced.

implementation in Risa/Asir over {\bf Q} is too immature. Nevertheless

Why is $F_4$ efficient in this case? The answer is in the right

the timing of $McKay$ is greatly reduced. Fig. \ref{f4vsbuch}

half of Fig. \ref{f4vsbuch}. During processing S-polynomials of degree

explains why $F_4$ is efficient in this case. The figure shows that

16, the Buchberger algorithm produces intermediate polynomials with

the Buchberger algorithm produces normal forms with huge coefficients

huge coefficients, but if we compute normal forms of these polynomials

for S-polynomials after the 250-th one, which are the computations in

by using all subsequently generated basis elements, then their

degree 16. However, we know that the reduced basis elements have much

coefficients will be reduced after removing contents. As $F_4$

smaller coefficients after removing contents. As $F_4$ algorithm

algorithm automatically produces the reduced basis elements, the

automatically produces the reduced ones, the degree 16 computation is

degree 16 computation is quite easy in $F_4$.

quite easy in $F_4$.

\begin{table}[hbtp]

\begin{center}

\begin{tabular}{|c||c|c|c|c|c|c|c|} \hline

Line 362 FGb(estimated) & 0.9 & 23 & 0.1 & 0.8 & 6 & 51 & 366 \

Line 364 FGb(estimated) & 0.9 & 23 & 0.1 & 0.8 & 6 & 51 & 366 \

\begin{table}[hbtp]

\begin{center}

\begin{tabular}{|c||c|c|c|c|c|} \hline

\begin{tabular}{|c||c|c|c|c|c|c|} \hline

& $C_7$ & $Homog. C_7$ & $K_7$ & $K_8$ & $McKay$ \\ \hline

& $C_7$ & $Homog. C_7$ & $C_8$ & $K_7$ & $K_8$ & $McKay$ \\ \hline

Asir $Buchberger$ & 389 & 594 & 29 & 299 & 34950 \\ \hline

Asir $Buchberger$ & 389 & 594 & 54000 & 29 & 299 & 34950 \\ \hline

Singular & --- & 15247 & 7.6 & 79 & $>$ 20h \\ \hline

Singular & --- & 15247 & --- & 7.6 & 79 & $>$ 20h \\ \hline

CoCoA 4 & --- & 13227 & 57 & 709 & --- \\ \hline\hline

CoCoA 4 & --- & 13227 & --- & 57 & 709 & --- \\ \hline\hline

Asir $F_4$ & 989 & 456 & 90 & 991 & 4939 \\ \hline

Asir $F_4$ & 989 & 456 & --- & 90 & 991 & 4939 \\ \hline

FGb(estimated) & 8 &11 & 0.6 & 5 & 10 \\ \hline

FGb(estimated) & 8 &11 & 288 & 0.6 & 5 & 10 \\ \hline

\end{tabular}

\end{center}

\caption{Groebner basis computation over {\bf Q}}

Line 378 FGb(estimated) & 8 &11 & 0.6 & 5 & 10 \\ \hline

Line 380 FGb(estimated) & 8 &11 & 0.6 & 5 & 10 \\ \hline

\begin{figure}[hbtp]

\begin{center}

\epsfxsize=12cm

\epsffile{../compalg/ps/blenall.ps}

%\epsffile{../compalg/ps/blenall.ps}

\epsffile{blen.ps}

\end{center}

\caption{Maximal coefficient bit length of intermediate bases}

\label{f4vsbuch}

\end{figure}

\subsection{Polynomial factorization}

Table \ref{minipoly} shows timing data for the minimal polynomial

computation over {\bf Q}. Singular provides a function {\tt finduni}

Table \ref{unifac} shows timing data for univariate factorization over

for computing the minimal polynomial in each variable in ${\bf

{\bf Q}. $N_{i,j}$ is an irreducible polynomial which are hard to

Q}[x_1,\ldots,x_n]/I$ for zero dimensional ideal $I$. The modular

factor by the classical algorithm. $N_{i,j}$ is a norm of a polynomial

method used in Asir is efficient when the resulting minimal

and $\deg(N_i) = i$ with $j$ modular factors. Risa/Asir is

polynomials have large coefficients and we can verify the fact from Table

disadvantageous in factoring polynomials of this type because the

\ref{minipoly}.

algorithm used in Risa/Asir has exponential complexity. In contrast,

CoCoA 4\cite{COCOA} and NTL-5.2\cite{NTL} show nice performances

because they implement recently developed algorithms.

\begin{table}[hbtp]

\begin{center}

\begin{tabular}{|c||c|c|c|c|} \hline

\begin{tabular}{|c||c|c|c|c|c|} \hline

& $N_{105,23}$ & $N_{120,20}$ & $N_{168,24}$ & $N_{210,54}$ \\ \hline

& $C_6$ & $C_7$ & $K_6$ & $K_7$ & $K_8$ \\ \hline

Asir & 0.86 & 59 & 840 & hard \\ \hline

Singular & 0.9 & 846 & 307 & 60880 & --- \\ \hline

Asir NormFactor & 1.6 & 2.2& 6.1& hard \\ \hline

Asir & 1.5 & 182 & 12 & 164 & 3420 \\ \hline

%Singular& hard? & hard?& hard? & hard? \\ \hline

CoCoA 4 & 0.2 & 7.1 & 16 & 0.5 \\ \hline\hline

NTL-5.2 & 0.16 & 0.9 & 1.4 & 0.4 \\ \hline

\end{tabular}

\end{center}

\caption{Univariate factorization over {\bf Q}}

\caption{Minimal polynomial computation}

\label{unifac}

\label{minipoly}

\end{table}

\subsection{Polynomial factorization}

%Table \ref{unifac} shows timing data for univariate factorization over

%{\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

%and $\deg(N_i) = i$ with $j$ modular factors. Risa/Asir is

%disadvantageous in factoring polynomials of this type because the

%algorithm used in Risa/Asir has exponential complexity. In contrast,

%CoCoA 4\cite{COCOA} and NTL-5.2\cite{NTL} show nice performances

%because they implement recently developed algorithms.

%\begin{table}[hbtp]

%\begin{center}

%\begin{tabular}{|c||c|c|c|c|} \hline

% & $N_{105,23}$ & $N_{120,20}$ & $N_{168,24}$ & $N_{210,54}$ \\ \hline

%Asir & 0.86 & 59 & 840 & hard \\ \hline

%Asir NormFactor & 1.6 & 2.2& 6.1& hard \\ \hline

%%Singular& hard? & hard?& hard? & hard? \\ \hline

%CoCoA 4 & 0.2 & 7.1 & 16 & 0.5 \\ \hline\hline

%NTL-5.2 & 0.16 & 0.9 & 1.4 & 0.4 \\ \hline

%\end{tabular}

%\end{center}

%\caption{Univariate factorization over {\bf Q}}

%\label{unifac}

%\end{table}

Table \ref{multifac} shows timing data for multivariate

factorization over {\bf Q}.

$W_{i,j,k}$ is a product of three multivariate polynomials

Line 418 $Wang[i]$, $Wang[j]$, $Wang[k]$ given in a data file

Line 440 $Wang[i]$, $Wang[j]$, $Wang[k]$ given in a data file

in Risa/Asir source tree and located in {\tt asir2000/lib}.

For these examples Risa/Asir shows reasonable performance

compared with other famous systems.

\begin{table}[hbtp]

\begin{center}

\begin{tabular}{|c||c|c|c|c|c|} \hline

Line 435 Maple 7& 0.5 & 18 & 967 & 48 & 1.3 \\ \hline

Line 456 Maple 7& 0.5 & 18 & 967 & 48 & 1.3 \\ \hline

\caption{Multivariate factorization over {\bf Q}}

\label{multifac}

\end{table}

As to univariate factorization over {\bf Q},

the univariate factorizer implements only classical

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}

\subsection{OpenXM overview}

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{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{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

the method to reset a server is carefully designed and it provides

Line 466 purposes.

Line 495 purposes.

\subsection{OpenXM client interface of {\tt asir}}

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}

[1] P = ox_launch(); /* invoke an OpenXM asir server */

Line 483 a typical OpenXM session.

Line 512 a typical OpenXM session.

[[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]]

[5] ox_cmo_rpc(P,"fctr,",x^10000-2^10000*y^10000);

/* call factorizer; an utility function */

/* call factorizer; a utility function */

[6] ox_reset(P); /* reset the computation in the server */

Line 495 a typical OpenXM session.

Line 524 a typical OpenXM session.

An application {\tt ox\_asir} is a wrapper of {\tt asir} and provides

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

computations to idling servers. If there are no idling servers the

clients waits for some servers to return results by {\tt

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}

def gbcheck(B,V,O,Procs) {

Line 544 def gbcheck(B,V,O,Procs) {

Line 573 def gbcheck(B,V,O,Procs) {

\subsection{Asir OpenXM library {\tt libasir.a}}

Asir OpenXM library {\tt libasir.a} includes functions simulating the

Asir OpenXM library {\tt libasir.a} contains functions simulating the

stack machine commands supported in {\tt ox\_asir}. By linking {\tt

libasir.a} an application can use the same functions as in {\tt

ox\_asir} without accessing to {\tt ox\_asir} via TCP/IP.

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}

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

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.

\begin{thebibliography}{7}

Line 612 OpenXM committers (2000-2001)

Line 649 OpenXM committers (2000-2001)

OpenXM package.

{\tt http://www.openxm.org}.

\bibitem{RUR}

Rouillier, R. (1996)

R\'esolution des syst\`emes z\'ero-dimensionnels.

Doctoral Thesis(1996), University of Rennes I, France.

\bibitem{SY}

Shimoyama, T., Yokoyama, K. (1996)

Localization and Primary Decomposition of Polynomial Ideals.

Line 627 Traverso, C. (1988)

Line 669 Traverso, C. (1988)

Groebner trace algorithms.

LNCS {\bf 358} (Proceedings of ISSAC'88), Springer-Verlag, 125--138.

\bibitem{BENCH}

{\tt http://www.math.uic.edu/\~\,jan/demo.html}.

\bibitem{COCOA}

{\tt http://cocoa.dima.unige.it/}.

\bibitem{FGB}

{\tt http://www-calfor.lip6.fr/\~\,jcf/}.

\bibitem{NTL}

%\bibitem{NTL}

{\tt http://www.shoup.net/}.

%{\tt http://www.shoup.net/}.

\bibitem{OPENMATH}

{\tt http://www.openmath.org/}.

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>