Top
Back: normal_lib
Forward: HomJJ
FastBack: noether_lib
FastForward: pointid_lib
Up: normal_lib
Top: Singular Manual
Contents: Table of Contents
Index: Index
About: About this document

D.4.13.1 normal

Procedure from library normal.lib (see normal_lib).

Usage:
normal(id [,choose]); id = radical ideal, choose = optional string.
Optional parameters in list choose (can be entered in any order):
Decomposition:
- "equidim" -> computes first an equidimensional decomposition, and then the normalization of each component. (default)
- "prim" -> computes first the minimal associated primes, and then the normalization of each prime.
- "noDeco" -> no preliminary decomposition is done. If the ideal is not equidimensional radical, output might be wrong.
- "isPrim" -> assumes that the ideal is prime. If assumption does not hold, output might be wrong.
- "noFac" -> factorization is avoided in the computation of the minimal associated primes;
Other:
- "useRing" -> uses the original ring ordering.
If the ring ordering is not global, it will change to a global ordering only for computing radicals and prime or equidimensional decompositions.
If this option is not set, it changes to dp ordering and perform all computation with respect to this ordering.
- "withDelta" (or "wd") -> returns also the delta invariants. If choose is not given or empty, the default options are used.

Assume:
The ideal must be radical, for non-radical ideals the output may be wrong (id=radical(id); makes id radical). However, when using "prim" option the minimal associated primes of id are computed first and hence normal computes the normalization of the radical of id.
"isPrim" should only be used if id is known to be prime.

Return:
a list, say nor, of size 2 (resp. 3 with option "withDelta").
 
         * nor[1], the first element, is a list of r rings, where r is the
         number of associated primes P_i with option "prim" (resp. >= no
         of equidimenensional components P_i with option "equidim").
Each ring Ri:=nor[1][i], i=1..r, contains two ideals with given names norid and normap such that
- Ri/norid is the normalization of the i-th component, i.e. the integral closure in its field of fractions (as affine ring); - normap gives the normalization map from basering/id to Ri/norid for each i.
- the direct sum of the rings Ri/norid, i=1,..r, is the normalization of basering/id;
* nor[2] is a list of size r with information on the normalization of the i-th component as module over the basering:
nor[2][i] is an ideal, say U, in the basering such that the integral closure of basering/P_i is generated as module over the basering by 1/c * U, with c the last element U[size(U)] of U.
* nor[3] (if option "withDelta" is set) is a list of an intvec of size r, the delta invariants of the r components, and an integer, the total delta invariant of basering/id (-1 means infinite, and 0 that basering/P_i resp. basering/input is normal).

Theory:
We use a general algorithm described in [G.-M. Greuel, S. Laplagne, F. Seelisch: Normalization of Rings (2009)].
The delta invariant of a reduced ring K[x1,...,xn]/id is dim_K(normalization(K[x1,...,xn]/id) / K[x1,...,xn]/id) We call this number also the delta invariant of id.

Note:
To use the i-th ring type: def R=nor[1][i]; setring R;.
Increasing/decreasing printlevel displays more/less comments (default: printlevel=0).
Implementation works also for local rings.
Not implemented for quotient rings.
If the input ideal id is weighted homogeneous a weighted ordering may be used (qhweight(id); computes weights).

Example:
 
LIB "normal.lib";
printlevel = printlevel+1;
ring s = 0,(x,y),dp;
ideal i = (x2-y3)*(x2+y2)*x;
list nor = normal(i, "withDelta", "prim");
==> // Computing the minimal associated primes...
==> [1]:
==>    _[1]=-y3+x2
==> [2]:
==>    _[1]=x2+y2
==> [3]:
==>    _[1]=x
==> 
==> // number of components is 3
==> 
==> // start computation of component 1
==>    --------------------------------
==> Computing the jacobian ideal...
==> 
==> The universal denominator is  x
==> The original singular locus is
==> _[1]=x
==> _[2]=y2
==> 
==> The radical of the original singular locus is
==> J[1]=x
==> J[2]=y
==> The non zero divisor is  y
==> 
==> Preliminar step begins.
==> Computing the quotient (DJ : J)...
==> In this step, we have the ring 1/c * U, with c = y
==> and U = 
==> U[1]=y
==> U[2]=x
==> 
==> Step  1  begins.
==> Computing the test ideal...
==> Computing the quotient (c*D*cJ : cJ)...
==> The ring in the previous step was already normal.
==> 
==> // start computation of component 2
==>    --------------------------------
==> Computing the jacobian ideal...
==> 
==> The universal denominator is  y
==> The original singular locus is
==> _[1]=y
==> _[2]=x
==> 
==> The radical of the original singular locus is
==> J[1]=x
==> J[2]=y
==> The non zero divisor is  y
==> 
==> Preliminar step begins.
==> Computing the quotient (DJ : J)...
==> In this step, we have the ring 1/c * U, with c = y
==> and U = 
==> U[1]=y
==> U[2]=x
==> 
==> Step  1  begins.
==> Computing the test ideal...
==> Computing the quotient (c*D*cJ : cJ)...
==> The ring in the previous step was already normal.
==> 
==> // start computation of component 3
==>    --------------------------------
==> Computing the jacobian ideal...
==> 
==> The universal denominator is  1
==> The original singular locus is
==> _[1]=1
==> 
==> The radical of the original singular locus is
==> J[1]=x
==> J[2]=y
==> The non zero divisor is  y
==> 
==> Preliminar step begins.
==> Computing the quotient (DJ : J)...
==> // Sum of delta for all components:  2
==> // Computing the sum of the intersection multiplicities of the components\
   ...
