
D.4.17.2 normalP
Procedure from library normal.lib (see normal_lib).
 Usage:
 normalP(id [,choose]); id = radical ideal, choose = optional list of
strings.
Optional parameters in list choose (can be entered in any order):
"withRing", "isPrim", "noFac", "noRed", where
 "noFac" > factorization is avoided during the computation
of the minimal associated primes.
 "isPrim" > assumes that the ideal is prime. If the assumption
does not hold, output might be wrong.
 "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 every
new module generator of the integral closure in the quotient field.
 Assume:
 The characteristic of the ground field must be positive. If the
option "isPrim" is not set, the minimal associated primes of id
are computed first and hence normalP computes the normalization of
the radical of id. If option "isPrim" is set, the ideal must be
a prime ideal otherwise the result may be wrong.
 Return:
 a list, say 'nor' of size 2 (resp. 3 if "withRing" is set).
** If option "withRing" is not set:
Only the module structure is computed:
* nor[1] is a list of ideals Ii, i=1..r, in the basering R where r
is the number of minimal associated prime ideals P_i of the input
ideal id, describing the module structure:
If Ii is given by polynomials g_1,...,g_k in R, then c:=g_k is
nonzero in the ring R/P_i and g_1/c,...,g_k/c generate the integral
closure of R/P_i as Rmodule in the quotient field of R/P_i.
* nor[2] shows the delta invariants: it is a list of an intvec
of size r, the delta invariants of the r components, and an integer,
the total delta invariant of R/id
(1 means infinite, and 0 that R/P_i resp. R/id is normal).
** If option "withRing" is set:
The ring structure is also computed, and in this case:
* 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 R/P_i, i.e. isomorphic as
Kalgebra (K the ground field) to the integral closure of R/P_i in
the field of fractions of R/P_i;
 the direct sum of the rings Ri/norid is the normalization
of R/id;
 normap gives the normalization map from R to Ri/norid.
* nor[2] gives the module generators of the normalization of R/P_i,
it is the same as nor[1] if "withRing" is not set.
* nor[3] shows the delta invariants, it is the same as nor[2] if
"withRing" is not set.
 Theory:
 normalP uses the LeonardPellikaanSinghSwanson algorithm (using the
Frobenius) cf. [A. K. Singh, I. Swanson: An algorithm for computing
the integral closure, arXiv:0901.0871].
The delta invariant of a reduced ring A is dim_K(normalization(A)/A).
For A=K[x1,...,xn]/id we call this number also the delta invariant of
id. The procedure returns the delta invariants of the components P_i
and of id.
 Note:
 To use the ith 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.
For local or mixed orderings use proc 'normal'.
If the input ideal id is weighted homogeneous a weighted ordering may
be used (qhweight(id); computes weights).
Works only in characteristic p > 0; use proc normal in char 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:
==> // To see the result, type
==> nor;
==>
==> // * nor[1] is a list of 2 ideal(s), where each ideal nor[1][i] consists
==> // of elements g1..gk of the basering R such that gj/gk generate the inte\
gral
==> // closure of R/P_i (where P_i is a min. associated prime of the input id\
eal)
==> // as Rmodule in the quotient field of R/P_i;
==>
==> // * nor[2] shows the deltainvariant 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*((xy^2)^2  x^3);
list nor = normalP(i,"withRing"); nor;
==>
==> // 'normalP' created a list, say nor, of three lists:
==> // To see the result, type
==> nor;
==>
==> // * nor[1] is a list of 2 ring(s):
==> // To access the ith 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 R1;
==> // Ri/norid is the affine algebra of the normalization of the ith
==> // component R/P_i (where P_i is a min. associated prime of the input ide\
al)
==> // 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 Rmodule in the quotient field of R/P_i.
==>
==> // * nor[3] shows the deltainvariant 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;
normalC.
