bug in normalC?

[kroeker@…]

is it a bug in normalC?

ring rng = 0,(xq,xf),dp;
ideal j = xq+2, 4*xf-1;
j = radical(j);
minAssGTZ(j);
//isPrime(j);
list L = normal(j);
norTest(j,L); //= 1,1,1 (ok) 

list L = normalC(j);
norTest(j,L); //= 0,1,1 (fail) 

[kroeker@…]

ok, it is a bug in norTest and the priority is thus minor.

here is the corresponding output of normal and normalC:

> ring rng = 0,(xq,xf),dp;
> ideal j = xq+2, 4*xf-1;
> def L =normal(j);

// 'normal' created a list, say nor, of two 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].
L;

[1]:
   [1]:
      //   characteristic : 0
//   number of vars : 2
//        block   1 : ordering dp
//                  : names    xq xf
//        block   2 : ordering C
[2]:
   [1]:
      _[1]=1

> def new = L[1][1];
> setring new;
> norid;
norid[1]=4*xf-1
norid[2]=xq+2
> normap;
normap[1]=xq
normap[2]=xf


> L=normalC(j);

> def L=normalC(j);

// 'normalC' created a list, say nor, of two lists:
// To see the result, type
      nor;

// * nor[1] is a list of 1 ring(s).
// Ri/norid is the affine algebra of the normalization of r/P_i  (where P_i
// is an associated prime or an equidimensional part of the input ideal id)
// and normap the normalization map from the basering to Ri/norid;
// * nor[2] shows the delta-invariant of each component and of id
// (-1 means infinite, 0 that r/P_i resp. r/id is normal, and -2 that delta of a component was not computed).

>L;

[1]:
   [1]:
      //   characteristic : 0
//   number of vars : 1
//        block   1 : ordering dp
//                  : names    T(1)
//        block   2 : ordering C
[2]:
   [1]:
      0
   [2]:
      0
> def new = L[1][1];
> setring new;
> normap;
normap[1]=T(1)
normap[2]=0
> norid;
norid[1]=T(1)
>