==> // Intersection multiplicity is :  11
==> 
==> // 'normal' created a list, say nor, of three elements.
==> // * nor[1] is a list of 3 ring(s). To access the i-th ring nor[1][i], 
==> // give it a name, say Ri, and type e.g. 
==>      def R1 = nor[1][1]; setring R1; norid; normap;
==> // For the other rings type first 
==>      setring r;
==> // (if r is the name of your original basering) and then continue as
==> // for the first ring.
==> // Ri/norid is the affine algebra of the normalization of the i-th 
==> // component r/P_i (where P_i is the i-th component of a decomposition of
==> // the input ideal) and normap the normalization map from r to Ri/norid.
==> // * nor[2] is a list of 3 ideal(s) such that the integral
==> // closure of basering/P_i is generated as module over the basering by
==> // 1/ci * Ui, with Ui the i-th ideal of nor[2] and ci the last element
==> // Ui[size(Ui)] of Ui.
==> // * nor[3] is a list of an intvec of size r, the delta invariants 
==> // of the r components, and an integer, the total delta invariant 
==> // of basering/id (-1 means infinite, and 0 that basering/P_i resp. 
==> // basering/input is normal).
nor;
==> [1]:
==>    [1]:
==>       //   characteristic : 0
==> //   number of vars : 3
==> //        block   1 : ordering dp
==> //                  : names    T(1) 
==> //        block   2 : ordering dp
==> //                  : names    x y 
==> //        block   3 : ordering C
==>    [2]:
==>       //   characteristic : 0
==> //   number of vars : 3
==> //        block   1 : ordering dp
==> //                  : names    T(1) 
==> //        block   2 : ordering dp
==> //                  : names    x y 
==> //        block   3 : ordering C
==>    [3]:
==>       //   characteristic : 0
==> //   number of vars : 2
==> //        block   1 : ordering dp
==> //                  : names    x y 
==> //        block   2 : ordering C
==> [2]:
==>    [1]:
==>       _[1]=x
==>       _[2]=y
==>    [2]:
==>       _[1]=x
==>       _[2]=y
==>    [3]:
==>       _[1]=1
==> [3]:
==>    [1]:
==>       1,1,0
==>    [2]:
==>       13
// 2 branches have delta = 1, and 1 branch has delta = 0
// the total delta invariant is 13
def R2 = nor[1][2];  setring R2;
norid; normap;
==> norid[1]=-T(1)*y+x
==> norid[2]=T(1)*x+y
==> norid[3]=T(1)^2+1
==> norid[4]=x^2+y^2
==> normap[1]=x
==> normap[2]=y
printlevel = printlevel-1;
ring r = 2,(x,y,z),dp;
ideal i = z3-xy4;
list nor = normal(i, "withDelta", "prim");  nor;
==> 
==> // 'normal' created a list, say nor, of three elements.
==> // * nor[1] is a list of 1 ring(s). To access the i-th ring nor[1][i], 
==> // give it a name, say Ri, and type e.g. 
==>      def R1 = nor[1][1]; setring R1; norid; normap;
==> // For the other rings type first 
==>      setring r;
==> // (if r is the name of your original basering) and then continue as
==> // for the first ring.
==> // Ri/norid is the affine algebra of the normalization of the i-th 
==> // component r/P_i (where P_i is the i-th component of a decomposition of
==> // the input ideal) and normap the normalization map from r to Ri/norid.
==> // * nor[2] is a list of 1 ideal(s) such that the integral
==> // closure of basering/P_i is generated as module over the basering by
==> // 1/ci * Ui, with Ui the i-th ideal of nor[2] and ci the last element
==> // Ui[size(Ui)] of Ui.
==> // * nor[3] is a list of an intvec of size r, the delta invariants 
==> // of the r components, and an integer, the total delta invariant 
==> // of basering/id (-1 means infinite, and 0 that basering/P_i resp. 
==> // basering/input is normal).
==> [1]:
==>    [1]:
==>       //   characteristic : 2
==> //   number of vars : 5
==> //        block   1 : ordering dp
==> //                  : names    T(1) T(2) 
==> //        block   2 : ordering dp
==> //                  : names    x y z 
==> //        block   3 : ordering C
==> [2]:
==>    [1]:
==>       _[1]=xy2z
==>       _[2]=xy3
==>       _[3]=z2
==> [3]:
==>    [1]:
==>       -1
==>    [2]:
==>       -1
// the delta invariant is infinite
// xy2z/z2 and xy3/z2 generate the integral closure of r/i as r/i-module
// in its quotient field Quot(r/i)
// the normalization as affine algebra over the ground field:
def R = nor[1][1]; setring R;
norid; normap;
==> norid[1]=T(1)*y+T(2)*z
==> norid[2]=T(2)*y+z
==> norid[3]=T(1)*z+x*y^2
==> norid[4]=T(1)^2+x*z
==> norid[5]=T(1)*T(2)+x*y
==> norid[6]=T(2)^2+T(1)
==> norid[7]=x*y^4+z^3
==> normap[1]=x
==> normap[2]=y
==> normap[3]=z


Top Back: normal_lib Forward: HomJJ FastBack: noether_lib FastForward: pointid_lib Up: normal_lib Top: Singular Manual Contents: Table of Contents Index: Index About: About this document
            User manual for Singular version 3-1-0, Mar 2009, generated by texi2html.