source: git/Singular/LIB/rstandard.lib @ 4bde6b

spielwiese
Last change on this file since 4bde6b was 4bde6b, checked in by Hans Schoenemann <hannes@…>, 4 years ago
spelling p1
  • Property mode set to 100644
File size: 15.9 KB
Line 
1///////////////////////////////////////////////////////////////////////////////
2version="version standard.lib 4.1.2.0 Feb_2019 ";
3category="Commutative Algebra";
4info="
5LIBRARY: rstandard.lib     Computes Janet bases and border bases for ideals
6
7AUTHORS: Shamsa Kanwal           lotus_zone16@yahoo.com
8         Gerhard Pfister         pfister@mathematik.uni-kl.de
9
10OVERVIEW: Computing Janet bases and border bases for any ordering
11          using the idea of r-standard bases (defined by V. Gerdt)
12
13REFERENCES:
14   [1] A. Kehrein, M. Kreuzer, L. Robbiano: An algebrists view on border bases, in:
15       A. Dickenstein and I. Emiris (eds.), Solving Polynomial Equations:
16       Foundations, Algorithms and Applications, Springer, Heidelberg 2005, 169-202.
17
18   [2] V.P. Gerdt: Involute Algorithms for Computing Groebner Bases, In
19       Computational Commutative and Non-Computational Algebra Geometry,
20       S.Conjocaru, G. Pfister and V. Ufnarovski (Eds.), NATO Science Series,105
21       Press 2005, 199-255.
22
23
24PROCEDURES:
25   borderBasis(I);  computes a border basis of the ideal I
26   modBorder(I);    computes a border basis of the ideal I using modular methods
27   rJanet(I);       computes a Janet basis of the ideal I
28   modJanet(I);     computes a Janet basis of the ideal I using modular methods
29
30KEYWORDS: border basis; janet basis
31";
32LIB "general.lib";
33LIB "modstd.lib";
34
35//=================================  procedures  ==============================
36//================================= border bases ==============================
37
38
39static proc orderIdeal(ideal I)
40{
41//returns the order ideal, the corners and the border of the
42//order ideal
43   I=std(I);
44   int d=vdim(I);
45   if(d==-1){ERROR(" ideal is not zero dimensional ");}
46   ideal O=kbase(I);   //this is the order ideal
47   ideal C=lead(I);    //this are the corners
48   ideal B=border(C);  //this is the border of the order ideal
49   list L=O,C,B,I;
50   return(L);
51}
52
53static proc border(ideal L)
54{
55//L a monomial ideal
56//returns the border of the order ideal corresponding to L
57   ideal O=kbase(L);
58   ideal Omax=maxO(O);
59   ideal B=L;
60   poly p;
61   list C;
62   int i,j,k;
63   for(i=1;i<=size(L);i++)
64   {
65      for(j=1;j<=size(Omax);j++)
66      {
67         for(k=1;k<=nvars(basering);k++)
68         {
69            p=(var(k)*Omax[j])/L[i];
70            if(p!=0){break;}
71         }
72         if(k<=nvars(basering))
73         {
74            C=coneM(p);
75            for(k=1;k<=size(C);k++)
76            {
77               B[size(B)+1]=C[k]*L[i];
78            }
79         }
80      }
81   }
82   B=simplify(B,4);
83   B=simplify(B,2);
84   B=sort(B)[1];
85   return(B);
86}
87
88static proc coneM(poly p)
89{
90//computes all monomials different from 1 dividing p
91  list L=p;
92  int i,j,k;
93  poly q;
94  k=1;
95  ideal I;
96  while(k)
97  {
98     k=0;
99     i++;
100     I=maxideal(i);
101     for(j=1;j<=size(I);j++)
102     {
103       q=p/I[j];
104       if((q!=0)&&(q!=1))
105       {
106          k=1;
107          L[size(L)+1]=q;
108       }
109     }
110  }
111  return(L);
112}
113
114static proc maxO(ideal O)
115{
116//O is a monomial ideal
117//computes the maximal elements in O with respect to division
118    def R=basering;
119    def S=changeord(list(list("ds",nvars(R))));
120    setring S;
121    ideal O=imap(R,O);
122    O=sort(O)[1];
123    setring R;
124    O=imap(S,O);
125    int i=1;
126    int j;
127    int n=size(O);
128    while(i<ncols(O))
129    {
130       j=i+1;
131       while(j<=ncols(O))
132       {
133          if(O[j]!=0)
134          {
135             if(O[i]/O[j]!=0)
136             {
137                O[j]=0;
138             }
139          }
140          j++;
141       }
142       O=simplify(O,2);
143       i++;
144    }
145    return(O);
146}
147
148/////////////////////////////////////////////////////////////////////////////
149proc borderBasis(ideal I)
150"USAGE:   borderBasis(I); I is an ideal.
151RETURN:   ideal, a border basis for I.
152PURPOSE:  Computes a border basis for the ideal given by the generators in I.
153SEE ALSO: modBorder
154KEYWORDS: order ideal, border basis
155EXAMPLE:  example borderBasis; shows an example
156"
157{
158   list L=orderIdeal(I);
159   I=L[4];
160   ideal B=L[3];
161   poly P;
162   int i;
163   if(ringlist(basering)[3][1][1]=="ds"||ringlist(basering)[3][1][1]=="Ds")
164   {
165      for(i=1;i<=size(B);i++)
166      {
167         P=system("reduce_bound",B[i],I,deg(highcorner(I))+1);
168         B[i]=B[i]-P;
169      }
170   }
171   else
172   {
173      if(ord_test(basering))
174      {
175         for(i=1;i<=size(B);i++)
176         {
177            P=reduce(B[i],I);
178            B[i]=B[i]-P;
179         }
180      }
181      else
182      {
183         L=division(B[i],I);
184         B[i]=L[3][1,1]*B[i]-L[2][1];
185      }
186   }
187   attrib(B,"isSB",1);
188   return(B);
189}
190example
191{ "EXAMPLE:";
192   ring R=32003,(x,y,z),ds;
193   poly f=x3y+x5+x3y2+2x2y3+x2yz2+xy5+x12+y16+z20;
194   ideal i= jacob(f);
195   i=i,f;
196   ideal j=borderBasis(i);  j;
197}
198
199/////////////////////////////////////////////////////////////////////////////
200
201proc modBorder(ideal I, list #)
202"USAGE:   modBorder(I,i); I is an ideal, i an integer.
203RETURN:   ideal, a border basis for I using modular methods.
204PURPOSE:  Computes a border basis for the ideal given by the generators in I
205          using modular techniques.
206          If second argument is 0 then the result is not verified.
207SEE ALSO: borderBasis
208KEYWORDS: order ideal, border basis
209EXAMPLE:  example modBorder; shows an example
210"
211{
212    int exactness = 1;
213    if (size(#) > 0) {
214        exactness = #[1];
215    }
216    /* save options */
217    intvec opt = option(get);
218    option(redSB);
219    /* choose the right command */
220    string command = "borderBasis";
221    /* call modular() */
222    if (exactness) {
223        I = modular(command, list(I), Modstd::primeTest_std,
224            Modstd::deleteUnluckyPrimes_std, Modstd::pTest_std,finalTest_std_new);
225    }
226    else {
227        I = modular(command, list(I), Modstd::primeTest_std,
228            Modstd::deleteUnluckyPrimes_std,Modstd::pTest_std);
229    }
230    /* return the result */
231    attrib(I, "isSB", 1);
232    option(set, opt);
233    return(I);
234}
235example
236{ "EXAMPLE:";
237   ring R=0,(x,y,z),ds;
238   poly f=x3y+x5+x3y2+2x2y3+x2yz2+xy5+x12+y16+z20;
239   ideal i= jacob(f);
240   i=i,f;
241   ideal j=modBorder(i,1);  j;
242
243   ring S=0,(x,y,z),ds;
244   ideal i=
245   3x2+6xy+3y2+6xz+6yz+3z2+3x2yz+4xy2z+y3z+4xyz2+2y2z2+yz3+10x9,
246   3x2+6xy+3y2+6xz+6yz+3z2+x3z+4x2yz+3xy2z+2x2z2+4xyz2+xz3+10y9,
247   3x2+6xy+3y2+6xz+6yz+3z2+x3y+2x2y2+xy3+4x2yz+4xy2z+3xyz2+10z9;
248   ideal j=modBorder(i,0);  j;
249}
250
251//=================================== Janet bases ==============================
252
253
254/////////////////////////////////////////////////////////////////////////////
255proc rJanet(ideal I)
256"USAGE:   rJanet(I); I is an ideal.
257RETURN:   ideal, a Janet basis for I.
258PURPOSE:  Computes a Janet basis for the ideal given by the generators in I for any ordering.
259SEE ALSO: modJanet
260KEYWORDS: Janet division, Janet basis
261EXAMPLE:  example rJanet; shows an example
262"
263{
264   def R=basering;
265   int i,d;
266   poly p;
267
268   I=std(I);
269   d=dim(I);
270   if(I[1]==1){return(ideal(1));}
271   ideal J=lead(I);
272   intvec v;
273   v[nvars(R)]=0;
274   v=v+1;
275   list rl=ringlist(R);
276   rl[3]=list(list("dp",v));
277   ring S=ring(rl);
278   ideal J=imap(R,J);
279   J=janet(J);
280   J=simplify(J,1+2+4+8+16);
281   setring R;
282   J=imap(S,J);
283   list L;
284   poly P;
285   if((ringlist(basering)[3][1][1]=="ds"||ringlist(basering)[3][1][1]=="Ds")&&(d==0))
286   {
287      for(i=1;i<=size(J);i++)
288      {
289         P=system("reduce_bound",J[i],I,deg(highcorner(I))+1);
290         J[i]=J[i]-P;
291      }
292   }
293   else
294   {
295      if(ord_test(basering))
296      {
297         for(i=1;i<=size(J);i++)
298         {
299            P=reduce(J[i],I);
300            J[i]=J[i]-P;
301         }
302      }
303      else
304      {
305         L=division(J[i],I);
306         J[i]=L[3][1,1]*J[i]-L[2][1];
307      }
308   }
309   attrib(J,"isSB",1);
310   return(J);
311}
312example
313{ "EXAMPLE:";
314   ring R= 32003,(a,b,c,d,e,f,g),dp;
315   ideal i=
316   a+b+c+d+e+f+g,
317   ab+bc+cd+de+ef+fg+ga,
318   abc+bcd+cde+fde+efg+fga+gab,
319   abcd+bcde+cdef+defg+efga+fgab+gabc,
320   abcde+bcdef+cdefg+defga+efgab+fgabc+gabcd,
321   abcdef+bcdefg+cdefga+defgab+efgabc+fgabcd+gabcde,
322   abcdefg-1;
323   ideal j = rJanet(i);   j;
324}
325
326/////////////////////////////////////////////////////////////////////////////
327proc modJanet(ideal I, list #)
328"USAGE:   modJanet(I,i); I is an ideal, i an integer (optional).
329RETURN:   ideal, a Janet basis for I using modular methods.
330PURPOSE:  Computes a Janet basis for the ideal given by the generators in I
331          using modular techniques.
332          If second argument is 0 then the result is not verified.
333SEE ALSO: rJanet
334KEYWORDS: Janet basis
335EXAMPLE:  example Janet; shows an example
336"
337{
338    int exactness = 1;
339    if (size(#) > 0) {
340        exactness = #[1];
341    }
342    /* save options */
343    intvec opt = option(get);
344    option(redSB);
345    /* choose the right command */
346    string command = "rJanet";
347    /* call modular() */
348    if (exactness) {
349        I = modular(command, list(I), Modstd::primeTest_std,
350            Modstd::deleteUnluckyPrimes_std, Modstd::pTest_std,finalTest_std_new);
351    }
352    else {
353        I = modular(command, list(I), Modstd::primeTest_std,
354            Modstd::deleteUnluckyPrimes_std,Modstd::pTest_std);
355    }
356    /* return the result */
357    attrib(I, "isSB", 1);
358    option(set, opt);
359    return(I);
360}
361example
362{ "EXAMPLE:";
363   ring R=0,(t,x,y,z),ds;
364   ideal i=
365   5t3x2z+2t2y3x5,
366   7y+4x2y+y2x+2zt,
367   3tz+3yz2+2yz4;
368   ideal j=modJanet(i);  j;
369
370   ring S=0,(x,y,z),dp;
371   poly p1 =x2y*(47x5y7z3+28xy5z8+63+91x5y3z7);
372   poly p2 =xyz*(57y6+21x2yz9+51y2z2+15x2z4);
373   poly p3 =xy4z*(74y+32x6z7+53x5y2z+17x2y3z);
374   poly p4 =y3z*(21x2z6+32x10y6z5+23x5y5z7+27y2);
375   poly p5 =xz*(36y2z2+81x9y10+19x2y5z4+79x4z6);
376   ideal i =p1,p2,p3,p4,p5;
377   ideal j=modJanet(i,0);  j;
378}
379/////////////////////////////////////////////////////////////////////////////
380static proc minimizeS(ideal I)
381{
382   int i,j;
383   ideal K;
384   ideal J=std(lead(I));
385   I=sort(I)[1];
386   J=sort(J)[1];
387   while(i<size(J))
388   {
389      i++;
390      while(j<size(I))
391      {
392         j++;
393         if(leadmonom(I[j])==J[i])
394         {
395            K[size(K)+1]=I[j];
396            break;
397         }
398      }
399   }
400   return(K);
401}
402
403static proc finalTest_std_new(string command, alias list args, ideal result)
404{
405   result=minimizeS(result);
406   attrib(result,"isSB",1);
407   return(Modstd::finalTest_std(command, args,result));
408}
409
410/////////////////////////////////////////////////////////////////////////////
411
412/*
413//=====  Examples (http://symbolicdata.org/XMLResources/IntPS/): ============
414
415//Cyclic_7.xml
416ring r18= 32003,(a,b,c,d,e,f,g),dp;
417ideal i=
418a+b+c+d+e+f+g,
419ab+bc+cd+de+ef+fg+ga,
420abc+bcd+cde+fde+efg+fga+gab,
421abcd+bcde+cdef+defg+efga+fgab+gabc,
422abcde+bcdef+cdefg+defga+efgab+fgabc+gabcd,
423abcdef+bcdefg+cdefga+defgab+efgabc+fgabcd+gabcde,
424abcdefg-1;
425
426// Milnor1.xml
427ring s8=32003,(x,y,z),dp;
428int a =60;
429int b =40;
430int c =20;
431int t =1;
432poly f= x^a+y^b+z^(3*c)+x^(c+2)*y^(c-1)+x^(c-1)*y^(c-1)*z3+x^(c-2)*y^c*(y2+t*x)^2;
433ideal i= jacob(f);
434
435// Tjurina1.xml
436ring s10=32003,(x,y,z),dp;
437int a=30;
438poly f =xyz*(x+y+z)^2 +(x+y+z)^3 +x^a+y^a+z^a;
439ideal i= jacob(f);
440i=i,f;
441
442// random1.xml
443ring s15=32003,(x,y,z),dp;
444poly p1 =x2y*(47x5y7z3+28xy5z8+63+91x5y3z7);
445poly p2 =xyz*(57y6+21x2yz9+51y2z2+15x2z4);
446poly p3 =xy4z*(74y+32x6z7+53x5y2z+17x2y3z);
447poly p4 =y3z*(21x2z6+32x10y6z5+23x5y5z7+27y2);
448poly p5 =xz*(36y2z2+81x9y10+19x2y5z4+79x4z6);
449ideal i =p1,p2,p3,p4,p5;
450
451// random2.xml
452ring s16=32003,(x,y,z),dp;
453poly p1 =xy2z*(47x6y6z2+28y5+63y3z3+91xyz6+57z2);
454poly p2 =x3y2z*(21y4z7+51z9+15x4y2z7+74x7y7z5+32x7y8);
455poly p3 =xy*(53x+17y2z3+21x5y5z2+32x4y7z8+23x2y4z5);
456poly p4 =z*(27x7y4z6+36x3yz4+81x3y7z+19y5+79x5z6);
457ideal i =p1,p2,p3,p4;
458
459// Singular.schwarz_6.xml (dehomogenized: h=1)
460ring r16= 32003,(x(1..6)),lp;
461poly s1= -1*x(1)^2-1*x(1)-2*x(2)*x(6)-2*x(3)*x(5)-1*x(4)^2;
462poly s2= -2*x(1)*x(2)-1*x(2)-2*x(3)*x(6)-2*x(4)*x(5);
463poly s3= -2*x(1)*x(3)-1*x(2)^2-1*x(3)-2*x(4)*x(6)-1*x(5)^2;
464poly s4= -2*x(1)*x(4)-2*x(2)*x(3)-1*x(4)-2*x(5)*x(6);
465poly s5= -2*x(1)*x(5)-2*x(2)*x(4)-1*x(3)^2-1*x(5)-1*x(6)^2;
466poly s6= -2*x(1)*x(6)-2*x(2)*x(5)-2*x(3)*x(4)-1*x(6);
467ideal i =s1,s2,s3,s4,s5,s6;
468
469//Twomat3.xml
470ring r1=32003,(a,b,c,d,e,f,g,h,i,A,B,C,D,E,F,G,H,I),dp;
471ideal i=
472-dB-gC+bD+cG,
473-bA+aB-eB-hC+bE+cH,
474-cA-fB+aC-iC+bF+cI,
475dA-aD+eD-dE-gF+fG,
476dB-bD-hF+fH,
477dC-cD-fE+eF-iF+fI,
478gA+hD-aG+iG-dH-gI,
479gB+hE-bG-eH+iH-hIgC+hF-cG-fH;
480
481// Klein.xml
482ring r12 = 32003,(x,y,z,t,u),dp;
483ideal i= x6+y6+522*(x^5*y-x*y^5)-10005*(x^4*y^2+x^2*y^4)-z,
484-(x^4+y^4)+228*(x^3*y-x*y^3)-494*x^2*y^2-t,
485x*y*(x*2+11*x*y-y^2)*5-u;
486
487// Meintjes.xml
488ring r15 = 32003,(x,y,z,t,u,a,b,c,d,e,f,g),dp;
489ideal i=
490xy+x-3u,
491yz2+2y2a+ytb+yzd+2xy+yc-ug+x,
4922yz2+yzd+2z2f+ze-8u,
493ytb+2t2+4ug,
494yz2+y2a+ytb+yzd+z2f+xy+t2+yc+ze+x-1;
495
496// Wilfred.xml
497ring w7=32003,(x(1..16)),dp;
498ideal i=
499x(1)+x(2)+x(3)+x(4),
500x(1)^2*x(2)^2+x(2)*x(3)*x(5)*x(6),
501x(3)*x(4)*x(9)*x(10)+x(4)*x(5)*x(13)*x(14),
502x(1)*x(2)^2*x(3)+x(2)*x(3)*x(6)*x(7),
503x(3)*x(4)*x(11)*x(12)+x(4)*x(5)*x(15)*x(16),
504x(7)*x(8)*x(9)*x(10)+x(8)*x(9)*x(13)*x(14),
505x(7)*x(8)*x(11)*x(12)+x(8)*x(9)*x(15)*x(16),
506x(1)*x(2)*x(9)*x(10)+x(5)*x(6)*x(10)*x(11),
507x(2)*x(3)*x(9)*x(10)+x(6)*x(7)*x(10)*x(11),
508x(11)*x(12)*x(15)*x(16)+x(1)*x(15)*x(16)^2,
509x(4)*x(5)*x(13)*x(14)+x(8)*x(9)*x(14)*x(15)+x(12)*x(13)*x(15)*x(16)+
510x(1)^2*x(16)^2;
511
512// Behnke.xml
513ring bn=32003,(a,b,c,d,e),dp;
514int n=7;
515ideal i=
516a^n-b^n,
517b^n-c^n,
518c^n-d^n,
519d^n-e^n,
520a^(n-1)*b+b^(n-1)*c+c^(n-1)*d+d^(n-1)*e+e^(n-1)*a;
521
522//Paris.ilias13.xml
523ring r=32003,(S1,s1,d1,S2,D2,s2,d2),dp;
524ideal i=-8*d1*D2+2*S2*s2-2*D2*d2-8*S2-4*s2+16,
5258*d1*D2-2*S2*s2+2*D2*d2+8*S2+4*s2-16,
526-8*d1*S2-16*s1*D2+2*D2*s2-2*S2*d2+16*d1+8*D2+4*d2,
5278*d1*S2+16*s1*D2-2*D2*s2+2*S2*d2-16*d1-8*D2-4*d2,
528-8*S1*S2+4*S2^2-20*D2^2+16*S1-16,
5298*S1*S2-4*S2^2+20*D2^2-16*S1+16,
530-16*d1^2-8*s1*s2+s2^2-8*d1*d2-d2^2+32*s1-16,
53116*d1^2+8*s1*s2-s2^2+8*d1*d2+d2^2-32*s1+16,
532-16*S1*d1+8*d1*S2-10*D2*s2-4*S1*d2+2*S2*d2+16*d1+40*D2+4*d2,
53316*S1*d1-8*d1*S2+10*D2*s2+4*S1*d2-2*S2*d2-16*d1-40*D2-4*d2,
534-32*S1*s1+16*s1*S2+40*d1*D2+4*S1*s2-2*S2*s2+10*D2*d2+16*S1+32*s1-8*S2-4*s2-16,
53532*S1*s1-16*s1*S2-40*d1*D2-4*S1*s2+2*S2*s2-10*D2*d2-16*S1-32*s1+8*S2+4*s2+16,
536S2^2*s2^3-2*S2*D2*s2^3+D2^2*s2^3+3*S2^2*s2^2*d2-6*S2*D2*s2^2*d2+3*D2^2*s2^2*d2
537  +3*S2^2*s2*d2^2-6*S2*D2*s2*d2^2+3*D2^2*s2*d2^2+S2^2*d2^3-2*S2*D2*d2^3
538  +D2^2*d2^3-32,
539S2^2*s2^3+2*S2*D2*s2^3+D2^2*s2^3-3*S2^2*s2^2*d2-6*S2*D2*s2^2*d2-3*D2^2*s2^2*d2
540  +3*S2^2*s2*d2^2+6*S2*D2*s2*d2^2+3*D2^2*s2*d2^2-S2^2*d2^3-2*S2*D2*d2^3
541  -D2^2*d2^3-32,
542S1^2*s1^3-3*S1^2*s1^2*d1+3*S1^2*s1*d1^2-S1^2*d1^3+4*S1*s1^3*D2-12*S1*s1^2*d1*D2
543  +12*S1*s1*d1^2*D2-4*S1*d1^3*D2+4*s1^3*D2^2-12*s1^2*d1*D2^2+12*s1*d1^2*D2^2
544  -4*d1^3*D2^2-32,
545S1^2*s1^3+3*S1^2*s1^2*d1+3*S1^2*s1*d1^2+S1^2*d1^3-4*S1*s1^3*D2-12*S1*s1^2*d1*D2
546  -12*S1*s1*d1^2*D2-4*S1*d1^3*D2+4*s1^3*D2^2+12*s1^2*d1*D2^2+12*s1*d1^2*D2^2
547  +4*d1^3*D2^2-32;
548
549
550// Pfister_2.xlm
551ring r=32003,(x2,x3,x4,x5,y1,y2,y3,y4,z1,z2,z3,z4,z5),dp;
552ideal i=x2^3+x3^2+x4^2+x5^2+y1^2+y2^2+y3^2+y4^2+z1^2+z2^2+z3^2+z4^2+z5^2,
553y1^2+z1^2-1,x2^2+y2^2+z2^2-1,x3^2+y3^2+z3^2-1,x4^2+y4^2+z4^2-1,
554x5^2+z5^2-1,y1*y2+z1*z2,x2*x3+y2*y3+z2*z3,x3*x4+y3*y4+z3*z4,x4*x5+z4*z5,
555x2+x3+x4+x5+1,y1+y2+y3+y4-1,z1+z2+z3+z4+z5;
556
557// Singular.gerhard_3.xml
558ring r=32003,(w,x,y,z),dp;
559ideal i=3*w^5*x^5*y^5*z^2+18*z^17,
5605*w^10*x^8*y^4+6*w^11*x^6*y^5+16*w^10*x^5*y^7+10*w^9*x^4*y^9+23*y^22+5*w^10*x^5*y^4*z^3,
56124*x^23+8*w^11*x^7*y^5+6*w^12*x^5*y^6+10*w^11*x^4*y^8+4*w^10*x^3*y^10+5*w^11*x^4*y^5*z^3;
562
563//Singular.gerhard_1.xml  (dehomogenized w=1)
564ring r1=32003,(t,x,y,z),ds;
565ideal i=
5665t3x2z+2t2y3x5,
5677y+4x2y+y2x+2zt,
5683tz+3yz2+2yz4;
569
570// Milnor3.xml
571ring r3=32003,(x,y,z),ds;
572int a =33;
573int b =30;
574int c =10;
575int t =1;
576poly f =x^a+y^b+z^(3*c)+x^(c+2)*y^(c-1)+x^(c-1)*y^(c-1)*z3+x^(c-2)*y^c*(y2+t*x)^2;
577ideal i= jacob(f);
578
579// Tjurina1.xml
580ring r4=0,(x,y,z),ds;
581int a=30;
582poly f =xyz*(x+y+z)^2 +(x+y+z)^3 +x^a+y^a+z^a;
583ideal i= jacob(f);
584
585// Milnor4.xml
586ring r6=32003,(x,y,z),ds;
587int a =12;
588int b =16;
589int c =20;
590int alpha =5;
591int beta= 5;
592int t= 1;
593poly f =x^a+y^b+z^c+x^alpha*y^(beta-5)+x^(alpha-2)*y^(beta-3)
594+x^(alpha-3)*y^(beta-4)*z^2+x^(alpha-4)*y^(beta-4)*(y^2+t*x)^2;
595ideal i= jacob(f);
596i=i,f;
597
598// Steidel_1.xml
599ring r=0,(x,y,z),ds;
600ideal i=3*x^2+10*x^9+6*x*y+3*y^2+6*x*z+6*y*z+3*x^2*y*z+4*x*y^2*z+y^3*z
601  +3*z^2+4*x*y*z^2+2*y^2*z^2+y*z^3,
6023*x^2+6*x*y+3*y^2+10*y^9+6*x*z+x^3*z+6*y*z+4*x^2*y*z+3*x*y^2*z+3*z^2
603  +2*x^2*z^2+4*x*y*z^2+x*z^3,
6043*x^2+6*x*y+x^3*y+3*y^2+2*x^2*y^2+x*y^3+6*x*z+6*y*z+4*x^2*y*z
605  +4*x*y^2*z+3*z^2+3*x*y*z^2+10*z^9;
606
607*/
Note: See TracBrowser for help on using the repository browser.