source: git/Singular/LIB/normal.lib @ ecd512

spielwiese
Last change on this file since ecd512 was ecd512, checked in by Olaf Bachmann <obachman@…>, 26 years ago
* new bug fixes git-svn-id: file:///usr/local/Singular/svn/trunk@2379 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 35.7 KB
Line 
1///////////////////////////////////////////////////////////////////////////////
2// normal.lib
3// algorithms for computing the normalization based on
4// the ideas of De Jong,Vasconcelos
5// written by Gert-Martin Greuel and Gerhard Pfister
6///////////////////////////////////////////////////////////////////////////////
7
8version="$Id: normal.lib,v 1.9 1998-07-28 10:35:55 obachman Exp $";
9info="
10LIBRARY: normal.lib: PROCEDURE FOR NORMALIZATION (I)
11
12  normal(ideal I)
13  // computes a set of rings such that their product is the
14  // normalization of the reduced basering/I
15";
16
17LIB "sing.lib";
18LIB "primdec.lib";
19LIB "elim.lib";
20LIB "presolve.lib";
21///////////////////////////////////////////////////////////////////////////////
22
23proc isR_HomJR (list Li)
24"USAGE:   isR_HomJR (Li);  Li = list: ideal SBid, ideal J, poly p
25COMPUTE: module Hom_R(J,R) = R:J and compare with R
26ASSUME:  R    = P/SBid,  P = basering
27         SBid = standard basis of an ideal in P,
28         J    = ideal in P containing the polynomial p,
29         p    = nonzero divisor of R
30RETURN:  1 if R = R:J, 0 if not
31EXAMPLE: example isR_HomJR;  shows an example
32"
33{
34   int n, ii;
35 def P = basering;
36   ideal SBid = Li[1];
37   ideal J = Li[2];
38   poly p = Li[3];
39   attrib(SBid,"isSB",1);
40   attrib(p,"isSB",1);
41 qring R    = SBid;
42   ideal J  = fetch(P,J);
43   poly p   = fetch(P,p);
44   ideal f  = quotient(p,J);
45   ideal lp = std(p);
46   n=1;
47   for (ii=1; ii<=size(f); ii++ )
48   {
49      if ( reduce(f[ii],lp) != 0)
50      { n = 0; break; }
51   }
52   return (n);
53 //?spaeter hier einen Test ob Hom(I,R) = Hom(I,I)?
54}
55example
56{"EXAMPLE:";  echo = 2;
57  ring r   = 0,(x,y,z),dp;
58  ideal id = y7-x5+z2;
59  ideal J  = x3,y+z;
60  poly p   = xy;
61  list Li  = std(id),J,p;
62  isR_HomJR (Li);
63
64  ring s   = 0,(t,x,y),dp;
65  ideal id = x2-y2*(y-t);
66  ideal J  = jacob(id);
67  poly p   = J[1];
68  list Li  = std(id),J,p;
69  isR_HomJR (Li);
70}
71///////////////////////////////////////////////////////////////////////////////
72
73proc extraweight (list # )
74"USAGE:   extraweight (P); P=name of an existing ring (true name, not a string)
75RETURN:  intvec, size=nvars(P), consisting of the weights of the variables of P
76NOTE:    This is useful when enlarging P but keeping the weights of the old
77         variables
78EXAMPLE: example extraweight;  shows an example
79"
80{
81   int ii,q,fi,fo,fia;
82   intvec rw,nw;
83   string os;
84   def P = #[1];
85   string osP = ordstr(P);
86   fo  = 1;
87//------------------------- find weights in ordstr(P) -------------------------
88   fi  = find(osP,"(",fo);
89   fia = find(osP,"a",fo)+find(osP,"w",fo)+find(osP,"W",fo);
90   while ( fia )
91   {
92      os = osP[fi+1,find(osP,")",fi)-fi-1];
93      if( find(os,",") )
94      {
95         execute "nw = "+os+";";
96         if( size(nw) > ii )
97         {
98             rw = rw,nw[ii+1..size(nw)];
99         }
100         else  {  ii = ii - size(nw); }
101
102         if( find(osP[1,fi],"a",fo) ) { ii = size(nw); }
103      }
104      else
105      {
106         execute "q = "+os+";";
107         if( q > ii )
108         {
109            nw = 0; nw[q-ii] = 0;
110            nw = nw + 1;          //creates an intvec 1,...,1 of length q-ii
111            rw = rw,nw;
112         }
113         else { ii = ii - q; }
114      }
115      fo  = fi+1;
116      fi  = find(osP,"(",fo);
117      fia = find(osP,"a",fo)+find(osP,"w",fo)+find(osP,"W",fo);
118   }
119//-------------- adjust weight vector to length = nvars(P)  -------------------
120   if( fo > 1 )
121   {                                            // case when weights were found
122      rw = rw[2..size(rw)];
123      if( size(rw) > nvars(P) )
124      {
125         rw = rw[1..nvars(P)];
126      }
127      if( size(rw) < nvars(P) )
128      {
129         nw=0; nw[nvars(P)-size(rw)]=0; nw=nw+1; rw=rw,nw;
130      }
131   }
132   else
133   {                                         // case when no weights were found
134      rw[nvars(P)]= 0; rw=rw+1;
135   }
136   return(rw);
137}
138example
139{"EXAMPLE:";  echo = 2;
140  ring r0 = 0,(x,y,z),dp;
141  extraweight(r0);
142  ring r1 = 0,x(1..5),(ds(3),wp(2,3));
143  extraweight(r1);
144  ring r2 = 0,x(1..5),(a(1,2,3,0),dp);
145  extraweight(r2);
146  ring r3 = 0,x(1..10),(a(1..5),dp(5),a(10..13),Wp(5..9));
147  extraweight(r3);
148  // an example for enlarging the ring:
149  intvec v = 6,2,3,4,5;
150  ring R = 0,x(1..10),(a(extraweight(r1),v),dp);
151  ordstr(R);
152}
153///////////////////////////////////////////////////////////////////////////////
154
155proc HomJJ (list Li,list #)
156"USAGE:   HomJJ (Li);  Li = list: SBid,id,J,poly p
157ASSUME:  R    = P/id,  P = basering, a polynomial ring, id an ideal of P,
158         SBid = standard basis of id,
159         J    = ideal of P containing the polynomial p,
160         p    = nonzero divisor of R
161COMPUTE: Endomorphism ring End_R(J)=Hom_R(J,J) with its ring structure where
162         R is the quotient ring of P modulo the standard basis SBid
163RETURN:  a list of two objects
164         _[1]: a polynomial ring, containing two ideals, 'endid' and 'endphi'
165               s.t. _[1]/endid = Hom_R(J,J) and
166               endphi describes the canonical map R -> Hom_R(J,J)
167         _[2]: an integer which is 1 if phi is an isomorphism, 0 if not
168EXAMPLE: example HomJJ;  shows an example
169"
170{
171//---------- initialisation ---------------------------------------------------
172
173   int isIso,isPr,isCo,isRe,isEq,ii,jj,q,y;
174   intvec rw,rw1;
175   list L;
176   if( size(#) >=1 )
177   {
178      if( typeof(#[1]) == "int" ) { y = #[1]; }
179   }
180 def P = basering;
181   ideal SBid, id, J = Li[1], Li[2], Li[3];
182   poly p = Li[4];
183   attrib(SBid,"isSB",1);
184   int homo = homog(Li[2]);               //is 1 if id is homogeneous, 0 if not
185
186//---- set attributes for special cases where algorithm can be simplified -----
187   if( homo==1 )
188   {
189      rw = extraweight(P);
190   }
191   if( typeof(attrib(id,"isPrim"))=="int" )
192   {
193      if(attrib(id,"isPrim")==1)  { isPr=1; }
194   }
195   if( typeof(attrib(id,"isIsolatedSingularity"))=="int" )
196   {
197      if(attrib(id,"isIsolatedSingularity")==1) { isIso=1; }
198   }
199   if( typeof(attrib(id,"isCohenMacaulay"))=="int" )
200   {
201      if(attrib(id,"isCohenMacaulay")==1) { isCo=1; }
202   }
203   if( typeof(attrib(id,"isRegInCodim2"))=="int" )
204   {
205      if(attrib(id,"isRegInCodim2")==1) { isRe=1; }
206   }
207   if( typeof(attrib(id,"isEquidimensional"))=="int" )
208   {
209      if(attrib(id,"isEquidimensional")==1) { isEq=1; }
210   }
211//-------------------------- go to quotient ring ------------------------------
212 qring R  = SBid;
213   ideal id = fetch(P,id);
214   ideal J  = fetch(P,J);
215   poly p   = fetch(P,p);
216   ideal f,rf,f2;
217   module syzf;
218
219//---------- computation of p*Hom(J,J) as R-ideal -----------------------------
220   f  = quotient(p*J,J);
221   if(y==1)
222   {
223      "the module Hom(rad(J),rad(J)) presented by the values on";
224      "the non-zerodivisor";
225      "  ";
226      p;
227      " ";
228      f;
229   }
230   f2 = std(p);
231
232   if(isIso==0)
233   {
234     ideal f1=std(f);
235     attrib(f1,"isSB",1);
236    // if( codim(f1,f2) >= 0 )
237    // {
238    //  dbprint(printlevel-voice+3,"// dimension of non-normal locus is zero");
239    //    isIso=1;
240    // }
241  }
242//---------- Test: Hom(J,J) == R ?, if yes, go home ---------------------------
243   rf = interred(reduce(f,f2));       // represents p*Hom(J,J)/p*R = Hom(J,J)/R
244   if ( size(rf) == 0 )
245   {
246      if ( homog(f) && find(ordstr(basering),"s")==0 )
247      {
248         ring newR1 = char(P),(X(1..nvars(P))),(a(rw),dp);
249      }
250      else
251      {
252         ring newR1 = char(P),(X(1..nvars(P))),dp;
253      }
254      ideal endphi = maxideal(1);
255      ideal endid = fetch(P,id);
256      L=substpart(endid,endphi,homo,rw);
257      def lastRing=L[1];
258      setring lastRing;
259
260      attrib(endid,"isCohenMacaulay",isCo);
261      attrib(endid,"isPrim",isPr);
262      attrib(endid,"isIsolatedSingularity",isIso);
263      attrib(endid,"isRegInCodim2",isRe);
264      attrib(endid,"isEqudimensional",isEq);
265      attrib(endid,"isCompleteIntersection",0);
266      attrib(endid,"isRad",0);
267//      export endid;
268//      export endphi;
269//      L = newR1;
270      L=lastRing;
271      L = insert(L,1,1);
272      dbprint(printlevel-voice+3,"// case R = Hom(J,J)");
273      if(y==1)
274      {
275         "R=Hom(rad(J),rad(J))";
276         "   ";
277         lastRing;
278         "   ";
279         "the new ideal";
280         endid;
281         "   ";
282         "the old ring";
283         "   ";
284         P;
285         "   ";
286         "the old ideal";
287         "   ";
288         setring P;
289         id;
290         "   ";
291         setring lastRing;
292         "the map";
293         "   ";
294         endphi;
295         "   ";
296         pause;
297      }
298      setring P;
299      return(L);
300   }
301   if(y==1)
302   {
303      "R is not equal to Hom(rad(J),rad(J)), we have to try again";
304      pause;
305   }
306//---------- Hom(J,j) != R: create new ring and map form old ring -------------
307// the ring newR1/SBid+syzf will be isomorphic to Hom(J,J) as R-module
308
309   f = mstd(f)[2];                                   // minimizes f (partially)
310   f = p,rf;          // generates pJ:J mod(p), i.e. p*Hom(J,J)/p*R as R-module
311   q = size(f);
312   syzf = syz(f);
313
314   if ( homo==1 )
315   {
316      rw1 = rw,0;
317      for ( ii=2; ii<=q; ii++ )
318      {
319         rw  = rw, deg(f[ii])-deg(f[1]);
320         rw1 = rw1, deg(f[ii])-deg(f[1]);
321      }
322      ring newR1 = char(R),(X(1..nvars(R)),T(1..q)),(a(rw1),dp);
323   }
324   else
325   {
326      ring newR1 = char(R),(X(1..nvars(R)),T(1..q)),dp;
327   }
328
329   map psi1 = P,maxideal(1);
330   ideal SBid = psi1(SBid);
331   attrib(SBid,"isSB",1);
332
333 qring newR = std(SBid);
334   map psi = R,ideal(X(1..nvars(R)));
335   ideal id = psi(id);
336   ideal f = psi(f);
337   module syzf = psi(syzf);
338   ideal pf,Lin,Quad,Q;
339   matrix T,A;
340   list L1;
341
342//---------- computation of Hom(J,J) as ring ----------------------------------
343// determine kernel of: R[T1,...,Tq] -> J:J >-> R[1/p]=R[t]/(t*p-1),
344// Ti -> fi/p -> t*fi (p=f1=f[1]), to get ring structure. This is of course
345// the same as the kernel of R[T1,...,Tq] -> pJ:J >-> R, Ti -> fi.
346// It is a fact, that the kernel is generated by the linear and the quadratic
347// relations
348
349   pf = f[1]*f;
350   T = matrix(ideal(T(1..q)),1,q);
351   Lin = ideal(T*syzf);
352   if(y==1)
353   {
354      "the ring structure of Hom(rad(J),rad(J)) as R-algebra";
355      " ";
356      "the linear relations";
357      " ";
358      Lin;
359      "   ";
360   }
361   for (ii=2; ii<=q; ii++ )
362   {
363      for ( jj=2; jj<=ii; jj++ )
364      {
365         A = lift(pf,f[ii]*f[jj]);
366         Quad = Quad, ideal(T(jj)*T(ii) - T*A);          // quadratic relations
367      }
368   }
369   if(y==1)
370   {
371      "the quadratic relations";
372      "   ";
373      interred(Quad);
374      pause;
375   }
376   Q = Lin+Quad;
377   Q = subst(Q,T(1),1);
378   Q = interred(reduce(Q,std(0)));
379//---------- reduce number of variables by substitution, if possible ----------
380   if (homo==1)
381   {
382      ring newRing = char(R),(X(1..nvars(R)),T(2..q)),(a(rw),dp);
383   }
384   else
385   {
386      ring newRing = char(R),(X(1..nvars(R)),T(2..q)),dp;
387   }
388
389   ideal endid  = imap(newR,id)+imap(newR,Q);
390   ideal endphi = ideal(X(1..nvars(R)));
391
392   L=substpart(endid,endphi,homo,rw);
393   def lastRing=L[1];
394   setring lastRing;
395   attrib(endid,"isCohenMacaulay",isCo);
396   attrib(endid,"isPrim",isPr);
397   attrib(endid,"isIsolatedSingularity",isIso);
398   attrib(endid,"isRegInCodim2",isRe);
399   attrib(endid,"isEquidimensional",isEq);
400   attrib(endid,"isCompleteIntersection",0);
401   attrib(endid,"isRad",0);
402  // export(endid);
403  // export(endphi);
404           if(y==1)
405   {
406      "the new ring after reduction of the number of variables";
407      "   ";
408      lastRing;
409      "   ";
410      "the new ideal";
411      endid;
412      "   ";
413      "the old ring";
414      "   ";
415      P;
416      "   ";
417      "the old ideal";
418      "   ";
419      setring P;
420      id;
421      "   ";
422      setring lastRing;
423      "the map";
424      "   ";
425      endphi;
426      "   ";
427      pause;
428   }
429   L = lastRing;
430   L = insert(L,0,1);
431   return(L);
432}
433example
434{"EXAMPLE:";  echo = 2;
435  ring r   = 0,(x,y),wp(2,3);
436  ideal id = y^2-x^3;
437  ideal J  = x,y;
438  poly p   = x;
439  list Li = std(id),id,J,p;
440  list L   = HomJJ(Li);
441  def end = L[1];      // defines ring L[1], containing ideals endid and endphi
442  setring end;         // makes end the basering
443  end;
444  endid;               // end/endid is isomorphic to End(r/id) as ring
445  map psi = r,endphi;  // defines the canonical map r/id -> End(r/id)
446  psi;
447
448  ring r   = 32003,(x,y,z),dp;
449  ideal id = x2-xy-xz+yz;
450  ideal J =y-z,x-z;
451  poly p = x+16001y+16001z;
452  list Li = std(id),id,J,p;
453  list L   = HomJJ(Li,0);
454  def end = L[1];      // defines ring L[1], containing ideals endid and endphi
455  setring end;         // makes end the basering
456  end;
457  endid;               // end/endid is isomorphic to End(r/id) as ring
458
459}
460
461///////////////////////////////////////////////////////////////////////////////
462proc normal(ideal id, list #)
463"USAGE:   normal(i,choose);  i ideal,choose empty or 1
464         in case you choose 1 the factorizing Buchberger algorithm
465         is not used which is sometimes more efficient
466RETURN:  a list of rings L=R1,...,Rk, in each Ri are two ideals
467         Si,Mi such that the product of Ri/Mi is the normalization
468         Si is a standardbasis of Mi
469NOTE:    to use the rings: def r=L[i];setring r;
470EXAMPLE: example normal; shows an example
471"
472{
473   int i,j,y;
474   list result,prim,keepresult;
475
476   if(size(#)==0)
477   {
478      prim[1]=id;
479      if( typeof(attrib(id,"isEquidimensional"))=="int" )
480      {
481        if(attrib(id,"isEquidimensional")==1)
482        {
483           attrib(prim[1],"isEquidimensional",1);
484        }
485      }
486      else
487      {
488         attrib(prim[1],"isEquidimensional",0);
489      }
490      if( typeof(attrib(id,"isCompleteIntersection"))=="int" )
491      {
492        if(attrib(id,"isCompleteIntersection")==1)
493        {
494           attrib(prim[1],"isCompleteIntersection",1);
495        }
496      }
497      else
498      {
499         attrib(prim[1],"isCompleteIntersection",0);
500      }
501
502      if( typeof(attrib(id,"isPrim"))=="int" )
503      {
504        if(attrib(id,"isPrim")==1)  {attrib(prim[1],"isPrim",1); }
505      }
506      else
507      {
508         attrib(prim[1],"isPrim",0);
509      }
510      if( typeof(attrib(id,"isIsolatedSingularity"))=="int" )
511      {
512         if(attrib(id,"isIsolatedSingularity")==1)
513             {attrib(prim[1],"isIsolatedSingularity",1); }
514      }
515      else
516      {
517         attrib(prim[1],"isIsolatedSingularity",0);
518      }
519      if( typeof(attrib(id,"isCohenMacaulay"))=="int" )
520      {
521         if(attrib(id,"isCohenMacaulay")==1)
522           { attrib(prim[1],"isCohenMacaulay",1); }
523      }
524      else
525      {
526         attrib(prim[1],"isCohenMacaulay",0);
527      }
528      if( typeof(attrib(id,"isRegInCodim2"))=="int" )
529      {
530         if(attrib(id,"isRegInCodim2")==1)
531         { attrib(prim[1],"isRegInCodim2",1);}
532      }
533      else
534      {
535          attrib(prim[1],"isRegInCodim2",0);
536      }
537      return(normalizationPrimes(prim[1],maxideal(1)));
538   }
539   else
540   {
541      if(#[1]==0)
542      {
543         prim=minAssPrimes(id);
544      }
545      else
546      {
547         prim=minAssPrimes(id,1);
548      }
549
550      if(y==1)
551      {
552         "we have ";size(prim);"components";
553      }
554      for(i=1;i<=size(prim);i++)
555      {
556         if(y==1)
557         {
558            "we are in loop";i;
559         }
560         attrib(prim[i],"isCohenMacaulay",0);
561         attrib(prim[i],"isPrim",1);
562         attrib(prim[i],"isRegInCodim2",0);
563         attrib(prim[i],"isIsolatedSingularity",0);
564         attrib(prim[i],"isEquidimensional",0);
565         attrib(prim[i],"isCompleteIntersection",0);
566
567         if( typeof(attrib(id,"isEquidimensional"))=="int" )
568         {
569           if(attrib(id,"isEquidimensional")==1)
570           {
571              attrib(prim[i],"isEquidimensional",1);
572           }
573         }
574         else
575         {
576            attrib(prim[i],"isEquidimensional",0);
577         }
578         if( typeof(attrib(id,"isIsolatedSingularity"))=="int" )
579         {
580            if(attrib(id,"isIsolatedSingularity")==1)
581             {attrib(prim[i],"isIsolatedSingularity",1); }
582         }
583         else
584         {
585            attrib(prim[i],"isIsolatedSingularity",0);
586         }
587
588         keepresult=normalizationPrimes(prim[i],maxideal(1));
589         for(j=1;j<=size(keepresult);j++)
590         {
591            result=insert(result,keepresult[j]);
592         }
593      }
594      return(result);
595   }
596}
597example
598{ "EXAMPLE:"; echo = 2;
599   ring  r = 0,(x,y,z),dp;
600
601}
602
603
604proc normalizationPrimes(ideal i,ideal ihp, list #)
605"USAGE:   normalizationPrimes(i);  i prime ideal
606RETURN:  a list of one ring L=R, in  R are two ideals
607         S,M such that R/M is the normalization
608         S is a standardbasis of M
609NOTE:    to use the ring: def r=L[1];setring r;
610EXAMPLE: example normalizationPrimes; shows an example
611"
612{
613   int y;
614   if(y==1)
615   {
616      "START one normalization loop with the ideal";
617      "        ";
618      i;
619      "        ";
620      basering;
621      "        ";
622      pause;
623   }
624
625   def BAS=basering;
626   list result,keepresult1,keepresult2;
627   ideal J,SB,MB,KK;
628   int depth,lauf,prdim;
629   int ti=timer;
630   
631   if(size(i)==0)
632   {
633      if(y==1)
634      {
635          "the ideal was the zero-ideal";
636      }
637         execute "ring newR7="+charstr(basering)+",("+varstr(basering)+"),("
638                      +ordstr(basering)+");";
639         ideal KK=ideal(0);
640         ideal PP=fetch(BAS,ihp);
641         export PP;
642         export KK;
643         result=newR7;
644         setring BAS;
645         return(result);
646
647   }
648
649   if(y==1)
650   {
651      "                                  ";
652      "                                  ";
653      " SB-computation of the input ideal";
654      "                                  ";
655   }
656   list SM=mstd(i);
657
658   if(y==1)
659   {
660      " the dimension is                 ";
661      dim(SM[1]);
662      "                                  ";
663   }
664
665   if(size(#)>0)
666   {
667      list JM=#[1],#[1];
668      attrib(JM[1],"isSB",1);
669      if( typeof(attrib(#[1],"isRad"))!="int" )
670      {
671         attrib(JM[2],"isRad",0);
672      }
673   }
674
675   if(attrib(i,"isPrim")==1)
676   {
677      attrib(SM[2],"isPrim",1);
678   }
679   else
680   {
681      attrib(SM[2],"isPrim",0);
682   }
683   if(attrib(i,"isIsolatedSingularity")==1)
684   {
685      attrib(SM[2],"isIsolatedSingularity",1);
686   }
687   else
688   {
689      attrib(SM[2],"isIsolatedSingularity",0);
690   }
691   if(attrib(i,"isCohenMacaulay")==1)
692   {
693      attrib(SM[2],"isCohenMacaulay",1);
694   }
695   else
696   {
697      attrib(SM[2],"isCohenMacaulay",0);
698   }
699   if(attrib(i,"isRegInCodim2")==1)
700   {
701      attrib(SM[2],"isRegInCodim2",1);
702   }
703   else
704   {
705      attrib(SM[2],"isRegInCodim2",0);
706   }
707    if(attrib(i,"isEquidimensional")==1)
708   {
709      attrib(SM[2],"isEquidimensional",1);
710   }
711   else
712   {
713      attrib(SM[2],"isEquidimensional",0);
714   }
715    if(attrib(i,"isCompleteIntersection")==1)
716   {
717      attrib(SM[2],"isCompleteIntersection",1);
718   }
719   else
720   {
721      attrib(SM[2],"isCompleteIntersection",0);
722   }
723
724   //the smooth case
725   if(size(#)>0)
726   {
727      if(dim(JM[1])==-1)
728      {
729         if(y==1)
730         {
731            "the ideal was smooth";
732         }
733         MB=SM[2];
734         intvec rw;
735         list LL=substpart(MB,ihp,0,rw);
736         def newR6=LL[1];
737         setring newR6;
738         ideal KK=endid;
739         ideal PP=endphi;
740//        execute "ring newR6="+charstr(basering)+",("+varstr(basering)+"),("
741//                      +ordstr(basering)+");";
742//         ideal KK=fetch(BAS,MB);
743//         ideal PP=fetch(BAS,ihp);
744         export PP;
745         export KK;
746         result=newR6;
747         setring BAS;
748         return(result);
749     }
750   }
751
752   //the zero-dimensional case
753   if((dim(SM[1])==0)&&(homog(SM[2])==1))
754   {
755      if(y==1)
756      {
757         "the ideal was zero-dimensional and homogeneous";
758      }
759      MB=maxideal(1);
760      intvec rw;
761      list LL=substpart(MB,ihp,0,rw);
762      def newR5=LL[1];
763      setring newR5;
764      ideal KK=endid;
765      ideal PP=endphi;
766//      execute "ring newR5="+charstr(basering)+",("+varstr(basering)+"),("
767//                      +ordstr(basering)+");";
768//      ideal KK=fetch(BAS,MB);
769//      ideal PP=fetch(BAS,ihp);
770      export PP;
771      export KK;
772      result=newR5;
773      setring BAS;
774      return(result);
775   }
776
777   //the one-dimensional case
778   //in this case it is a line because
779   //it is irreducible and homogeneous
780   if((dim(SM[1])==1)&&(attrib(SM[2],"isPrim")==1)
781        &&(homog(SM[2])==1))
782   {
783      if(y==1)
784      {
785         "the ideal defines a line";
786      }
787      MB=SM[2];
788      intvec rw;
789      list LL=substpart(MB,ihp,0,rw);
790      def newR4=LL[1];
791      setring newR4;
792      ideal KK=endid;
793      ideal PP=endphi;
794//      execute "ring newR4="+charstr(basering)+",("+varstr(basering)+"),("
795//                      +ordstr(basering)+");";
796//      ideal KK=fetch(BAS,MB);
797//      ideal PP=fetch(BAS,ihp);
798      export PP;
799      export KK;
800      result=newR4;
801      setring BAS;
802      return(result);
803   }
804
805   //the higher dimensional case
806   //we test first of all CohenMacaulay and
807   //complete intersection
808   if(((size(SM[2])+dim(SM[1]))==nvars(basering))&&(homog(SM[2])==1))
809   {
810      //test for complete intersection
811      attrib(SM[2],"isCohenMacaulay",1);
812      attrib(SM[2],"isCompleteIntersection",1);
813      attrib(SM[2],"isEquidimensional",1);
814      if(y==1)
815      {
816         "it is a complete Intersection";
817      }
818   }
819//   if(attrib(i,"isIsolatedSingularity")==0)
820//   {
821//      list L=sres(SM[2],0);
822//      prdim=ncols(betti(L))-1;
823//      depth=nvars(basering)-prdim;
824//   }
825
826  // if(attrib(SM[2],"isCohenMacaulay")==0)
827  // {
828  //    test for CohenMacaulay
829  //    if((dim(SM[1]))==depth)
830  //    {
831  //    attrib(SM[2],"isCohenMacaulay",1);
832  //    "it is CohenMacaulay";
833  //    }
834  // }
835
836   //compute the singular locus+lower dimensional components
837   if(((attrib(SM[2],"isIsolatedSingularity")==0)||(homog(SM[2])==0))
838        &&(size(#)==0))
839   {
840
841      J=minor(jacob(SM[2]),nvars(basering)-dim(SM[1]));
842      //ti=timer;
843      if(y==1)
844      {
845         "SB of singular locus will be computed";
846      }
847      ideal sin=J+SM[2];
848
849    //kills the embeded components
850//    if(homog(SM[2])==1)
851//    {
852//       sin=sat(sin,maxideal(1))[1];
853//    }
854
855      list JM=mstd(sin);
856      if(y==1)
857      {
858         "                                  ";
859         "the dimension of the singular locus is";
860         dim(JM[1]);
861         "                                  ";
862      }
863
864      attrib(JM[2],"isRad",0);
865      //   timer-ti;
866      attrib(JM[1],"isSB",1);
867      if(dim(JM[1])==-1)
868      {
869         if(y==1)
870         {
871            "it is smooth";
872         }
873         MB=SM[2];
874         intvec rw;
875         list LL=substpart(MB,ihp,0,rw);
876//         execute "ring newR3="+charstr(basering)+",("+varstr(basering)+"),("
877//                      +ordstr(basering)+");";
878         def newR3=LL[1];
879         setring newR3;
880//         ideal KK=fetch(BAS,MB);
881//         ideal PP=fetch(BAS,ihp);
882         ideal KK=endid;
883         ideal PP=endphi;
884         export PP;
885         export KK;
886         result=newR3;
887         setring BAS;
888         return(result);
889      }
890      if(dim(JM[1])==0)
891      {
892         attrib(SM[2],"isIsolatedSingularity",1);
893      }
894      if(dim(JM[1])<=nvars(basering)-2)
895      {
896         attrib(SM[2],"isRegInCodim2",1);
897      }
898   }
899   else
900   {
901     if(size(#)==0)
902     {
903        list JM=maxideal(1),maxideal(1);
904        attrib(JM[1],"isSB",1);
905        attrib(SM[2],"isRegInCodim2",1);
906     }
907   }
908   //if it is an isolated singularity things are easier
909   if((dim(JM[1])==0)&&(homog(SM[2])==1))
910   {
911      attrib(SM[2],"isIsolatedSingularity",1);
912      ideal SL=simplify(reduce(maxideal(1),SM[1]),2);
913      ideal Ann=quotient(SM[2],SL[1]);
914      ideal qAnn=simplify(reduce(Ann,SM[1]),2);
915
916      if(size(qAnn)==0)
917      {
918         if(y==1)
919         {
920            "                                  ";
921            "the ideal rad(J):                 ";
922            "                                  ";
923            maxideal(1);
924            "                                  ";
925            "                                  ";
926         }
927         //again test for normality
928         //Hom(I,R)=R
929         list RR;
930  //       list RR=SM[1],maxideal(1),SL[1];
931  //       "test with Hom(I,R)";
932  //       ti=timer;
933  //       if(isR_HomJR(RR)==1)
934  //       {
935  //         "it was normal";
936  //          timer-ti;
937  //          SB=SM[1];
938  //          SM=SM[2];
939  //          export SB,MB;
940  //          result=BAS;
941  //          return(result);
942  //       }
943  //       timer-ti;
944         RR=SM[1],SM[2],maxideal(1),SL[1];
945         ti=timer;
946         RR=HomJJ(RR,y);
947   //      timer-ti;
948         if(RR[2]==0)
949         {
950            def newR=RR[1];
951            setring newR;
952            map psi=BAS,endphi;
953         //   ti=timer;
954            list tluser=normalizationPrimes(endid,psi(ihp));
955
956        //    timer-ti;
957            setring BAS;
958            return(tluser);
959         }
960         MB=SM[2];
961         execute "ring newR7="+charstr(basering)+",("+varstr(basering)+"),("
962                      +ordstr(basering)+");";
963         ideal KK=fetch(BAS,MB);
964         ideal PP=fetch(BAS,ihp);
965         export PP;
966         export KK;
967         result=newR7;
968         setring BAS;
969         return(result);
970
971       }
972       else
973       {
974          ideal id=qAnn+SM[2];
975
976          attrib(id,"isCohenMacaulay",0);
977          attrib(id,"isPrim",0);
978          attrib(id,"isIsolatedSingularity",1);
979          attrib(id,"isRegInCodim2",0);
980          attrib(id,"isCompleteIntersection",0);
981          attrib(id,"isEquidimensional",0);
982
983          keepresult1=normalizationPrimes(id,ihp);
984          ideal id1=quotient(SM[2],Ann)+SM[2];
985//          evtl. qAnn nehmen
986//          ideal id=SL[1]+SM[2];
987
988          attrib(id1,"isCohenMacaulay",0);
989          attrib(id1,"isPrim",0);
990          attrib(id1,"isIsolatedSingularity",1);
991          attrib(id1,"isRegInCodim2",0);
992          attrib(id1,"isCompleteIntersection",0);
993          attrib(id1,"isEquidimensional",0);
994
995          keepresult2=normalizationPrimes(id1,ihp);
996
997          for(lauf=1;lauf<=size(keepresult2);lauf++)
998          {
999             keepresult1=insert(keepresult1,keepresult2[lauf]);
1000          }
1001          return(keepresult1);
1002       }
1003   }
1004
1005   //test for non-normality
1006   //Hom(I,I)<>R
1007   //we can use Hom(I,I) to continue
1008
1009   ideal SL=simplify(reduce(JM[2],SM[1]),2);
1010   ideal Ann=quotient(SM[2],SL[1]);
1011   ideal qAnn=simplify(reduce(Ann,SM[1]),2);
1012
1013   if(size(qAnn)==0)
1014   {
1015      list RR;
1016 //      "test with Hom(I,I) before the radical computation";
1017        //again test for normality
1018        //Hom(I,R)=R
1019 //     list RR=SM[1],JM[2],SL[1];
1020 //     "test with Hom(I,R)";
1021 //     ti=timer;
1022 //     if(isR_HomJR(RR)==1)
1023 //     {
1024 //      "it was normal";
1025 //        timer-ti;
1026 //        SB=SM[1];
1027 //        SM=SM[2];
1028 //        export SB,MB;
1029 //        result=BAS;
1030 //        return(result);
1031 //     }
1032 //     timer-ti;
1033
1034 //     list  RR=SM[1],SM[2],JM[2],SL[1];
1035 //     ti=timer;
1036      list RS;
1037 //   list RS=HomJJ(RR);
1038 //   timer-ti;
1039 //     if(RS[2]==0)
1040 //     {
1041 //        "Hom(I,I) was sucessfull without radical";
1042 //        def newR=RS[1];
1043 //        setring newR;
1044 //        list tluser=normalizationPrimes(SM);
1045 //        setring BAS;
1046 //        return(tluser);
1047 //     }
1048
1049      //now we have to compute the radical
1050      if(y==1)
1051      {
1052         "radical computation";
1053      }
1054//      ti=timer;
1055
1056
1057      if((attrib(JM[2],"isRad")==0)&&(attrib(SM[2],"isEquidimensional")==0))
1058      {
1059           //J=radical(JM[2]);
1060          J=radical(SM[2]+ideal(SL[1]));
1061
1062          // evtl. test auf J=SM[2]+ideal(SL[1]) dann schon normal
1063      }
1064      if((attrib(JM[2],"isRad")==0)&&(attrib(SM[2],"isEquidimensional")==1))
1065      {
1066          ideal JJ=SM[2]+ideal(SL[1]);
1067         // evtl. test auf J=SM[2]+ideal(SL[1]) dann schon normal
1068          if(attrib(SM[2],"isCompleteIntersection")==0)
1069          {
1070             J=equiRadical(JM[2]);
1071             //J=equiRadical(JJ);
1072          }
1073          else
1074          {
1075             //J=radical(JM[2]);
1076             J=quotient(JJ,minor(jacob(JJ),size(JJ)));
1077          }
1078      }
1079//    timer-ti;
1080
1081      JM=J,J;
1082
1083      //evtl. fuer SL[1] anderen Nichtnullteiler aus J waehlen
1084      // SL=simplify(reduce(J,SM[1]),2);
1085      // Ann=quotient(SM[2],SL[1]);
1086      // qAnn=simplify(reduce(Ann,SM[1]),2);
1087      // if(size(qAnn)!=0)
1088      // {
1089        // keepresult1=normalizationPrimes(qAnn+SM[2]);
1090        // keepresult2=normalizationPrimes(SL[1]+SM[2]);
1091        // for(lauf=1;lauf<=size(keepresult2);j++)
1092        // {
1093        //    keepresult1=insert(keepresult1,keepresult2[lauf]);
1094        // }
1095        // return(keepresult1);
1096      // }
1097      RR=SM[1],SM[2],JM[2],SL[1];
1098
1099//   evtl eine geeignete Potenz von JM?
1100     if(y==1)
1101     {
1102        "compute Hom(rad(J),rad(J)):";
1103     }
1104//   ti=timer;
1105
1106     RS=HomJJ(RR,y);
1107//   timer-ti;
1108
1109      if(RS[2]==1)
1110      {
1111         def lastR=RS[1];
1112         setring lastR;
1113         ideal KK=endid;
1114         ideal PP=endphi;
1115         export PP;
1116         export KK;
1117         setring BAS;
1118        // return(RS[1]);
1119         return(lastR);
1120      }
1121      int n=nvars(basering);
1122      ideal MJ=JM[2];
1123      def newR=RS[1];
1124      setring newR;
1125
1126      map psi=BAS,endphi;
1127      list tluser=
1128             normalizationPrimes(endid,psi(ihp),simplify(psi(MJ)+endid,4));
1129            // normalizationPrimes(endid);
1130      setring BAS;
1131      return(tluser);
1132   }
1133   else
1134   {
1135      int equi=attrib(SM[2],"isEquidimensional");
1136      ideal new1=qAnn+SM[2];
1137      execute "ring newR1="+charstr(basering)+",("+varstr(basering)+"),("
1138                      +ordstr(basering)+");";
1139      if(y==1)
1140      {
1141         "zero-divisor found";
1142      }
1143      ideal vid=fetch(BAS,new1);
1144      ideal ihp=fetch(BAS,ihp);
1145      attrib(vid,"isCohenMacaulay",0);
1146      attrib(vid,"isPrim",0);
1147      attrib(vid,"isIsolatedSingularity",0);
1148      attrib(vid,"isRegInCodim2",0);
1149      if(equi==1)
1150      {
1151         attrib(vid,"isEquidimensional",1);
1152      }
1153      else
1154      {
1155         attrib(vid,"isEquidimensional",0);
1156      }
1157      attrib(vid,"isCompleteIntersection",0);
1158
1159      keepresult1=normalizationPrimes(vid,ihp);
1160
1161      setring BAS;
1162      ideal new2=quotient(SM[2],Ann)+SM[2];
1163// evtl. qAnn nehmen
1164//      ideal new2=SL[1]+SM[2];
1165      execute "ring newR2="+charstr(basering)+",("+varstr(basering)+"),("
1166                      +ordstr(basering)+");";
1167
1168      ideal vid=fetch(BAS,new2);
1169      ideal ihp=fetch(BAS,ihp);
1170      attrib(vid,"isCohenMacaulay",0);
1171      attrib(vid,"isPrim",0);
1172      attrib(vid,"isIsolatedSingularity",0);
1173      attrib(vid,"isRegInCodim2",0);
1174      if(equi==1)
1175      {
1176         attrib(vid,"isEquidimensional",1);
1177      }
1178      else
1179      {
1180         attrib(vid,"isEquidimensional",0);
1181      }
1182      attrib(vid,"isCompleteIntersection",0);
1183
1184      keepresult2=normalizationPrimes(vid,ihp);
1185
1186      setring BAS;
1187      for(lauf=1;lauf<=size(keepresult2);lauf++)
1188      {
1189         keepresult1=insert(keepresult1,keepresult2[lauf]);
1190      }
1191      return(keepresult1);
1192   }
1193}
1194example
1195{ "EXAMPLE:";echo = 2;
1196   LIB"normal.lib";
1197   //Huneke
1198ring qr=31991,(a,b,c,d,e),dp;
1199ideal i=
12005abcde-a5-b5-c5-d5-e5,
1201ab3c+bc3d+a3be+cd3e+ade3,
1202a2bc2+b2cd2+a2d2e+ab2e2+c2de2,
1203abc5-b4c2d-2a2b2cde+ac3d2e-a4de2+bcd2e3+abe5,
1204ab2c4-b5cd-a2b3de+2abc2d2e+ad4e2-a2bce3-cde5,
1205a3b2cd-bc2d4+ab2c3e-b5de-d6e+3abcd2e2-a2be4-de6,
1206a4b2c-abc2d3-ab5e-b3c2de-ad5e+2a2bcde2+cd2e4,
1207b6c+bc6+a2b4e-3ab2c2de+c4d2e-a3cde2-abd3e2+bce5;
1208
1209list pr=normal(i);
1210def r1=pr[1];
1211setring r1;
1212KK;
1213}
1214
1215proc substpart(ideal endid,ideal endphi, int homo, intvec rw)
1216{
1217   def newRing=basering;
1218   int ii,jj;
1219   map phi = basering,maxideal(1);
1220
1221   //endid=diagon(endid);
1222
1223   list Le = elimpart(endid);
1224           //this proc and the next loop try to
1225   int q = size(Le[2]);              //substitute as many variables as possible
1226   intvec rw1 = 0;                   //indices of substituted variables
1227   rw1[nvars(basering)] = 0;
1228   rw1 = rw1+1;
1229
1230   while( size(Le[2]) != 0 )
1231   {
1232      endid = Le[1];
1233      map ps = newRing,Le[5];
1234
1235      phi = ps(phi);
1236      for(ii=1;ii<=size(Le[2])-1;ii++)
1237      {
1238         phi=phi(phi);
1239      }
1240      //eingefuegt wegen x2-y2z2+z3
1241      kill ps;
1242
1243      for( ii=1; ii<=size(rw1); ii++ )
1244      {
1245         if( Le[4][ii]==0 )
1246         {
1247            rw1[ii]=0;                             //look for substituted vars
1248         }
1249      }
1250      Le=elimpart(endid);
1251      q = q + size(Le[2]);
1252   }
1253   endphi = phi(endphi);
1254
1255//---------- return -----------------------------------------------------------
1256// in the homogeneous case put weights for the remaining vars correctly, i.e.
1257// delete from rw those weights for which the corresponding entry of rw1 is 0
1258
1259   if (homo==1 && nvars(newRing)-q >1 && size(endid) >0 )
1260   {
1261      jj=1;
1262      for( ii=2; ii<size(rw1); ii++)
1263      {
1264         jj++;
1265         if( rw1[ii]==0 )
1266         {
1267            rw=rw[1..jj-1],rw[jj+1..size(rw)];
1268            jj=jj-1;
1269         }
1270      }
1271      if( rw1[1]==0 ) { rw=rw[2..size(rw)]; }
1272      if( rw1[size(rw1)]==0 ){ rw=rw[1..size(rw)-1]; }
1273
1274      ring lastRing = char(basering),(T(1..nvars(newRing)-q)),(a(rw),dp);
1275   }
1276   else
1277   {
1278      ring lastRing = char(basering),(T(1..nvars(newRing)-q)),dp;
1279   }
1280
1281   ideal lastmap;
1282   q = 1;
1283   for(ii=1; ii<=size(rw1); ii++ )
1284   {
1285      if ( rw1[ii]==1 ) { lastmap[ii] = T(q); q=q+1; }
1286      if ( rw1[ii]==0 ) { lastmap[ii] = 0; }
1287   }
1288   map phi = newRing,lastmap;
1289   ideal endid  = phi(endid);
1290   ideal endphi = phi(endphi);
1291   export(endid);
1292   export(endphi);
1293   list L = lastRing;
1294   setring newRing;
1295   return(L);
1296}
1297
1298proc diagon(ideal i)
1299{
1300   matrix m;
1301   option(redSB);
1302   ideal j=liftstd(jet(i,1),m);
1303   option(noredSB);
1304   return(ideal(matrix(i)*m));
1305}
1306/////////////////////////////////////////////////////////////////////////////
1307/*
1308LIB"normal.lib";
1309int aa=timer;list pr=normal(i);timer-aa;
1310
1311
1312
1313//Huneke
1314ring qr=31991,(a,b,c,d,e),dp;
1315ideal i=
13165abcde-a5-b5-c5-d5-e5,
1317ab3c+bc3d+a3be+cd3e+ade3,
1318a2bc2+b2cd2+a2d2e+ab2e2+c2de2,
1319abc5-b4c2d-2a2b2cde+ac3d2e-a4de2+bcd2e3+abe5,
1320ab2c4-b5cd-a2b3de+2abc2d2e+ad4e2-a2bce3-cde5,
1321a3b2cd-bc2d4+ab2c3e-b5de-d6e+3abcd2e2-a2be4-de6,
1322a4b2c-abc2d3-ab5e-b3c2de-ad5e+2a2bcde2+cd2e4,
1323b6c+bc6+a2b4e-3ab2c2de+c4d2e-a3cde2-abd3e2+bce5;
1324
1325
1326//Vasconcelos
1327ring r=32003,(x,y,z,w,t),dp;
1328ideal i=
1329x2+zw,
1330y3+xwt,
1331xw3+z3t+ywt2,
1332y2w4-xy2z2t-w3t3;
1333
1334//Theo1
1335ring r=32003,(x,y,z),wp(2,3,6);
1336ideal i=zy2-zx3-x6;
1337
1338//Theo2
1339ring r=32003,(x,y,z),wp(3,4,12);
1340ideal i=z*(y3-x4)+x8;
1341
1342//Theo2a
1343ring r=32003,(T(1..4)),wp(3,4,12,17);
1344ideal i=
1345T(1)^8-T(1)^4*T(3)+T(2)^3*T(3),
1346T(1)^4*T(2)^2-T(2)^2*T(3)+T(1)*T(4),
1347T(1)^7+T(1)^3*T(2)^3-T(1)^3*T(3)+T(2)*T(4),
1348T(1)^6*T(2)*T(3)+T(1)^2*T(2)^4*T(3)+T(1)^3*T(2)^2*T(4)-T(1)^2*T(2)*T(3)^2+T(4)^2;
1349
1350//Theo3
1351ring r=32003,(x,y,z),wp(3,5,15);
1352ideal i=z*(y3-x5)+x10;
1353
1354
1355//Theo4
1356ring r=32003,(x,y,z),dp;
1357ideal i=(x-y)*(x-z)*(y-z);
1358
1359//Theo5
1360ring r=32003,(x,y,z),wp(2,1,2);
1361ideal i=z3-xy4;
1362
1363//Theo6
1364ring r=32003,(x,y,z),dp;
1365ideal i=x2y2+x2z2+y2z2;
1366
1367ring r=32003,(a,b,c,d,e,f),dp;
1368ideal i=
1369bf,
1370af,
1371bd,
1372ad;
1373
1374//Beispiel, wo vorher Primaerzerlegung schneller
1375//ist CM
1376//Sturmfels
1377ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
1378ideal i=
1379bv+su,
1380bw+tu,
1381sw+tv,
1382by+sx,
1383bz+tx,
1384sz+ty,
1385uy+vx,
1386uz+wx,
1387vz+wy,
1388bvz;
1389
1390//J S/Y
1391ring r=32003,(x,y,z,t),dp;
1392ideal i=
1393x2z+xzt,
1394xyz,
1395xy2-xyt,
1396x2y+xyt;
1397
1398//St_S/Y
1399ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
1400ideal i=
1401wy-vz,
1402vx-uy,
1403tv-sw,
1404su-bv,
1405tuy-bvz;
1406
1407//dauert laenger
1408//Horrocks:
1409ring r=32003,(a,b,c,d,e,f),dp;
1410ideal i=
1411adef-16000be2f+16001cef2,
1412ad2f+8002bdef+8001cdf2,
1413abdf-16000b2ef+16001bcf2,
1414a2df+8002abef+8001acf2,
1415ad2e-8000bde2-7999cdef,
1416acde-16000bce2+16001c2ef,
1417a2de-8000abe2-7999acef,
1418acd2+8002bcde+8001c2df,
1419abd2-8000b2de-7999bcdf,
1420a2d2+9603abde-10800b2e2-9601acdf+800bcef+11601c2f2,
1421abde-8000b2e2-acdf-16001bcef-8001c2f2,
1422abcd-16000b2ce+16001bc2f,
1423a2cd+8002abce+8001ac2f,
1424a2bd-8000ab2e-7999abcf,
1425ab3f-3bdf3,
1426a2b2f-2adf3-16000bef3+16001cf4,
1427a3bf+4aef3,
1428ac3e-10668cde3,
1429a2c2e+10667ade3+16001be4+5334ce3f,
1430a3ce+10669ae3f,
1431bc3d+8001cd3e,
1432ac3d+8000bc3e+16001cd2e2+8001c4f,
1433b2c2d+16001ad4+4000bd3e+12001cd3f,
1434b2c2e-10668bc3f-10667cd2ef,
1435abc2e-cde2f,
1436b3cd-8000bd3f,
1437b3ce-10668b2c2f-10667bd2ef,
1438abc2f-cdef2,
1439a2bce-16000be3f+16001ce2f2,
1440ab3d-8000b4e-8001b3cf+16000bd2f2,
1441ab2cf-bdef2,
1442a2bcf-16000be2f2+16001cef3,
1443a4d-8000a3be+8001a3cf-2ae2f2;
1444
1445
1446ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
1447
1448ideal k=
1449wy-vz,
1450vx-uy,
1451tv-sw,
1452su-bv,
1453tuy-bvz;
1454ideal j=x2y2+x2z2+y2z2;
1455ideal i=mstd(intersect(j,k))[2];
1456
1457//22
1458ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
1459ideal i=
1460wx2y3-vx2y2z+wx2yz2+wy3z2-vx2z3-vy2z3,
1461vx3y2-ux2y3+vx3z2-ux2yz2+vxy2z2-uy3z2,
1462tvx2y2-swx2y2+tvx2z2-swx2z2+tvy2z2-swy2z2,
1463sux2y2-bvx2y2+sux2z2-bvx2z2+suy2z2-bvy2z2,
1464tux2y3-bvx2y2z+tux2yz2+tuy3z2-bvx2z3-bvy2z3;
1465
1466
1467//riemenschneider
1468//33
1469//normal+primary 3
1470//primary 9
1471//radical 1
1472//minAssPrimes 2
1473ring r=32000,(p,q,s,t,u,v,w,x,y,z),wp(1,1,1,1,1,1,2,1,1,1);
1474ideal i=
1475xz,
1476vx,
1477ux,
1478su,
1479qu,
1480txy,
1481stx,
1482qtx,
1483uv2z-uwz,
1484uv3-uvw,
1485puv2-puw;
1486
1487
1488*/
Note: See TracBrowser for help on using the repository browser.