`dp_nf', `dp_nf_mod', `dp_true_nf', `dp_true_nf_mod'
----------------------------------------------------

dp_nf(INDEXLIST,DPOLY,DPOLYARRAY,FULLREDUCE)

dp_nf_mod(INDEXLIST,DPOLY,DPOLYARRAY,FULLREDUCE,MOD)
     :: Computes the normal form of a distributed polynomial.  (The
     result may be multiplied by a constant in the ground field.)

dp_true_nf(INDEXLIST,DPOLY,DPOLYARRAY,FULLREDUCE)

dp_true_nf_mod(INDEXLIST,DPOLY,DPOLYARRAY,FULLREDUCE,MOD)
     :: Computes the normal form of a distributed polynomial. (The true
     result is returned in such a list as `[numerator, denominator]')

RETURN
     `dp_nf()' : distributed polynomial, `dp_true_nf()' : list

INDEXLIST
     list

DPOLY
     distributed polynomial

DPOLYARRAY
     array of distributed polynomial

FULLREDUCE
     flag

MOD
     prime

   * Computes the normal form of a distributed polynomial.

   * `dp_nf_mod()' and `dp_true_nf_mod()' require distributed
     polynomials with coefficients in a finite field as arguments.

   * The result of `dp_nf()' may be multiplied by a constant in the
     ground field in order to make the result integral. The same is true
     for `dp_nf_mod()', but it returns the true normal form if the
     ground field is a finite field.

   * `dp_true_nf()' and `dp_true_nf_mod()' return such a list as
     `[NM,DN]'.  Here NM is a distributed polynomial whose coefficients
     are integral in the ground field, DN is an integral element in the
     ground field and NM/DN is the true normal form.

   * DPOLYARRAY is a vector whose components are distributed polynomials
     and INDEXLIST is a list of indices which is used for the normal
     form computation.

   * When argument FULLREDUCE has non-zero value, all terms are
     reduced. When it has value 0, only the head term is reduced.

   * As for the polynomials specified by INDEXLIST, one specified by an
     index placed at the preceding position has priority to be selected.

   * In general, the result of the function may be different depending
     on INDEXLIST.  However, the result is unique for Groebner bases.

   * These functions are useful when a fixed non-distributed polynomial
     set is used as a set of reducers to compute normal forms of many
     polynomials.  For single computation `p_nf' and `p_true_nf' are
     sufficient.

     [0] load("gr")$
     [64] load("katsura")$
     [69] K=katsura(4)$
     [70] dp_ord(2)$
     [71] V=[u0,u1,u2,u3,u4]$
     [72] DP1=newvect(length(K),map(dp_ptod,K,V))$
     [73] G=gr(K,V,2)$
     [74] DP2=newvect(length(G),map(dp_ptod,G,V))$
     [75] T=dp_ptod((u0-u1+u2-u3+u4)^2,V)$
     [76] dp_dtop(dp_nf([0,1,2,3,4],T,DP1,1),V);
     u4^2+(6*u3+2*u2+6*u1-2)*u4+9*u3^2+(6*u2+18*u1-6)*u3+u2^2
     +(6*u1-2)*u2+9*u1^2-6*u1+1
     [77] dp_dtop(dp_nf([4,3,2,1,0],T,DP1,1),V);
     -5*u4^2+(-4*u3-4*u2-4*u1)*u4-u3^2-3*u3-u2^2+(2*u1-1)*u2-2*u1^2-3*u1+1
     [78] dp_dtop(dp_nf([0,1,2,3,4],T,DP2,1),V);
     -11380879768451657780886122972730785203470970010204714556333530492210
     456775930005716505560062087150928400876150217079820311439477560587583
     488*u4^15+...
     [79] dp_dtop(dp_nf([4,3,2,1,0],T,DP2,1),V);
     -11380879768451657780886122972730785203470970010204714556333530492210
     456775930005716505560062087150928400876150217079820311439477560587583
     488*u4^15+...
     [80] @78==@79;
     1

References
     *Note `dp_dtop': dp_dtop, *Note `dp_ord': dp_ord, *Note `dp_mod
     dp_rat': dp_mod dp_rat, *Note `p_nf p_nf_mod p_true_nf
     p_true_nf_mod': p_nf p_nf_mod p_true_nf p_true_nf_mod.

