#### D.4.24.1 normal

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

Usage:
  normal(id [,choose]); id = radical ideal, choose = list of options.
  Optional parameters in list choose (can be entered in any order):
  Decomposition:
  - "equidim" -> computes first an equidimensional decomposition of the input ideal, and then the normalization of each component (default).
  - "prim" -> computes first the minimal associated primes of the input ideal, and then the normalization of each prime. (When the input ideal is not prime and the minimal associated primes are easy to compute, this method is usually faster than "equidim".)
  - "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 this assumption does not hold, the output might be wrong.
  - "noFac" -> factorization is avoided in the computation of the minimal associated primes;
  Other:
  - "useRing" -> uses the original ring ordering.
  If this option is set and if the ring ordering is not global, normal will change to a global ordering only for computing radicals and prime or equidimensional decompositions.
  If this option is not set, normal changes to dp ordering and performs all computations with respect to this ordering.
  - "withDelta" (or "wd") -> returns also the delta invariants. Not valid for options "locNormal" and "modNormal".
  If the optional parameter choose is not given or empty, only "equidim" but no other option is used.
  - list("inputJ", ideal inputJ) -> takes as initial test ideal the ideal inputJ. This option is only for use in other procedures. Using this option, the result might not be the normalization.
  (Option only valid for global algorithm.)
  - list("inputC", ideal inputC) -> takes as initial conductor the ideal inputC. This option is only for use in other procedures. Using this option, the result might not be the normalization.
  (Option only valid for global algorithm.)
  Options used for computing integral basis (over rings of two variables):
  - "normalCheck" -> checks only if the ring is normal. The output is 1 if the ring is normal and 0 if not.
  - "var1" -> uses a polynomial in the first variable as universal denominator.
  - "var2" -> uses a polynomial in the second variable as universal denominator.
  - "GBRadical" -> it computes a Groebner basis of the radical ideal computed for the test ideal.
  - "noGBRadical" -> it does not compute a Groebner basis of the radical ideal computed for the test ideal.
  - "locNormal" -> uses locNormal procedure to compute the normalization, which implements a local-to-global algorithm (for this option it is required that the ideal I is prime).
  - "modular" -> combined with "locNormal" option, it will use modNormal algorithm for the local computations.
  - "modNormal" -> uses modNormal procedure to compute the normalization, which implements a modular algorithm (for this option it is required that the ideal I is prime).
  - list("nPrimes", int n) -> parameter for modNormal. We consider n primes at a time until the result lifted to the rationals is correct modulo one additional prime. (default: n = 10)
  - "noVerification" -> if the modular approach is used (using modNormal option or modular option in locNormal), the
  result will not be verified.
  If the optional parameter choose is not given or empty, only "equidim" but no other option is used.
  - "withRing" -> the ring structure of the normalization is computed. The number of variables in the new ring is reduced as much as possible. This is the default option, except when using modNormal or locNormal options.

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

Note:
  "isPrim" should only be used if id is known to be prime.

Return:
  If "withRing" option is set, a list, say nor, of size 2 (resp. 3 with option "withDelta").
  Let R denote the basering and id the input ideal.
  * nor[1] 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 of R/P_i in its field of fractions (as affine ring); - `normap` gives the normalization map from R/id to Ri/norid for each i.
  - the direct sum of the rings Ri/norid, i=1,..r, is the normalization of R/id as affine algebra;
  * nor[2] is a list of size r with information on the normalization of the i-th component as module over the basering R:
  nor[2][i] is an ideal, say U, in R such that the integral closure of basering/P_i is generated as module over R 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 R/P_i resp. R/id is normal).
  If "withRing" option is not set, a list of an ideal U and a polynomial d such that U/d is the normalization

Theory:
  We use here a general algorithm described in [G.-M.Greuel, S.Laplagne, F.Seelisch: Normalization of Rings (2009)].
  The procedure computes the R-module structure, the algebra structure and the delta invariant of the normalization of R/id:
  The normalization of R/id is the integral closure of R/id in its total ring of fractions. It is a finitely generated R-module and nor[2] computes R-module generators of it. More precisely: If U:=nor[2][i] and c:=U[size(U)], then c is a non-zero divisor and U/c is an R-module in the total ring of fractions, the integral closure of R/P_i. Since U[size(U)]/c is equal to 1, R/P_i resp. R/id is contained in the integral closure.
  The normalization is also an affine algebra over the ground field and nor[1] presents it as such. For geometric considerations nor[1] is relevant since the variety of the ideal norid in Ri is the normalization of the variety of the ideal P_i in R.
  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. nor[3] returns the delta invariants of the components P_i and of id.

Note:
  To use the i-th ring type e.g.: `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 together with the useRing-option (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...
    ==> // 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.
    ==> // To see the list type
    ==>       nor;
    ==>
    ==> // * 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
    ==>      def R1 = nor[1][1]; setring R1; norid; normap;
    ==> // For the other rings type first (if R is the name of your base ring)
    ==>      setring R;
    ==> // and then continue as for R1.
    ==> // Ri/norid is the affine algebra of the normalization of R/P_i where
    ==> // P_i is the i-th component of a decomposition of the input ideal id
    ==> // and normap the normalization map from R to Ri/norid.
    ==>
    ==> // * nor[2] is a list of 3 ideal(s). Let ci be the last generator
    ==> // of the ideal nor[2][i]. Then the integral closure of R/P_i is
    ==> // generated as R-submodule of the total ring of fractions by
    ==> // 1/ci * nor[2][i].
    ==>
    ==> // * nor[3] is a list of an intvec of size 3 the delta invariants
    ==> // of the 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).
    nor;
    ==> [1]:
    ==>    [1]:
    ==>       // coefficients: QQ considered as a field
    ==> // number of vars : 3
    ==> //        block   1 : ordering dp
    ==> //                  : names    T(1)
    ==> //        block   2 : ordering dp
    ==> //                  : names    x y
    ==> //        block   3 : ordering C
    ==>    [2]:
    ==>       // coefficients: QQ considered as a field
    ==> // number of vars : 3
    ==> //        block   1 : ordering dp
    ==> //                  : names    T(1)
    ==> //        block   2 : ordering dp
    ==> //                  : names    x y
    ==> //        block   3 : ordering C
    ==>    [3]:
    ==>       // coefficients: QQ considered as a field
    ==> // 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.
    ==> // To see the list type
    ==>       nor;
    ==>
    ==> // * 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
    ==>      def R1 = nor[1][1]; setring R1; norid; normap;
    ==> // For the other rings type first (if R is the name of your base ring)
    ==>      setring R;
    ==> // and then continue as for R1.
    ==> // Ri/norid is the affine algebra of the normalization of R/P_i where
    ==> // P_i is the i-th component of a decomposition of the input ideal id
    ==> // and normap the normalization map from R to Ri/norid.
    ==>
    ==> // * nor[2] is a list of 1 ideal(s). Let ci be the last generator
    ==> // of the ideal nor[2][i]. Then the integral closure of R/P_i is
    ==> // generated as R-submodule of the total ring of fractions by
    ==> // 1/ci * nor[2][i].
    ==>
    ==> // * nor[3] is a list of an intvec of size 1 the delta invariants
    ==> // of the 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).
    ==> [1]:
    ==>    [1]:
    ==>       // coefficients: ZZ/2 considered as a field
    ==> // 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

See also: normalC; normalP.

User manual for Singular version 4.4.1, 2025, generated by texi2html.