#### D.4.18.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 non-zero in the ring R/P_i and g_1/c,...,g_k/c generate the integral closure of R/P_i as R-module 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 K-algebra (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 Leonard-Pellikaan-Singh-Swanson 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 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. 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 R-module in the quotient field of R/P_i;
    ==>
    ==> // * 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:
    ==> // To see the result, type
    ==>      nor;
    ==>
    ==> // * nor[1] is a list of 2 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 R1;
    ==> // Ri/norid is the affine algebra of the normalization of the i-th
    ==> // 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 R-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; normalC.

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