Top
Back: normal
Forward: normalC
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.2 normalP

Procedure from library normal.lib (see normal_lib).

Usage:
normalP(id [,choose]); id a radical ideal, choose a comma separated list of optional strings "withRing", "isPrim", "noFac", "noRed", where
- "noFac", factorization is avoided during the computation of the minimal associated primes.
- "isPrim", disables the computation of the minimal associated primes (should only be used if the ideal is known to be prime).
- "withRing", the ring structure of the normalization is computed. The number of variables in the new ring is reduced as much as possible.
- "noRed", when computing the ring structure no reduction on the number of variables is done, it creates one new variable for each of the new generators of the integral closure in the quotient field.

Assume:
The characteristic of the ground field must be positive. The ideal id is assumed to be radical. However, if choose does not contain "isPrim" the minimal associated primes of id are computed first and hence normal computes the normalization of the radical of id. If choose = "isPrim" the ideal must be a prime ideal (this is not tested) otherwise the result may be wrong.

Return:
a list, say 'nor' of size 2 (default) or, if "withRing" is given, of size 3.
nor[1] (resp. nor[2] if "withRing" is given) is a list of ideals Ii, i=1..r, in the basering where r is the number of associated prime ideals P_i (irreducible components) of id.
- Ii is an ideal given by polynomials g_1,...,g_k,g_k+1 such that g_1/g_k+1,...,g_k/g_k+1 generate the integral closure of basering/P_i as module (over the basering) in its quotient field.

nor[2] (resp. nor[3] if choose="withRing") 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).

If the optional string "withRing" is given, the ring structure of the normalization is computed too and nor[1] is a list of r rings.
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 rime component P_i, i.e. isomorphic to the integral closure of basering/P_i in its field of fractions;
- the direct sum of the rings Ri/norid is the normalization of basering/id;
- normap gives the normalization map from basering/P_i to Ri/norid (for each i).

Theory:
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. normalP uses the qth-power algorithm suggested by Leonard-Pellikaan (using the Frobenius) in part similair to an implementation by Singh-Swanson.

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).
Not implemented for local or mixed orderings or quotient rings.
If the input ideal id is weighted homogeneous a weighted ordering may be used (qhweight(id); computes weights).
works only in characteristic p > 0.

Example:
 
LIB "normal.lib";
ring r  = 11,(x,y,z),wp(2,1,2);
ideal i = x*(z3 - xy4 + x2);
list nor= normalP(i); nor;
==> 
==> // 'normalP' computed a list, say nor, of two lists:
==> //    nor[1] is a list of 2 ideal(s), where each ideal nor[1][i] consists
==> // of elements g1..gk of the basering such that gj/gk generate the integr\
   al
==> // closure of the i-th component as (basering/P_i)-module in the quotient
==> // field of basering/P_i (P_i an associated prime of the input ideal);
==> //    nor[2] shows the delta-invariant of each component and of the input\
    ideal
==> // (-1 means infinite, and 0 that r/P_i is normal).
==> [1]:
==>    [1]:
==>       _[1]=1
==>    [2]:
==>       _[1]=1
==> [2]:
==>    [1]:
==>       0,0
==>    [2]:
==>       -1
//the result says that both components of i are normal, but i itself
//has infinite delta
ring s = 2,(x,y),dp;
ideal i = y*((x-y^2)^2 - x^3);
list nor = normalP(i,"withRing"); nor;
==> 
==> // 'normalP' created a list, say nor, of three lists:
==> // nor[1] resp. nor[2] are lists of 2 ring(s) resp. ideal(s)
==> // and nor[3] is a list of an intvec and an integer.
==> // To see the result, type
==>      nor;
==> // 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 an associated prime of the input ideal)
==> // and normap the normalization map from r to Ri/norid;
==> //    nor[2] is a list of 2 ideal(s), each ideal nor[2][i] consists of
==> // elements g1..gk of r such that the gj/gk generate the integral
==> // closure of r/P_i as (r/P_i)-module in the quotient field of r/P_i.
==> //    nor[3] shows the delta-invariant of each component and of the input
==> // ideal (-1 means infinite, and 0 that r/P_i is normal).
==> [1]:
==>    [1]:
==>       //   characteristic : 2
==> //   number of vars : 1
==> //        block   1 : ordering dp
==> //                  : names    x
==> //        block   2 : ordering C
==>    [2]:
==>       //   characteristic : 2
==> //   number of vars : 2
==> //        block   1 : ordering dp
==> //                  : names    T(1)
==> //        block   2 : ordering dp
==> //                  : names    y
==> //        block   3 : ordering C
==> [2]:
==>    [1]:
==>       _[1]=1
==>    [2]:
==>       _[1]=y3+xy
==>       _[2]=x2
==> [3]:
==>    [1]:
==>       0,3
==>    [2]:
==>       6
def R2  = nor[1][2]; setring R2;
norid; normap;
==> norid[1]=T(1)^4+T(1)^3*y+T(1)^2+y^2
==> norid[2]=T(1)^3+T(1)+y
==> norid[3]=T(1)^6+T(1)^5*y+T(1)^4*y^2+T(1)^3*y^3+T(1)^2+T(1)*y+y^4
==> normap[1]=T(1)^2+T(1)*y+1
==> normap[2]=y
See also: normal.


Top Back: normal Forward: normalC 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.