#### D.4.18.6 primeClosure

Procedure from library `normal.lib` (see normal_lib).

Usage:
  primeClosure(L [,c]); L a list of a ring containing a prime ideal ker, c an optional integer

Return:
  a list L (of size n+1) consisting of rings L[1],...,L[n] such that - L[1] is a copy of (not a reference to!) the input ring L[1] - all rings L[i] contain ideals ker, L[2],...,L[n] contain ideals phi such that
  L[1]/ker --> ... --> L[n]/ker
  are injections given by the corresponding ideals phi, and L[n]/ker is the integral closure of L[1]/ker in its quotient field. - all rings L[i] contain a polynomial nzd such that elements of L[i]/ker are quotients of elements of L[i-1]/ker with denominator nzd via the injection phi.
  L[n+1] is the delta invariant

Note:
  - L is constructed by recursive calls of primeClosure itself. - c determines the choice of nzd:
  - c not given or equal to 0: first generator of the ideal SL, the singular locus of Spec(L[i]/ker)
  - c<>0: the generator of SL with least number of monomials.

Example:

    LIB "normal.lib";
    ring R=0,(x,y),dp;
    ideal I=x4,y4;
    def K=ReesAlgebra(I)[1];        // K contains ker such that K/ker=R[It]
    list L=primeClosure(K);
    def R(1)=L[1];                  // L[4] contains ker, L[4]/ker is the
    def R(4)=L[4];                  // integral closure of L[1]/ker
    setring R(1);
    R(1);
    ==> //   characteristic : 0
    ==> //   number of vars : 4
    ==> //        block   1 : ordering dp
    ==> //                  : names    x y U(1) U(2)
    ==> //        block   2 : ordering C
    ker;
    ==> ker[1]=y^4*U(1)-x^4*U(2)
    setring R(4);
    R(4);
    ==> //   characteristic : 0
    ==> //   number of vars : 10
    ==> //        block   1 : ordering a
    ==> //                  : names    X(1) X(2) X(3) X(4) X(5) X(6) X(7) T(2) T(\
       3) T(4)
    ==> //                  : weights     1    1    1    1    3    2    2    1   \
        1    1
    ==> //        block   2 : ordering dp
    ==> //                  : names    X(1) X(2) X(3) X(4) X(5) X(6) X(7) T(2) T(\
       3) T(4)
    ==> //        block   3 : ordering C
    ker;
    ==> ker[1]=X(2)*X(7)-X(5)
    ==> ker[2]=X(1)*X(6)-X(5)
    ==> ker[3]=X(1)^2*X(4)-X(2)*X(6)
    ==> ker[4]=X(2)^2*X(3)-X(1)*X(7)
    ==> ker[5]=X(1)*X(4)*X(7)-X(6)^2
    ==> ker[6]=X(1)*X(2)*X(3)*X(4)-X(6)*X(7)
    ==> ker[7]=X(2)*X(3)*X(6)-X(7)^2
    ==> ker[8]=X(1)*T(3)-X(2)*T(4)
    ==> ker[9]=-X(2)*T(2)+X(1)*T(4)
    ==> ker[10]=-X(2)*T(2)+X(7)
    ==> ker[11]=-X(1)*T(3)+X(6)
    ==> ker[12]=X(6)*T(2)-X(7)*T(4)
    ==> ker[13]=-X(7)*T(3)+X(6)*T(4)
    ==> ker[14]=X(2)*X(4)*T(2)-X(6)*T(3)
    ==> ker[15]=X(1)*X(4)-X(2)*T(3)
    ==> ker[16]=X(1)*X(4)*T(2)-X(6)*T(4)
    ==> ker[17]=X(2)*X(3)-X(1)*T(2)
    ==> ker[18]=X(2)*X(3)*T(3)-X(6)*T(2)
    ==> ker[19]=X(2)*X(3)*T(4)-X(7)*T(2)
    ==> ker[20]=T(2)^2-X(3)*T(4)
    ==> ker[21]=-X(3)*X(4)+T(2)*T(3)
    ==> ker[22]=T(3)^2-X(4)*T(4)
    ==> ker[23]=-X(3)*T(3)+T(2)*T(4)
    ==> ker[24]=-X(4)*T(2)+T(3)*T(4)
    ==> ker[25]=-X(3)*X(4)+T(4)^2

User manual for Singular version 4-0-3, 2016, generated by texi2html.