|
D.4.13.3 normalC
Procedure from library normal.lib (see normal_lib).
- Usage:
- normalC(id [,choose]); id = radical ideal, choose = optional string
which may be a combination of "equidim", "prim", "withGens",
"isPrim", "noFac".
If choose is not given or empty, a default method is choosen
If choose = "prim" resp. "equidim" normalC computes a prime resp.
an equidimensional decomposition and then the normalization of each
component; if choose = "noFac" factorization is avoided in the
computation of the minimal associated primes;
if choose = "withGens" the minimal associated primes P_i of id are
computed and for each P_i, algebra generators of the integral closure
of basering/P_i are computed as elements of its quotient field;
"isPrim" disables "equidim" and "prim".
- Assume:
- The ideal must be radical, for non-radical ideals the output may
be wrong (id=radical(id); makes id radical). However, if choose =
"prim" the minimal associated primes of id are computed first
and hence normalC computes the normalization of the radical of id.
"isPrim" should only be used if id is known to be irreducible.
- Return:
- a list, say nor, of size 2 (resp. 3 if choose="withGens").
The first list nor[1] consists of r rings, where r is the number
of irreducible components if choose = "prim" (resp. >= no of
equidimenensional components if choose = "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);
- the direct sum of the rings Ri/norid is the normalization
of basering/id;
- normap gives the normalization map from basering/id to
Ri/norid for each j.
If choose="withGens", nor[2] is a list of size r of ideals Ii=
nor[2][i] in the basering, generating the integral closure of
basering/P_i in its quotient field, i=1..r, in two different ways:
- Ii is given by polynomials
g_1,...,g_k,g_k+1 such that the variables T(j) of the ring Ri
satisfy T(1)=g_1/g_k+1,..,T(k)=g_k/g_k+1. Hence the g_j/g_k+1
are algebra generators of the integral closure of basering/P_i
as sub-algebra in the quotient field of basering/P_i.
nor[2] (resp. nor[3] if choose="withGens") 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).
Return value -2 means that delta resp. delta of one of the components
is not computed (which may happen if "equidim" is given) .
|
- 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.
We use the algorithm described in [G.-M. Greuel, G. Pfister:
A SINGULAR Introduction to Commutative Algebra, 2nd Edition.
Springer Verlag (2007)].
- 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 and 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 = normalC(i);
==> // We use method 'equidim'
==>
==> // number of equidimensional components: 1
==>
==> // number of components after application of facstd: 3
==>
==> // computing the normalization of component 1
==> ----------------------------------------
==> // delta of component 1
==> 1
==>
==> // computing the normalization of component 2
==> ----------------------------------------
==> // delta of component 2
==> 1
==>
==> // computing the normalization of component 3
==> ----------------------------------------
==> // delta of component 3
==> 0
==> // Sum of delta for all components
==> 2
==> // Compute intersection multiplicities of the components
==>
==> // 'normalC' created a list, say nor, of two lists:
==> // nor[1] is a list of 3 ring(s), nor[2] a list of an intvec and an int.
==> // 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;
==> // and similair for the other rings nor[1][i];
==> // Ri/norid is the affine algebra of the normalization of the i-th compon\
ent
==> // r/P_i (where P_i is a prime or an equidimensional ideal of the input i\
deal)
==> // and normap the normalization map from the basering to Ri/norid;
==> // nor[2] shows the delta-invariant of each component and of the input
==> // ideal (-1 means infinite, -2 that delta of a component was not compute\
d).
nor;
==> [1]:
==> [1]:
==> // characteristic : 0
==> // number of vars : 1
==> // block 1 : ordering dp
==> // : names T(1)
==> // block 2 : ordering C
==> [2]:
==> // characteristic : 0
==> // number of vars : 2
==> // block 1 : ordering a
==> // : names T(1) T(2)
==> // : weights 1 0
==> // block 2 : ordering dp
==> // : names T(1) T(2)
==> // block 3 : ordering C
==> [3]:
==> // characteristic : 0
==> // number of vars : 1
==> // block 1 : ordering dp
==> // : names T(1)
==> // block 2 : ordering C
==> [2]:
==> [1]:
==> 0,1,1
==> [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(2)^2+1
==> normap[1]=-T(1)*T(2)
==> normap[2]=T(1)
printlevel = printlevel-1;
ring r = 2,(x,y,z),dp;
ideal i = z3-xy4;
nor = normalC(i); nor;
==>
==> // 'normalC' created a list, say nor, of two lists:
==> // nor[1] is a list of 1 ring(s), nor[2] a list of an intvec and an int.
==> // 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;
==> // and similair for the other rings nor[1][i];
==> // Ri/norid is the affine algebra of the normalization of the i-th compon\
ent
==> // r/P_i (where P_i is a prime or an equidimensional ideal of the input i\
deal)
==> // and normap the normalization map from the basering to Ri/norid;
==> // nor[2] shows the delta-invariant of each component and of the input
==> // ideal (-1 means infinite, -2 that delta of a component was not compute\
d).
==> [1]:
==> [1]:
==> // characteristic : 2
==> // number of vars : 3
==> // block 1 : ordering dp
==> // : names T(1) T(2) T(3)
==> // block 2 : ordering C
==> [2]:
==> [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(3)^3+T(1)*T(2)
==> normap[1]=T(1)
==> normap[2]=T(2)
==> normap[3]=T(2)*T(3)
setring r;
nor = normalC(i, "withGens", "prim"); // a different algorithm
==> // ** redefining n2 **
==> // ** redefining n3 **
==> // ** redefining V **
==>
==> // 'normalC' created a list, say nor, of three lists:
==> // nor[1] resp. nor[2] are lists of 1 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 1 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 sub-algebra in the quotient field of r/P_i, with
==> // gj/gk being mapped by normap to the j-th variable of Ri;
==> // nor[3] shows the delta-invariant of each component and of the input
==> // ideal (-1 means infinite, and 0 that r/P_i resp. r/input is normal).
nor;
==> [1]:
==> [1]:
==> // characteristic : 2
==> // number of vars : 6
==> // block 1 : ordering dp
==> // : names X(1) X(2) X(3) X(4) T(2) T(3)
==> // block 2 : ordering C
==> [2]:
==> [1]:
==> _[1]=x2y3
==> _[2]=z3
==> _[3]=xy3z
==> _[4]=xy2z2
==> _[5]=xyz2
==> _[6]=xy2z
==> _[7]=xy3
==> [3]:
==> [1]:
==> -1
==> [2]:
==> -1
|
|