
7.3.4 division (plural)
Syntax:
division ( ideal_expression, ideal_expression )
division ( module_expression, module_expression )
division ( ideal_expression, ideal_expression, int_expression )
division ( module_expression, module_expression, int_expression )
division ( ideal_expression, ideal_expression, int_expression, intvec_expression )
division ( module_expression, module_expression, int_expression,
intvec_expression )
Type:
 list
Purpose:
division computes a left division with remainder.
For two left ideals resp. modules M (first argument) and N
(second argument), it returns a list T,R,U where T is a matrix,
R is a left ideal resp. a module, and U is a diagonal matrix of units such that
transpose(U)*transpose(matrix(M))=transpose(T)*transpose(matrix(N)) + transpose(matrix(R)) . From this data one gets
a left standard representation for the left normal form R of M with respect to a left Groebner basis of N .
division uses different algorithms depending on whether N is represented by a Groebner basis.
For a GRalgebra, the matrix U is the identity matrix.
A matrix T as above is also computed by lift .
For additional arguments n (third argument) and w (fourth argument),
division returns a list T,R as above such that
transpose(matrix(M))=transpose(T)*transpose(matrix(N)) + transpose(matrix(R)) is a left standard representation for the
left normal form R of M with respect to N up to weighted degree n with respect to the weight vector w .
The weighted degree of T and R respect to w is at most n .
If the weight vector w is not given,
division uses the standard weight vector w=1,...,1 .
Example:
 LIB "dmod.lib";
ring r = 0,(x,y),dp;
poly f = x^3+xy;
def S = Sannfs(f); setring S; // compute the annihilator of f^s
LD; // is not a Groebner basis yet!
==> LD[1]=3*x^2*Dyx*Dx+y*Dy
==> LD[2]=x*Dx+2*y*Dy3*s
poly f = imap(r,f);
poly P = f*Dxs*diff(f,x);
division(P,LD); // so P is in the ideal via the cofactors in _[1]
==> [1]:
==> _[1,1]=2/3*y
==> _[2,1]=x^2+1/3*y
==> [2]:
==> _[1]=0
==> [3]:
==> _[1,1]=1
ideal I = LD, f; // consider a bigger ideal
list L = division(s^2, I); // the normal form is 2s1
L;
==> [1]:
==> _[1,1]=2/3*x^2*Dy1/3*x*Dx+2/3*s+1/3
==> _[2,1]=2/3*x^2*Dy1/3*x*Dx1/3*s2/3
==> _[3,1]=2*x*Dy^2+Dx*Dy
==> [2]:
==> _[1]=2*s1
==> [3]:
==> _[1,1]=1
// now we show that the formula above holds
matrix M[1][1] = s^2; matrix N = matrix(I);
matrix T = matrix(L[1]); matrix R = matrix(L[2]); matrix U = matrix(L[3]);
// the formula must return zero:
transpose(U)*transpose(M)  transpose(T)*transpose(N)  transpose(R);
==> _[1,1]=0

See
ideal;
lift;
module;
poly;
vector.
