source: git/Singular/LIB/schreyer.lib @ 210d1b

spielwiese
Last change on this file since 210d1b was 210d1b, checked in by Oleksandr Motsak <motsak@…>, 12 years ago
fixing a Sort problem for 0-input (wrong output rank of 0?)
  • Property mode set to 100644
File size: 56.9 KB
Line 
1///////////////////////////////////////////////////////////////////////////
2version="version schreyer.lib 4.0.0.0 Jun_2013 "; // $Id$
3category="General purpose";
4info="
5LIBRARY: schreyer.lib     Helpers for computing a Schreyer resolution in @code{derham.lib}
6AUTHOR:  Oleksandr Motsak <U@D>, where U={motsak}, D={mathematik.uni-kl.de}
7KEYWORDS: Schreyer ordering; Schreyer resolution; syzygy
8OVERVIEW:
9@* The library contains helper procedures for computing a Schreyer resoltion (cf. [SFO]),
10   originally meant to be used by @code{derham.lib} (which requires resolutions over the homogenized Weyl algebra).
11   The library works both in the commutative and non-commutative setting (cf. [MO]).
12   Here, we call a free resolution a Schreyer resolution if each syzygy module is given by a Groebner basis
13   with respect to the corresponding Schreyer ordering.
14   A Schreyer resolution can be much bigger than a minimal resolution of the same module, but may be easier to construct.
15@* The input for the resolution computations is a set of vectors @code{M} in form of a module over some basering @code{R}.
16   The ring @code{R} may be non-commutative, in which case the ring ordering should be global.
17@* These procedures produce/work with partial Schreyer resolutions of @code{(R^rank(M))/M} in form of
18   a ring (endowed with a special ring ordering that will be extended in the course of a resolution computation)
19   containing a list of modules @code{RES} and a module @code{MRES}:
20@* The list of modules @code{RES} contains the images of maps (also called syzygy modules) substituting the
21   computed beginning of a Schreyer resolution, that is, each syzygy module is given by a Groebner basis
22   with respect to the corresponding Schreyer ordering.
23@* The list @code{RES} starts with a zero map given by @code{rank(M)} zero generators indicating that the image of
24   the first differential map is zero. The second map @code{RES[2]} is given by @code{M}, which indicates that
25   the resolution of @code{(R^rank(M))/M} is being computed.
26@* The module @code{MRES} is a direct sum of modules from @code{RES} and thus comprises all computed differentials.
27@* Syzygies are shifted so that @code{gen(i)} is mapped to @code{MRES[i]} under the differential map.
28@* The Schreyer ordering succesively extends the starting module ordering on @code{M} (defined in Singular by the basering @code{R})
29   and is extended to higher syzygies using the following definition:
30@*        a < b if and only if (d(a) < d(b)) OR ( (d(a) = d(b) AND (comp(a) < comp(b)) ),
31@* where @code{d(a)} is the image of a under the differential (given by @code{MRES}),
32   and @code{comp(a)} is the module component, for any module terms @code{a} and @code{b} from the same higher syzygy module.
33REFERENCES:
34[SFO] Schreyer, F.O.: Die Berechnung von Syzygien mit dem verallgemeinerten Weierstrassschen Divisionssatz,
35      Master's thesis, Univ. Hamburg, 1980.
36[MO]  Motsak, O.: Non-commutative Computer Algebra with applications: Graded commutative algebra and related
37      structures in Singular with applications, Ph.D. thesis, TU Kaiserslautern, 2010
38
39NOTE:  requires the dynamic or built-in module @code{syzextra}
40
41PROCEDURES:
42  Sres(M,len)     compute Schreyer resolution of module M of maximal length len
43  Ssyz(M)         compute Schreyer resolution of module M of length 1
44  Scontinue(len)  extend currently active resolution by (at most) len syszygies
45";
46
47static proc prepareSyz( module I, list # )
48{
49  int i;
50  int k = 0;
51  int r = nrows(I);
52  int c = ncols(I);
53
54
55  if( size(#) > 0 )
56  {
57    if( typeof(#[1]) == "int" || typeof(#[1]) == "bigint" )
58    {
59      k = #[1];
60    }
61  }
62
63  if( k < r )
64  {
65    "// *** Wrong k: ", k, " < nrows: ", r, " => setting k = r = ", r;
66    k = r;
67  }
68
69//   "k: ", k;  "c: ", c;   "I: ", I;
70
71  for( i = c; i > 0; i-- )
72  {
73    I[i] = I[i] + gen(k + i);
74  }
75
76//  DetailedPrint(I);
77
78  return(I);
79}
80
81static proc separateSyzGB( module J, int c )
82{
83  module II, G; vector v; int i;
84
85  J = simplify(J, 2);
86
87  for( i = ncols(J); i > 0; i-- )
88  {
89    v = J[i];
90    if( leadcomp(v) > c )
91    {
92      II[i] = v;
93    } else
94    {
95      G[i] = v; // leave only gen(i): i <= c
96    }
97  }
98
99  II = simplify(II, 2);
100  G = simplify(G, 2);
101
102  return (list(G, II));
103}
104
105static proc splitSyzGB( module J, int c )
106{
107  module JJ; vector v, vv; int i;
108
109  for( i = ncols(J); i > 0; i-- )
110  {
111    v = J[i];
112
113    vv = 0;
114   
115    while( leadcomp(v) <= c )
116    {
117      vv = vv + lead(v);
118      v  = v  - lead(v);
119    }
120
121    J[i] = vv;
122    JJ[i] = v;
123  }
124
125  J = simplify(J, 2);
126  JJ = simplify(JJ, 2);
127
128  return (list(J, JJ));
129}
130
131
132static proc Sinit(module M)
133{
134  def @save = basering;
135 
136  int @DEBUG = !system("with", "ndebug");
137  if( @DEBUG )
138  {
139    "Sinit::Input";
140    type(M);
141    DetailedPrint(M);
142    attrib(M);
143  }
144
145  int @RANK = nrows(M); int @SIZE = ncols(M);
146
147  int @IS_A_SB = attrib(M, "isSB"); // ??? only if all weights were zero?!
148
149  if( !@IS_A_SB )
150  {
151    M = std(M); // this should be faster than computing std in S (later on)
152  }
153
154  def S = MakeInducedSchreyerOrdering(1); // 1 puts history terms to the back
155  // TODO: NOTE: +1 causes trouble to Singular interpreter!!!???
156  setring S; // a new ring with a Schreyer ordering
157
158  if( @DEBUG )
159  {
160    "Sinit::StartingISRing";
161    basering;
162//    DetailedPrint(basering);
163  }
164
165  // Setup the leading syzygy^{-1} module to zero:
166  module Z = 0; Z[@RANK] = 0; attrib(Z, "isHomog", intvec(0)); 
167
168  module MRES = Z;
169 
170  list RES; RES[1] = Z;
171
172  module F = freemodule(@RANK);
173  intvec @V = deg(F[1..@RANK]);
174 
175  module M = imap(@save, M);
176 
177  attrib(M, "isHomog", @V);
178  attrib(M, "isSB", 1);
179
180 
181  if( @DEBUG )
182  {
183    "Sinit::SB_Input: ";
184    type(M);
185    attrib(M);
186    attrib(M, "isHomog");
187    DetailedPrint(M);
188  }
189
190  if( @DEBUG )
191  {
192    // 0^th syz. property
193    if( size(module(transpose( transpose(M) * transpose(MRES) ))) > 0 )
194    {
195      transpose( transpose(M) * transpose(MRES) );
196      "transpose( transpose(M) * transpose(MRES) ) != 0!!!";
197      $
198    }
199  }
200
201  RES[size(RES)+1] = M; // list of all syzygy modules
202  MRES = MRES, M;
203
204  attrib(MRES, "isHomog", @V); 
205
206  attrib(S, "InducionLeads", lead(M));
207  attrib(S, "InducionStart", @RANK); 
208 
209  if( @DEBUG )
210  {
211    "Sinit::MRES";
212    DetailedPrint(MRES);
213    attrib(MRES, "isHomog");
214    attrib(S);
215  }
216
217  export RES;
218  export MRES;
219  return (S);
220}
221
222static proc Sstep()
223{
224  int @DEBUG = !system("with", "ndebug");
225
226  if( @DEBUG )
227  {
228    "Sstep::NextInducedRing";
229    DetailedPrint(basering);
230
231    attrib(basering, "InducionLeads");
232    attrib(basering, "InducionStart");
233
234    GetInducedData();
235  }
236
237  // syzygy step:
238
239/*
240  // is initial weights are all zeroes!
241  def L =  lead(M);
242  intvec @V = deg(M[1..ncols(M)]);  @W;  @V;  @W = @V;  attrib(L, "isHomog", @W); 
243  SetInducedReferrence(L, @RANK, 0);
244*/
245
246//  def L =  lead(MRES);
247//  @W = @W, @V;
248//  attrib(L, "isHomog", @W); 
249
250
251  // General setting:
252//  SetInducedReferrence(MRES, 0, 0); // limit: 0!
253  int @l = size(RES);
254
255  module M = RES[@l];
256
257  module L = attrib(basering, "InducionLeads");
258  int limit = attrib(basering, "InducionStart");
259
260//  L;  limit;
261 
262  int @RANK = ncols(MRES) - ncols(M); // nrows(M); // what if M is zero?!
263
264/*
265  if( @RANK !=  nrows(M) )
266  {
267    type(MRES);
268    @RANK;
269    type(M);
270    pause();
271  }
272*/
273 
274  intvec @W = attrib(M, "isHomog");
275  intvec @V = deg(M[1..ncols(M)]);
276  @V = @W, @V;
277   
278  if( @DEBUG )
279  {
280    "Sstep::NextInput: ";
281    M;
282    deg(M[1..ncols(M)]); // no use of @W :(?
283    @RANK;   
284    DetailedPrint(MRES);
285    attrib(MRES, "isHomog"); @W;
286    deg(MRES[1..ncols(MRES)]);
287  }
288
289 
290     
291  SetInducedReferrence(L, limit, 0);
292 
293  def K = prepareSyz(M, @RANK);
294//  K;
295 
296//   attrib(K, "isHomog", @V);   DetailedPrint(K, 1000);
297
298//  pause();
299 
300  K = idPrepare(K, @RANK); // std(K); // ?
301  K = simplify(K, 2);
302
303//  K;
304
305  module N = separateSyzGB(K, @RANK)[2]; // 1^st syz. module: vectors which start in lower part (comp >= @RANK)
306
307// "N_0: "; N; DetailedPrint(N, 10);
308
309//  basering; print(@V); type(N);
310//  attrib(N, "isHomog", @V);  // TODO: fix "wrong weights"!!!? deg is wrong :(((
311  N = std(N);
312  attrib(N, "isHomog", @V);
313
314//  N;
315 
316  if( @DEBUG )
317  {
318    if( size(N) > 0 )
319    {
320      // next syz. property
321      if( size(module(transpose( transpose(N) * transpose(MRES) ))) > 0 )
322      {
323        MRES;
324
325        "N: "; N; DetailedPrint(N, 10);
326
327        "K:"; K; DetailedPrint(K, 10);
328
329        "RANKS: ", @RANK;
330
331        "transpose( transpose(N) * transpose(MRES) ) != 0!!!";
332        transpose( transpose(N) * transpose(MRES) );
333
334        "transpose(N) * transpose(MRES): ";
335        transpose(N) * transpose(MRES);
336        DetailedPrint(module(_), 2);
337        $
338      }
339    }
340  }
341 
342  RES[@l + 1] = N; // list of all syzygy modules
343 
344  MRES = MRES, N;
345  attrib(MRES, "isHomog", @V);
346
347
348  L = L, lead(N);
349  attrib(basering, "InducionLeads", L);
350
351  if( @DEBUG )
352  {
353    "Sstep::NextSyzOutput: ";
354    DetailedPrint(N);
355    attrib(N, "isHomog");
356  }
357
358}
359
360proc Scontinue(int l)
361"USAGE:  Scontinue(int len)
362RETURN:  nothing, instead it changes the currently active resolution
363PURPOSE: extends the currently active resolution by at most len syzygies
364ASSUME:  must be used within a ring returned by Sres or Ssyz
365EXAMPLE: example Scontinue; shows an example
366"
367{
368  def data = GetInducedData();
369           
370  if( (!defined(RES)) || (!defined(MRES)) || (typeof(data) != "list") || (size(data) != 2) )
371  {
372    ERROR("Sorry, but basering does not seem to be returned by Sres or Ssyz");
373  }
374  for (;  (l != 0) && (size(RES[size(RES)]) > 0); l-- )
375  {
376    Sstep();
377  }
378}
379example
380{ "EXAMPLE:"; echo = 2;
381  ring r;
382  module M = maxideal(1); M;
383  def S = Ssyz(M); setring S; S;
384  "Only the first syzygy: ";
385  RES; MRES;
386  "More syzygies: ";
387  Scontinue(10);
388  RES; MRES;
389}
390
391proc Ssyz(module M)
392"USAGE:  Ssyz(module M)
393RETURN:  ring, containing a Schreyer resolution
394PURPOSE: computes a Schreyer resolution of M of length 1 (see the library overview)
395SEE ALSO: Sres
396EXAMPLE: example Ssyz; shows an example
397"
398{
399  def S = Sinit(M); setring S;
400 
401  Sstep(); // NOTE: what if M is zero?
402
403  return (S);
404}
405example
406{ "EXAMPLE:"; echo = 2;
407  ring r;
408  module M = maxideal(1); M;
409  def S = Ssyz(M); setring S; S;
410  "Only the first syzygy: ";
411  RES;
412  MRES; // Note gen(i)
413  kill S;
414  setring r; kill M;
415
416  module M = 0;
417  def S = Ssyz(M); setring S; S;
418  "Only the first syzygy: ";
419  RES;
420  MRES;
421}
422
423proc Sres(module M, int l)
424"USAGE:  Sres(module M, int len)
425RETURN:  ring, containing a Schreyer resolution
426PURPOSE: computes a Schreyer resolution of M of length at most len (see the library overview)
427NOTE:    If given len is zero then nvars(basering) + 1 is used instead.
428SEE ALSO: Ssyz
429EXAMPLE: example Sres; shows an example
430"
431{
432  def S = Sinit(M); setring S;
433
434  if (l == 0)
435  {
436    l = nvars(basering) + 1; // not really an estimate...?!
437  }
438 
439  Sstep(); l = l - 1;
440 
441  Scontinue(l);
442 
443  return (S);
444}
445example
446{ "EXAMPLE:"; echo = 2;
447  ring r;
448  module M = maxideal(1); M;
449  def S = Sres(M, 0); setring S; S;
450  RES;
451  MRES;
452  kill S;
453  setring r; kill M;
454
455  def A = nc_algebra(-1,0); setring A;
456  ideal Q = var(1)^2, var(2)^2, var(3)^2;
457  qring SCA = twostd(Q);
458  basering;
459
460  module M = maxideal(1);
461  def S = Sres(M, 2); setring S; S;
462  RES;
463  MRES;
464}
465
466
467
468// ================================================================== //
469
470
471LIB "general.lib"; // for sort
472
473/* static proc Tail(def M) // DONE: in C++ (dyn. module: syzextra)!
474{
475  int i = ncols(M); def m;
476  while (i > 0)
477  {
478    m = M[i];
479    m = m - lead(m); // m = tail(m)   
480    M[i] = m;   
481    i--;
482  }
483  return (M);
484}*/
485
486/* static */
487proc MySort(def M)
488{
489  if( typeof( attrib(basering, "DEBUG") ) == "int" )
490  {
491    int @DEBUG = attrib(basering, "DEBUG");
492  } else
493  {
494    int @DEBUG = !system("with", "ndebug");
495  }
496
497  if( typeof( attrib(basering, "KERCHECK") ) == "int" )
498  {
499    int @KERCHECK = attrib(basering, "KERCHECK");
500  } else
501  {
502    int @KERCHECK = @DEBUG; // TODO: @SYZCHECK:(
503  }
504
505
506  if( @DEBUG )
507  {
508    "MySort:: Input: "; M;
509  }
510
511  def @N = M;
512 
513  if( size(M) > 0 )
514  {
515    Sort_c_ds(@N);
516
517    if( @KERCHECK )
518    {
519      def iv = sort(lead(M), "c,ds", 1)[2]; // ,1 => reversed! // TODO: not needed?
520      def @M = M;
521      @M = M[iv];
522
523      // 0^th syz. property
524      if( (size(@N) + size(@M)) > 0 )
525      {
526        if( size(module( matrix(module(matrix(@N))) - matrix(module(matrix(@M))) )) > 0 )
527        {
528          "ERROR: MySort: wrong sorting in 'MySort': @N != @M!!!";
529         
530          "@M:"; @M;
531          "@N:"; @N;
532
533          "module( matrix(module(matrix(@N))) - matrix(module(matrix(@M))) ): ";
534          module( matrix(module(matrix(@N))) - matrix(module(matrix(@M))) );
535
536          "ERROR: MySort: wrong sorting in 'MySort': @N != @M!!!";
537          $
538        }
539      }
540    }
541  }
542
543  if( @DEBUG )
544  {
545    "MySort:: Ouput: "; @N;
546  }
547 
548  return (@N);
549}
550
551
552/* static */ proc SSinit(def M)
553{
554  if( (typeof(M) != "module") && (typeof(M) != "ideal") )
555  {
556    ERROR("Sorry: need an ideal or a module for input");
557  }
558
559  // TODO! DONE?
560  def @save = basering;
561 
562  int @DEBUG = !system("with", "ndebug");
563
564  if( typeof( attrib(SSinit, "DEBUG") ) == "int" )
565  {
566    @DEBUG = attrib(SSinit, "DEBUG");
567  }
568
569  int @SYZCHECK = @DEBUG;
570
571  if( typeof( attrib(SSinit, "SYZCHECK") ) == "int" )
572  {
573    @SYZCHECK = attrib(SSinit, "SYZCHECK");
574  }
575
576  int @KERCHECK = @SYZCHECK;
577
578  if( typeof( attrib(SSinit, "KERCHECK") ) == "int" )
579  {
580    @KERCHECK = attrib(SSinit, "KERCHECK");
581  }
582
583  if( @DEBUG )
584  {
585    "SSinit::Input";
586    type(M);
587//    DetailedPrint(M);
588    attrib(M);
589  }
590
591  int @RANK = nrows(M); int @SIZE = ncols(M);
592
593  int @IS_A_SB = attrib(M, "isSB"); // ??? only if all weights were zero?!
594
595  if( !@IS_A_SB )
596  {
597    def opts = option(get);
598    option(redSB); option(redTail);
599    M = std(M);
600    option(set, opts);
601    kill opts;
602  } else
603  {
604    M = simplify(M, 2 + 4 + 32);
605  }
606
607  def @N = MySort(M); // TODO: replace with inplace sorting!!!
608  def LEAD = lead(@N);
609
610  if( @SYZCHECK )
611  {
612    def @LEAD = lead(M);
613
614    // sort wrt neg.deg.rev.lex!
615    intvec iv_ds = sort(@LEAD, "c,ds", 1)[2]; // ,1 => reversed!
616
617    M = M[iv_ds]; // sort M wrt ds on current leading terms
618    @LEAD = @LEAD[iv_ds];
619
620    // 0^th syz. property
621    if( size(module( matrix(@N) - matrix(M) )) > 0 )
622    {
623      "M:"; M;
624      "@N:"; @N;
625
626      "module( matrix(@N) - matrix(M) ): ";
627      module( matrix(@N) - matrix(M) );
628
629      "ERROR: wrong sorting (in SSnit): @N != M!!!";
630      $
631    }
632
633    // 0^th syz. property
634    if( size(module( matrix(@LEAD) - matrix(LEAD) )) > 0 )
635    {
636      "LEAD:"; LEAD;
637      "@LEAD:"; @LEAD;
638
639      "module( matrix(@LEAD) - matrix(LEAD) ): ";
640      module( matrix(@LEAD) - matrix(LEAD) );
641
642      "ERROR: wrong sorting (in SSnit): @LEAD != LEAD!!!";
643      $
644    }
645   
646  }
647
648  M = @N;
649 
650 
651 
652 
653  def TAIL = Tail(M);
654 
655  intvec @DEGS = deg(M[1..@SIZE]); // store actuall degrees of input elements
656 
657  // TODO: what about real modules? weighted ones?
658 
659  list @l = ringlist(@save);
660
661  int @z = 0; ideal @m = maxideal(1); intvec @wdeg = deg(@m[1..ncols(@m)]);
662
663  // NOTE: @wdeg will be ignored anyway :(
664  @l[3] = list(list("C", @z), list("lp", @wdeg));
665
666  kill @z, @wdeg; // since these vars are ring independent!
667
668  def S = ring(@l); // --MakeInducedSchreyerOrdering(1);
669
670  module F = freemodule(@RANK);
671  intvec @V = deg(F[1..@RANK]);
672 
673  setring S; // ring with an easy divisibility test ("C, lex")
674
675  if( @DEBUG )
676  {
677    "SSinit::NewRing(C, lex)";
678    basering;
679    DetailedPrint(basering);
680  }
681
682  // Setup the leading syzygy^{-1} module to zero:
683  module Z = 0; Z[@RANK] = 0; attrib(Z, "isHomog", intvec(0)); 
684
685  module MRES = Z;
686 
687  list RES;  RES[1] = Z;
688  list LRES; LRES[1] = Z;
689  list TRES; TRES[1] = Z;
690 
691  def M = imap(@save, M);
692
693  attrib(M, "isHomog", @V);
694  attrib(M, "isSB", 1);
695  attrib(M, "degrees", @DEGS); 
696 
697  def LEAD = imap(@save, LEAD);
698 
699  attrib(LEAD, "isHomog", @V);
700  attrib(LEAD, "isSB", 1); 
701 
702  def TAIL = imap(@save, TAIL);
703
704  if( @DEBUG )
705  {
706    "SSinit::(sorted) SB_Input: ";
707    type(M);
708    attrib(M);
709    attrib(M, "isHomog");
710//    DetailedPrint(M);
711  }
712
713  if( @SYZCHECK )
714  {
715    // 0^th syz. property
716    if( size(module(transpose( transpose(M) * transpose(MRES) ))) > 0 )
717    {
718      transpose( transpose(M) * transpose(MRES) );
719      "ERROR: transpose( transpose(M) * transpose(MRES) ) != 0!!!";
720      $
721    }
722  }
723
724  RES [size(RES)+1] = M; // list of all syzygy modules
725  LRES[size(LRES)+1] = LEAD; // list of all syzygy modules
726  TRES[size(TRES)+1] = TAIL; // list of all syzygy modules
727 
728  MRES = MRES, M; //?
729
730  attrib(MRES, "isHomog", @V);
731 
732//  attrib(S, "InducionStart", @RANK);
733
734
735  if( typeof( attrib(SSinit, "LEAD2SYZ") ) == "int" )
736  {
737    attrib(S, "LEAD2SYZ", attrib(SSinit, "LEAD2SYZ") );
738  } else
739  {
740    attrib(S, "LEAD2SYZ", 1);
741  }
742
743  if( typeof( attrib(SSinit, "TAILREDSYZ") ) == "int" )
744  {
745    attrib(S, "TAILREDSYZ", attrib(SSinit, "TAILREDSYZ") );
746  } else
747  {
748    attrib(S, "TAILREDSYZ", 1);
749  }
750
751
752  if( typeof( attrib(SSinit, "HYBRIDNF") ) == "int" )
753  {
754    attrib(S, "HYBRIDNF", attrib(SSinit, "HYBRIDNF") );
755  } else
756  {
757    attrib(S, "HYBRIDNF", 0);
758  }
759 
760  attrib(S, "DEBUG", @DEBUG);
761  attrib(S, "SYZCHECK", @SYZCHECK);
762  attrib(S, "KERCHECK", @KERCHECK);
763 
764  if( @DEBUG )
765  {
766    "SSinit::MRES";
767    MRES;
768//    DetailedPrint(MRES);
769    attrib(MRES, "isHomog");
770    attrib(S);
771  }
772
773  export RES;
774  export MRES;
775  export LRES;
776  export TRES;
777  return (S);
778}
779example
780{ "EXAMPLE:"; echo = 2;
781  ring R = 0, (w, x, y, z), dp;
782
783  def M = maxideal(1);
784  def S = SSinit(M); setring S; S;
785 
786  "Only the first initialization: ";
787  RES; LRES; TRES;
788  MRES;
789
790  kill S; setring R; kill M;
791 
792  ideal M = w^2 - x*z,  w*x - y*z,  x^2 - w*y, x*y - z^2, y^2 - w*z;
793  def S = SSinit(M); setring S; S;
794
795  "Only the first initialization: ";
796  RES; LRES; TRES;
797  MRES;
798
799  kill S; setring R; kill M;
800}
801
802
803LIB "poly.lib"; // for lcm
804
805
806
807/// Compute L(Syz(L))
808proc SSComputeLeadingSyzygyTerms(def L)
809{
810  if( typeof( attrib(basering, "DEBUG") ) == "int" )
811  {
812    int @DEBUG = attrib(basering, "DEBUG");
813  } else
814  {
815    int @DEBUG = !system("with", "ndebug");
816  }
817
818  if( typeof( attrib(basering, "SYZCHECK") ) == "int" )
819  {
820    int @SYZCHECK = attrib(basering, "SYZCHECK");
821  } else
822  {
823    int @SYZCHECK = @DEBUG;
824  }
825
826  if( typeof( attrib(basering, "KERCHECK") ) == "int" )
827  {
828    int @KERCHECK = attrib(basering, "KERCHECK");
829  } else
830  {
831    int @KERCHECK = @SYZCHECK;
832  }
833
834  if( @DEBUG )
835  {
836    "SSComputeLeadingSyzygyTerms::Input: ";
837    L;
838  }
839
840  module SS = ComputeLeadingSyzygyTerms(L);
841
842  if( @KERCHECK )
843  { 
844    int i, j, r;
845    int N = ncols(L);
846    def a, b;
847    poly aa, bb;
848
849    bigint c;
850
851    ideal M;
852
853    module S = 0;
854
855    for(i = 1; i <= N; i++)
856    {
857      a = L[i];
858      c = leadcomp(a);
859      r = int(c);
860
861      aa = leadmonomial(a);
862
863      M = 0;
864
865      for(j = i-1; j > 0; j--)
866      {
867        b = L[j];
868
869        if( leadcomp(b) == c )
870        {
871          bb = leadmonomial(b);
872
873          M[j] = (lcm(aa, bb) / aa);
874        }
875      }
876
877      // TODO: add quotient relations here...
878
879      M = simplify(M, 1 + 2 + 32);
880
881      M = MySort(M);
882
883      S = S, M * gen(i);
884    }
885
886    S = MySort(simplify(S, 2));
887
888    if( (size(S) + size(SS)) > 0 )
889    {
890    if( size(module(matrix(S) - matrix(SS))) > 0 )
891    {
892        "ERROR: SSComputeLeadingSyzygyTerms: S != SS ";
893
894        "basering: ";
895        DetailedPrint(basering);
896
897        "S: ";  S;
898        DetailedPrint(S, 1);
899        "SS: "; SS;
900        DetailedPrint(SS, 1);
901
902        "DIFF: ";
903        print(matrix(S) - matrix(SS));
904        DetailedPrint(module(matrix(S) - matrix(SS)), 2);     
905        $
906    }
907    }
908  }
909
910 
911  if( @DEBUG )
912  {
913    "SSComputeLeadingSyzygyTerms::Output: ";
914    "SS: ";
915    SS;
916  }
917 
918  if( size(SS) > 0 )
919  {
920    attrib(SS, "isSB", 1);
921  }
922 
923  return (SS);
924}
925
926/// Compute Syz(L), where L is a monomial (leading) module
927proc SSCompute2LeadingSyzygyTerms(def L)
928{
929  if( typeof( attrib(basering, "DEBUG") ) == "int" )
930  {
931    int @DEBUG = attrib(basering, "DEBUG");
932  } else
933  {
934    int @DEBUG = !system("with", "ndebug");
935  }
936
937  if( typeof( attrib(basering, "SYZCHECK") ) == "int" )
938  {
939    int @SYZCHECK = attrib(basering, "SYZCHECK");
940  } else
941  {
942    int @SYZCHECK = @DEBUG;
943  }
944
945  if( typeof( attrib(basering, "KERCHECK") ) == "int" )
946  {
947    int @KERCHECK = attrib(basering, "KERCHECK");
948  } else
949  {
950    int @KERCHECK = @SYZCHECK;
951  }
952
953  int @TAILREDSYZ = 1;
954  if( typeof( attrib(basering, "TAILREDSYZ") ) == "int" )
955  {
956    @TAILREDSYZ = attrib(basering, "TAILREDSYZ");
957  }
958 
959 
960  if( @DEBUG )
961  {
962    "SSCompute2LeadingSyzygyTerms::Input: ";
963    L;
964  }
965
966  module SS = Compute2LeadingSyzygyTerms(L);
967
968  if( @DEBUG )
969  {
970    "SSCompute2LeadingSyzygyTerms::Syz(SS): "; SS;
971  }
972 
973  if( @SYZCHECK )
974  {
975    if( size(SS) > 0 and size(L) > 0 )
976    {
977      if( size(module(transpose( transpose(SS) * transpose(L) ))) > 0 )
978      {
979        transpose( transpose(SS) * transpose(L) );
980        "ERROR: transpose( transpose(SS) * transpose(L) ) != 0!!!";
981        $
982      }
983    }
984  }
985   
986  if( @KERCHECK )
987  {
988
989    int i, j, r;
990    int N = ncols(L);
991    def a, b;
992
993    poly aa, bb, @lcm;
994
995    bigint c;
996
997    module M;
998
999    module S = 0;
1000
1001    for(i = 1; i <= N; i++)
1002    {
1003      a = L[i];
1004  //    "a: ", a;
1005      c = leadcomp(a);
1006      r = int(c);
1007
1008      aa = leadmonomial(a);
1009
1010      M = 0;
1011
1012      for(j = i-1; j > 0; j--)
1013      {
1014        b = L[j];
1015  //      "b: ", b;
1016
1017        if( leadcomp(b) == c )
1018        {
1019          bb = leadmonomial(b);
1020          @lcm = lcm(aa, bb);
1021
1022          M[j] = (@lcm / aa)* gen(i) - (@lcm / bb)* gen(j);
1023        }
1024      }
1025
1026      M = simplify(M, 2);
1027
1028      // TODO: add quotient relations here...
1029      S = S, M;
1030    }
1031
1032    if( @TAILREDSYZ )
1033    {
1034      // Make sure that 2nd syzygy terms are not reducible by 1st
1035      def opts = option(get);
1036      option(redSB); option(redTail);
1037      S = std(S); // binomial module
1038      option(set, opts);
1039      //  kill opts;
1040    } else
1041    {
1042      S = simplify(S, 2 + 32);
1043    }
1044
1045    S = MySort(S);
1046
1047    if( @DEBUG )
1048    {
1049      "SSCompute2LeadingSyzygyTerms::Syz(S): "; S;
1050    }
1051
1052    if( size(module(matrix(S) - matrix(SS))) > 0 )
1053    {
1054      "ERROR: SSCompute2LeadingSyzygyTerms: S != SS ";
1055
1056      "basering: ";
1057      DetailedPrint(basering);
1058
1059      "S: ";  S;
1060      DetailedPrint(S, 2);
1061      "SS: "; SS;
1062      DetailedPrint(SS, 2);
1063
1064      "DIFF: ";
1065      print(matrix(S) - matrix(SS));
1066      DetailedPrint(module(matrix(S) - matrix(SS)), 4);
1067      $
1068    }
1069  }
1070 
1071  module S2 = Tail(SS);
1072  SS = lead(SS); // (C,lp) on base ring!
1073             
1074  if( @DEBUG )
1075  {
1076    "SSCompute2LeadingSyzygyTerms::Output: "; SS; S2;
1077  } 
1078 
1079  attrib(SS, "isSB", 1);
1080
1081  return (SS, S2);
1082}
1083
1084// -------------------------------------------------------- //
1085
1086/// TODO: save shortcut (syz: |-.->) LM(LM(m) * "t") -> syz?
1087proc SSFindReducer(def product, def syzterm, def L/*, def T*/, list #)
1088{
1089  if( typeof( attrib(basering, "DEBUG") ) == "int" )
1090  {
1091    int @DEBUG = attrib(basering, "DEBUG");
1092  } else
1093  {
1094    int @DEBUG = !system("with", "ndebug");
1095  }
1096
1097
1098  if( @DEBUG )
1099  {
1100    "SSFindReducer::Input: ";
1101
1102    "syzterm: ", syzterm;
1103    "product: ", product;
1104    "L: ", L;
1105//    "T: ", T;
1106    if( size(#) > 0 )
1107    {
1108      "LSyz: ", #;
1109    }
1110  }
1111
1112
1113  if( typeof( attrib(basering, "SYZCHECK") ) == "int" )
1114  {
1115    int @SYZCHECK = attrib(basering, "SYZCHECK");
1116  } else
1117  {
1118    int @SYZCHECK = @DEBUG;
1119  }
1120 
1121  if( @SYZCHECK && (syzterm != 0) )
1122  {
1123    def @@c = leadcomp(syzterm); int @@r = int(@@c);
1124    def @@product = leadmonomial(syzterm) * L[@@r];
1125
1126    if( @@product != product)
1127    {
1128      "product: ", product, ", @@product: ", @@product;
1129      "ERROR: 'syzterm' results in wrong product !!!???";
1130      $
1131    }
1132  }
1133
1134  if( typeof(#[1]) == "module" )
1135  {
1136    vector my = FindReducer(product, syzterm, L/*, T*/, #[1]);
1137  } else
1138  {
1139    vector my = FindReducer(product, syzterm, L/*, T*/);
1140  }
1141 
1142
1143  if( @SYZCHECK )
1144  {
1145    bigint c = leadcomp(product); int r = int(c);
1146
1147    def a, b, bb;
1148
1149    vector nf = [0];
1150
1151    // looking for an appropriate diviser
1152    for( int k = ncols(L); k > 0; k-- )
1153    {
1154      a = L[k];
1155      // with the same mod. component
1156      if( leadcomp(a) == c )
1157      {
1158        b = - (leadmonomial(product) / leadmonomial(L[k]));
1159
1160        // which divides the product: looking for the 1st appropriate one!
1161        if( b != 0 )
1162        {
1163          bb = b * gen(k);
1164
1165          if (size(bb + syzterm) == 0) // cannot allow something like: a*gen(i) - a*gen(i)
1166          {
1167            nf = [0];
1168          } else
1169          {
1170            nf = bb;
1171          }
1172
1173          // new syz. term should not be in <LS = #>
1174          if( size(#) > 0 )
1175          {
1176            if( typeof(#[1]) == "module" )
1177            {
1178              nf = NF(bb, #[1]);
1179            }
1180          }
1181
1182          // while the complement (the fraction) is not reducible by leading syzygies
1183          if( nf != 0 ) // nf must be == bb!!!
1184          {
1185            /// TODO: save shortcut LM(m) * T[i] -> ?
1186
1187            // choose ANY such reduction... (with the biggest index?)
1188            break;
1189          }
1190        }
1191      }
1192    }
1193
1194    if( my != nf )
1195    {
1196      "ERROR in FindReducer => ", my, " != nf: ", nf;
1197      $;
1198    }
1199  }
1200
1201  if( @DEBUG )
1202  {
1203    "SSFindReducer::Output: ", my;
1204  }
1205 
1206  return (my);
1207}
1208
1209
1210
1211
1212
1213/// TODO: save shortcut (syz: |-.->) LM(m) * "t" -> ?
1214proc SSReduceTerm(poly m, def t, def syzterm, def L, def T, list #)
1215{
1216  if( typeof( attrib(basering, "DEBUG") ) == "int" )
1217  {
1218    int @DEBUG = attrib(basering, "DEBUG");
1219  } else
1220  {
1221    int @DEBUG = !system("with", "ndebug");
1222  }
1223
1224
1225  if( @DEBUG )
1226  {
1227    "SSReduce::Input: ";
1228
1229    "syzterm: ", syzterm;
1230    "mult: ", m;
1231    "term: ", t;
1232    "L: ", L;
1233    "T: ", T;
1234    if( size(#) > 0 )
1235    {
1236      "LSyz: ", #;
1237    }
1238//    "attrib(LS, 'isSB')", attrib(LS, "isSB");
1239  }
1240
1241
1242  if( typeof( attrib(basering, "SYZCHECK") ) == "int" )
1243  {
1244    int @SYZCHECK = attrib(basering, "SYZCHECK");
1245  } else
1246  {
1247    int @SYZCHECK = @DEBUG;
1248  }
1249
1250  if( @SYZCHECK && (syzterm != 0) )
1251  {
1252    def @@c = leadcomp(syzterm); int @@r = int(@@c);
1253    poly @@m = leadmonomial(syzterm); def @@t = L[@@r];
1254
1255    if( (@@m != m) || (@@t != t))
1256    {
1257      "m: ", m, ", t: ", t;
1258      "@@m: ", @@m, ", @@t: ", @@t;
1259      "ERROR: 'syzterm' results in wrong m * t !!!";
1260      $
1261    }
1262  }
1263
1264  vector s = [0];
1265
1266  if( size(t) > 0 )
1267  {
1268    def product = m * t;
1269
1270    s = SSFindReducer(product, syzterm, L/*, T*/, #);
1271
1272    if( size(s) != 0 )
1273    {
1274      poly b = leadmonomial(s);
1275
1276      def c = leadcomp(s); int k = int(c);
1277
1278      s = s + SSTraverseTail(b, T[k], L, T, #); // !!!   
1279    }
1280  }
1281   
1282  if( @DEBUG )
1283  {
1284    "SSReduceTerm::Output: ", s;
1285  }
1286 
1287  return (s);
1288}
1289
1290
1291// TODO: store m * @tail -.-^-.-^-.--> ?
1292proc SSTraverseTail(poly m, def @tail, def L, def T, list #)
1293{
1294  if( typeof( attrib(basering, "DEBUG") ) == "int" )
1295  {
1296    int @DEBUG = attrib(basering, "DEBUG");
1297  } else
1298  {
1299    int @DEBUG = !system("with", "ndebug");
1300  }
1301
1302  if( @DEBUG )
1303  {
1304    "SSTraverse::Input: ";
1305
1306    "mult: ", m;
1307    "tail: ", @tail; // T[i];
1308
1309    if( size(#) > 0 )
1310    {
1311      "LSyz: "; #[1];
1312    }
1313  }
1314
1315  vector s = 0;
1316
1317  def @l;
1318
1319  // iterate tail-terms in ANY order!
1320  while( size(@tail) > 0 )
1321  {
1322    @l = lead(@tail);
1323    s = s + SSReduceTerm(m, @l, [0], L, T, #); // :(
1324    @tail = @tail - @l;
1325  }
1326
1327  if( @DEBUG )
1328  {
1329    "SSTraverseTail::Output: ", s;
1330  }
1331  return (s);
1332}
1333
1334// -------------------------------------------------------- //
1335
1336// module (N, LL, TT) = SSComputeSyzygy(L, T);
1337// Compute Syz(L ++ T) = N = LL ++ TT
1338proc SSComputeSyzygy(def L, def T)
1339{
1340  if( typeof( attrib(basering, "DEBUG") ) == "int" )
1341  {
1342    int @DEBUG = attrib(basering, "DEBUG");
1343  } else
1344  {
1345    int @DEBUG = !system("with", "ndebug");
1346  }
1347
1348  if( typeof( attrib(basering, "SYZCHECK") ) == "int" )
1349  {
1350    int @SYZCHECK = attrib(basering, "SYZCHECK");
1351  } else
1352  {
1353    int @SYZCHECK = @DEBUG;
1354  }
1355 
1356 
1357  if( @DEBUG )
1358  {
1359    "SSComputeSyzygy::Input";
1360    "basering: ", basering; attrib(basering);
1361//    DetailedPrint(basering);
1362
1363//    "iCompShift: ", iCompShift;
1364
1365    "L: "; L;
1366    "T: "; T;
1367  }
1368
1369  def a; bigint c; int r, k; poly aa;
1370
1371  int @LEAD2SYZ = 0;
1372  if( typeof( attrib(basering, "LEAD2SYZ") ) == "int" )
1373  {
1374    @LEAD2SYZ = attrib(basering, "LEAD2SYZ");
1375  }
1376
1377  int @TAILREDSYZ = 1;
1378  if( typeof( attrib(basering, "TAILREDSYZ") ) == "int" )
1379  {
1380    @TAILREDSYZ = attrib(basering, "TAILREDSYZ");
1381  }
1382
1383  int @HYBRIDNF = 0;
1384  if( typeof( attrib(basering, "HYBRIDNF") ) == "int" )
1385  {
1386    @HYBRIDNF = attrib(basering, "HYBRIDNF");
1387  }
1388
1389  module LL;
1390  def a2; int r2; poly aa2; 
1391
1392  /// Get the critical leading syzygy terms
1393  if( @LEAD2SYZ ) // & 2nd syz. term
1394  {
1395    module LL2;
1396    (LL, LL2) = SSCompute2LeadingSyzygyTerms(L); // ++
1397  } else
1398  {
1399    LL = SSComputeLeadingSyzygyTerms(L);
1400  }
1401
1402  module TT, SYZ; def spoly;
1403
1404  if( size(LL) > 0 )
1405  {
1406    list LS;
1407
1408    if( @TAILREDSYZ)
1409    {
1410      LS = list(LL);
1411    }
1412
1413    vector @tail;
1414
1415    for(k = ncols(LL); k > 0; k-- )
1416    {
1417      // leading syz. term:
1418      a = LL[k]; c = leadcomp(a); r = int(c); aa = leadmonomial(a);
1419      //    "A: ", a, " --->>>> ", aa, " **** [", r, "]: ";
1420
1421      // NF reduction:
1422      if( !@HYBRIDNF )
1423      {
1424        /// TODO: save shortcut (aa) * T[r] -> ?
1425        @tail = SSTraverseTail(aa, T[r], L, T, LS);
1426  // //      @tail = SSTraverseTail(a, L, T, LS);
1427
1428        // get the 2nd syzygy term...
1429
1430        if( @LEAD2SYZ ) // with the 2nd syz. term:
1431        {     
1432          a2 = LL2[k]; c = leadcomp(a2); r2 = int(c); aa2 = leadmonomial(a2);
1433
1434          @tail = @tail + a2 +
1435               /// TODO: save shortcut (aa2) * T[r2] -> ?
1436               SSTraverseTail(aa2, T[r2], L, T, LS);
1437  // //               SSTraverseTail(a2, L, T, LS);
1438        } else
1439        {
1440          @tail = @tail +
1441                  SSReduceTerm(aa, L[r], a, L, T, LS);
1442  // //                  SSReduceTerm(a, L, T, LS);
1443        }
1444      } else
1445      {
1446        spoly = aa * T[r];
1447
1448        if( @LEAD2SYZ )
1449        {
1450          a2 = LL2[k];
1451        } else
1452        {
1453          a2 = SSFindReducer( aa * L[r], a, L/*, T*/, LS);
1454        }
1455
1456        if ( (@SYZCHECK || @DEBUG) )
1457        {
1458          if( size(a2) == 0 ) // if syzterm == 0!!!!
1459          {
1460            "ERROR: could not find the 2nd syzygy term during the hybrid NF!!!";
1461            $
1462          }
1463        }
1464       
1465        c = leadcomp(a2); r2 = int(c); aa2 = leadmonomial(a2);
1466       
1467        spoly = spoly + aa2 * T[r2];
1468        @tail = a2;
1469
1470        while (size(spoly) > 0)
1471        {
1472          a2 = SSFindReducer( lead(spoly), [0], L/*, T*/, LS);
1473          spoly = Tail(spoly);
1474
1475          if( size(a2) != 0)
1476          {         
1477            c = leadcomp(a2); r2 = int(c); aa2 = leadmonomial(a2);
1478
1479            spoly = spoly + aa2 * T[r2];
1480            @tail = @tail + a2;
1481          }
1482        }
1483       
1484      }
1485     
1486      TT[k] = @tail;
1487      SYZ[k] = a + @tail;
1488    }
1489  }
1490
1491  if( @DEBUG )
1492  {
1493    "SSComputeSyzygy::Output";
1494
1495    "SYZ: "; SYZ;
1496    "LL: "; LL;
1497    "TT: "; TT;
1498  }
1499
1500  return (SYZ, LL, TT);
1501}
1502
1503// resolution/syzygy step:
1504static proc SSstep()
1505{
1506  if( typeof( attrib(basering, "DEBUG") ) == "int" )
1507  {
1508    int @DEBUG = attrib(basering, "DEBUG");
1509  } else
1510  {
1511    int @DEBUG = !system("with", "ndebug");
1512  }
1513
1514
1515  if( typeof( attrib(basering, "SYZCHECK") ) == "int" )
1516  {
1517    int @SYZCHECK = attrib(basering, "SYZCHECK");
1518  } else
1519  {
1520    int @SYZCHECK = @DEBUG;
1521  }
1522
1523  if( @DEBUG )
1524  {
1525    "SSstep::NextInducedRing";
1526    "basering: ", basering; attrib(basering);
1527  }
1528
1529/*
1530  // is initial weights are all zeroes!
1531  def L =  lead(M);
1532  intvec @V = deg(M[1..ncols(M)]);  @W;  @V;  @W = @V;  attrib(L, "isHomog", @W); 
1533  SetInducedReferrence(L, @RANK, 0);
1534*/
1535
1536//  def L =  lead(MRES);
1537//  @W = @W, @V;
1538//  attrib(L, "isHomog", @W); 
1539
1540
1541  // General setting:
1542//  SetInducedReferrence(MRES, 0, 0); // limit: 0!
1543  int @l = size(RES);
1544
1545  def M =  RES[@l];
1546
1547  def L = LRES[@l];
1548  def T = TRES[@l];
1549
1550
1551  //// TODO: wrong !!!!!
1552  int @RANK = ncols(MRES) - ncols(M); // nrows(M); // what if M is zero?!
1553
1554 
1555
1556/*
1557  if( @RANK !=  nrows(M) )
1558  {
1559    type(MRES);
1560    @RANK;
1561    type(M);
1562    pause();
1563  }
1564*/
1565 
1566  intvec @W = attrib(M, "isHomog"); intvec @V = attrib(M, "degrees"); @V = @W, @V;
1567   
1568  if( @DEBUG )
1569  {
1570    "Sstep::NextInput: ";
1571    M;
1572    L;
1573    @V;
1574    @RANK;
1575//    DetailedPrint(MRES);
1576    attrib(MRES, "isHomog");
1577  }
1578
1579     
1580  // TODO: N  = SYZ( M )!!!
1581  module N, LL, TT;
1582  (N, LL, TT) = SSComputeSyzygy(/*M, */L, T/*, @RANK*/);
1583
1584  // shift syz.comp by @RANK:
1585  module Z;
1586  Z = 0; Z[@RANK] = 0; Z = Z, transpose(LL);   LL = transpose(Z);
1587  Z = 0; Z[@RANK] = 0; Z = Z, transpose(TT);   TT = transpose(Z);
1588  Z = 0; Z[@RANK] = 0; Z = Z, transpose(N);     N = transpose(Z);
1589
1590
1591  if( @SYZCHECK )
1592  {
1593    if( size(N) > 0 )
1594    {
1595      // next syz. property
1596      if( size(module(transpose( transpose(N) * transpose(MRES) ))) > 0 )
1597      {
1598        "MRES", MRES;
1599
1600        "N: "; N; // DetailedPrint(N, 2);
1601
1602        "LL:"; LL; // DetailedPrint(LL, 1);
1603        "TT:"; TT; // DetailedPrint(TT, 10);
1604
1605        "RANKS: ", @RANK;
1606
1607        "transpose( transpose(N) * transpose(MRES) ) != 0!!!";
1608        transpose( transpose(N) * transpose(MRES) );
1609
1610        "transpose(N) * transpose(MRES): ";
1611        transpose(N) * transpose(MRES);
1612        // DetailedPrint(module(_), 2);
1613        $
1614      }
1615    }
1616  }
1617
1618  attrib(N, "isHomog", @V);
1619
1620  // TODO: correct the following:
1621  intvec @DEGS = deg(N[1..ncols(N)]); // no mod. comp. weights :(
1622
1623 
1624  attrib(N, "degrees", @DEGS);
1625 
1626   RES[@l + 1] = N; // list of all syzygy modules
1627  LRES[@l + 1] = LL; // list of all syzygy modules
1628  TRES[@l + 1] = TT; // list of all syzygy modules
1629
1630  MRES = MRES, N;
1631 
1632  attrib(MRES, "isHomog", @V);
1633
1634//  L = L, lead(N);  attrib(basering, "InducionLeads", L);
1635
1636  if( @DEBUG )
1637  {
1638    "SSstep::NextSyzOutput: ";
1639    N;
1640//    DetailedPrint(N);
1641    attrib(N);
1642  }
1643
1644}
1645
1646proc SScontinue(int l)
1647"USAGE:  SScontinue(l)
1648RETURN:  nothing, instead it changes RES and MRES variables in the current ring
1649PURPOSE: computes further (at most l) syzygies
1650NOTE:    must be used within a ring returned by Sres or Ssyz. RES and MRES are
1651         explained in Sres
1652EXAMPLE: example Scontinue; shows an example
1653"
1654{
1655
1656  /// TODO!
1657//  def data = GetInducedData();
1658
1659  if( (!defined(RES)) || (!defined(MRES)) ) /* || (typeof(data) != "list") || (size(data) != 2) */
1660  {
1661    ERROR("Sorry, but basering does not seem to be returned by Sres or Ssyz");
1662  }
1663  for (;  (l != 0) && (size(RES[size(RES)]) > 0); l-- )
1664  {
1665    SSstep();
1666  }
1667}
1668example
1669{ "EXAMPLE:"; echo = 2;
1670  ring r;
1671  module M = maxideal(1); M;
1672  def S = SSsyz(M); setring S; S;
1673  "Only the first syzygy: ";
1674  RES; MRES;
1675  "More syzygies: ";
1676  SScontinue(10);
1677  RES; MRES;
1678}
1679
1680proc SSsyz(def M)
1681"USAGE:  SSsyz(M)
1682RETURN:  ring, containing a list of modules RES and a module MRES
1683PURPOSE: computes the first syzygy module of M (wrt some Schreyer ordering)?
1684NOTE:    The output is explained in Sres
1685EXAMPLE: example Ssyz; shows an example
1686"
1687{
1688  if( (typeof(M) != "module") && (typeof(M) != "ideal") )
1689  {
1690    ERROR("Sorry: need an ideal or a module for input");
1691  }
1692
1693  def SS = SSinit(M); setring SS;
1694 
1695  SSstep(); // NOTE: what if M is zero?
1696
1697  return (SS);
1698}
1699example
1700{ "EXAMPLE:"; echo = 2;
1701  ring r;
1702
1703/*  ideal M = 0;
1704  def S = SSsyz(M); setring S; S;
1705  "Only the first syzygy: ";
1706  RES; LRES; TRES;
1707  MRES;
1708 
1709  kill S; setring r; kill M;
1710*/ 
1711
1712  ideal M = maxideal(1); M;
1713
1714  def S = SSres(M, 0); setring S; S;
1715  MRES;
1716  print(_);
1717  RES;
1718
1719  kill S; setring r; kill M;
1720
1721  kill r;
1722 
1723  ring R = 0, (w, x, y, z), dp;
1724  ideal M = w^2 - x*z,  w*x - y*z,  x^2 - w*y, x*y - z^2, y^2 - w*z;
1725 
1726  def S = SSres(M, 0); setring S; S;
1727  "";
1728  LRES;
1729  "";
1730  TRES;
1731  "";
1732  MRES;
1733  print(_);
1734  RES;
1735}
1736
1737proc SSres(def M, int l)
1738"USAGE:  SSres(I, l)
1739RETURN:  ring, containing a list of modules RES and a module MRES
1740PURPOSE: computes (at most l) syzygy modules of M wrt the classical Schreyer
1741         induced ordering with gen(i) > gen(j) if i > j, provided both gens
1742         are from the same syzygy level.???
1743NOTE:    RES contains the images of maps subsituting the beginning of the
1744         Schreyer free resolution of baseRing^r/M, while MRES is a sum of
1745         these images in a big free sum, containing all the syzygy modules.
1746         The syzygy modules are shifted so that gen(i) correspons to MRES[i].
1747         The leading zero module RES[0] indicates the fact that coker of the
1748         first map is zero. The number of zeroes inducates the rank of input.
1749NOTE:    If l == 0 then l is set to be nvars(basering) + 1
1750EXAMPLE: example SSres; shows an example
1751"
1752{
1753  if( (typeof(M) != "module") && (typeof(M) != "ideal") )
1754  {
1755    ERROR("Sorry: need an ideal or a module for input");
1756  }
1757
1758  def SS = SSinit(M); setring SS;
1759
1760  if (l == 0)
1761  {
1762    l = nvars(basering) + 1; // not really an estimate...?!
1763  }
1764
1765  SSstep(); l = l - 1;
1766
1767  SScontinue(l);
1768
1769  return (SS);
1770}
1771example
1772{ "EXAMPLE:"; echo = 2;
1773  ring r;
1774  module M = maxideal(1); M;
1775  def S = SSres(M, 0); setring S; S;
1776  RES;
1777  MRES;
1778  kill S;
1779  setring r; kill M;
1780
1781  def A = nc_algebra(-1,0); setring A;
1782  ideal Q = var(1)^2, var(2)^2, var(3)^2;
1783  qring SCA = twostd(Q);
1784  basering;
1785
1786  module M = maxideal(1);
1787  def S = SSres(M, 2); setring S; S;
1788  RES;
1789  MRES;
1790}
1791
1792
1793
1794static proc loadme()
1795{
1796  int @DEBUG = !system("with", "ndebug");
1797
1798  if( @DEBUG )
1799  {
1800   
1801    "ndebug?: ", system("with", "ndebug");
1802    "om_ndebug?: ", system("with", "om_ndebug");
1803
1804    listvar(Top);
1805    listvar(Schreyer);
1806  }
1807//  listvar(Syzextra); listvar(Syzextra_g);
1808
1809  if( !defined(DetailedPrint) )
1810  {
1811    if( 1 )
1812    {
1813
1814      if( @DEBUG )
1815      {
1816        "Loading the Release version!";
1817      }
1818      load("syzextra.so");
1819
1820      if( @DEBUG )
1821      {
1822        listvar(Syzextra);
1823      }
1824
1825      exportto(Top, Syzextra::ClearContent);
1826      exportto(Top, Syzextra::ClearDenominators);
1827
1828      exportto(Schreyer, Syzextra::m2_end);
1829     
1830//      export Syzextra;
1831
1832//      exportto(Schreyer, Syzextra::noop);
1833      exportto(Schreyer, Syzextra::DetailedPrint);
1834      exportto(Schreyer, Syzextra::leadmonomial);
1835      exportto(Schreyer, Syzextra::leadcomp);
1836//      exportto(Schreyer, Syzextra::leadrawexp);
1837//      exportto(Schreyer, Syzextra::ISUpdateComponents);
1838      exportto(Schreyer, Syzextra::SetInducedReferrence);
1839      exportto(Schreyer, Syzextra::GetInducedData);
1840//      exportto(Schreyer, Syzextra::GetAMData);
1841//      exportto(Schreyer, Syzextra::SetSyzComp);
1842      exportto(Schreyer, Syzextra::MakeInducedSchreyerOrdering);
1843//      exportto(Schreyer, Syzextra::MakeSyzCompOrdering);
1844      exportto(Schreyer, Syzextra::idPrepare);
1845//      exportto(Schreyer, Syzextra::reduce_syz);
1846//      exportto(Schreyer, Syzextra::p_Content);
1847
1848      exportto(Schreyer, Syzextra::ProfilerStart); exportto(Schreyer, Syzextra::ProfilerStop);
1849
1850      exportto(Schreyer, Syzextra::Tail);
1851      exportto(Schreyer, Syzextra::ComputeLeadingSyzygyTerms);     
1852      exportto(Schreyer, Syzextra::Compute2LeadingSyzygyTerms);
1853      exportto(Schreyer, Syzextra::Sort_c_ds);
1854
1855      exportto(Schreyer, Syzextra::FindReducer);
1856    }
1857/*
1858    else
1859    {
1860      if( @DEBUG )
1861      {
1862        "Loading the Debug version!";
1863      }
1864
1865      load("syzextra.so");
1866
1867      if( @DEBUG )
1868      {     
1869        listvar(Syzextra_g);
1870      }
1871     
1872      exportto(Top, Syzextra_g::ClearContent);
1873      exportto(Top, Syzextra_g::ClearDenominators);
1874
1875      exportto(Schreyer, Syzextra_g::m2_end);
1876
1877//      export Syzextra_g;
1878//      exportto(Schreyer, Syzextra_g::noop);
1879      exportto(Schreyer, Syzextra_g::DetailedPrint);
1880      exportto(Schreyer, Syzextra_g::leadmonomial);
1881      exportto(Schreyer, Syzextra_g::leadcomp);
1882//      exportto(Schreyer, Syzextra_g::leadrawexp);
1883//      exportto(Schreyer, Syzextra_g::ISUpdateComponents);
1884      exportto(Schreyer, Syzextra_g::SetInducedReferrence);
1885      exportto(Schreyer, Syzextra_g::GetInducedData);
1886//      exportto(Schreyer, Syzextra_g::GetAMData);
1887//      exportto(Schreyer, Syzextra_g::SetSyzComp);
1888      exportto(Schreyer, Syzextra_g::MakeInducedSchreyerOrdering);
1889//      exportto(Schreyer, Syzextra_g::MakeSyzCompOrdering);
1890      exportto(Schreyer, Syzextra_g::idPrepare);
1891//      exportto(Schreyer, Syzextra_g::reduce_syz);
1892//      exportto(Schreyer, Syzextra_g::p_Content);
1893
1894      exportto(Schreyer, Syzextra_g::ProfilerStart); exportto(Schreyer, Syzextra_g::ProfilerStop);
1895
1896      exportto(Schreyer, Syzextra_g::Tail);
1897      exportto(Schreyer, Syzextra_g::ComputeLeadingSyzygyTerms);
1898      exportto(Schreyer, Syzextra_g::Compute2LeadingSyzygyTerms);
1899      exportto(Schreyer, Syzextra_g::Sort_c_ds);
1900
1901      exportto(Schreyer, Syzextra_g::FindReducer);
1902     
1903    }
1904*/
1905
1906    exportto(Top, DetailedPrint);
1907    exportto(Top, GetInducedData);
1908
1909    if( @DEBUG )
1910    {
1911      listvar(Top);
1912      listvar(Schreyer);
1913    }
1914  }
1915 
1916  if( !defined(GetInducedData) )
1917  {
1918    ERROR("Sorry but we are missing the dynamic module (syzextra.so)...");
1919  }
1920
1921}
1922
1923static proc mod_init()
1924{
1925  loadme();
1926}
1927
1928
1929proc testallSexamples()
1930{
1931  example Ssyz;
1932  example Scontinue;
1933  example Sres; 
1934}
1935
1936proc testallSSexamples()
1937{
1938  example SSsyz;
1939  example SScontinue;
1940  example SSres; 
1941}
1942
1943example
1944{ "EXAMPLE:"; echo = 2;
1945  testallSexamples();
1946  testallSSexamples();
1947}
1948
1949proc TestSSres(def M)
1950{
1951  "-------------------------------------";
1952  "options: ", attrib(SSinit, "LEAD2SYZ"), attrib(SSinit, "TAILREDSYZ"), attrib(SSinit, "HYBRIDNF"), ": ";
1953  int t = timer;
1954  def S = SSres(M, 0);
1955  int tt = timer;
1956/*
1957  setring S;
1958 
1959  MRES;
1960  RES;
1961  "";
1962  LRES;
1963  "";
1964  TRES;
1965*/ 
1966  kill S;
1967 "0-----------------------------------0 => ", tt - t;
1968}
1969
1970
1971proc TestSSresAttribs(def M)
1972{
1973
1974  // the following 2 setups are bad for AGR@101n3d002s004%1:(((
1975//  attrib(SSinit, "LEAD2SYZ", 0); attrib(SSinit, "TAILREDSYZ", 0); attrib(SSinit, "HYBRIDNF", 0); TestSSres(M);
1976//  attrib(SSinit, "LEAD2SYZ", 0); attrib(SSinit, "TAILREDSYZ", 0); attrib(SSinit, "HYBRIDNF", 1); TestSSres(M);
1977
1978  attrib(SSinit, "LEAD2SYZ", 0); attrib(SSinit, "TAILREDSYZ", 1); attrib(SSinit, "HYBRIDNF", 0); TestSSres(M);
1979  attrib(SSinit, "LEAD2SYZ", 0); attrib(SSinit, "TAILREDSYZ", 1); attrib(SSinit, "HYBRIDNF", 1); TestSSres(M);
1980
1981  attrib(SSinit, "LEAD2SYZ", 1); attrib(SSinit, "TAILREDSYZ", 0); attrib(SSinit, "HYBRIDNF", 0); TestSSres(M);
1982  attrib(SSinit, "LEAD2SYZ", 1); attrib(SSinit, "TAILREDSYZ", 0); attrib(SSinit, "HYBRIDNF", 1); TestSSres(M);
1983
1984  attrib(SSinit, "LEAD2SYZ", 1); attrib(SSinit, "TAILREDSYZ", 1); attrib(SSinit, "HYBRIDNF", 0); TestSSres(M);
1985  attrib(SSinit, "LEAD2SYZ", 1); attrib(SSinit, "TAILREDSYZ", 1); attrib(SSinit, "HYBRIDNF", 1); TestSSres(M);
1986}
1987
1988
1989proc testALLA()
1990{
1991  attrib(SSinit, "SYZCHECK", 1); // TODO: only for now!!
1992  attrib(SSinit, "KERCHECK", 0); // TODO: only for now!!
1993
1994  ring r; r; ideal M = maxideal(1); M;
1995  TestSSresAttribs(M); 
1996  kill r;
1997
1998  ring r = 0, (a, b, c, d), lp; r; ideal M = maxideal(1); M;
1999  TestSSresAttribs(M); 
2000  kill r;
2001
2002  ring R = 0, (w, x, y, z), dp; R;
2003  ideal M = w^2 - x*z,  w*x - y*z,  x^2 - w*y, x*y - z^2, y^2 - w*z; M;
2004  TestSSresAttribs(M); 
2005  kill R;
2006
2007 
2008  ring AGR = (101), (a, b, c, d), dp; AGR;
2009  // simple: AGR@101n3d002s004%1:
2010  ideal M = c*d, b*d, a*d, c^2-d^2, b*c, a*c, b^2-d^2, a*b, a^2-d^2;
2011  M;
2012  TestSSresAttribs(M);
2013
2014
2015  // medium: AGR@101n3d004s009%1;
2016  ideal M = a*b+7*a*c-16*b*c-27*a*d+37*b*d-2*c*d, d^3, c*d^2, b*d^2, a*d^2, c^2*d, b*c*d, a*c*d, b^2*d, a^2*d, c^3, b*c^2, a*c^2, b^2*c, a^2*c, b^3, a^3;
2017  M;
2018  TestSSresAttribs(M);
2019
2020  /*
2021  // lengthy: AGR@101n3d008s058%3, toooo long!!! :((((
2022  ideal M = c^4*d^2+4*a^3*d^3+29*a^2*b*d^3-2*a*b^2*d^3+2*b^3*d^3-21*a^2*c*d^3+46*a*b*c*d^3+2*b^2*c*d^3-13*a*c^2*d^3+32*b*c^2*d^3+46*c^3*d^3-28*a^2*d^4+4*a*b*d^4+29*b^2*d^4-8*a*c*d^4+33*b*c*d^4-16*c^2*d^4+17*a*d^5-3*b*d^5-42*c*d^5+47*d^6,b*c^3*d^2+35*a^3*d^3+24*a^2*b*d^3+46*a*b^2*d^3-22*b^3*d^3-48*a^2*c*d^3+20*a*b*c*d^3-28*b^2*c*d^3-40*a*c^2*d^3-4*b*c^2*d^3+35*c^3*d^3-21*a^2*d^4+3*a*b*d^4+8*b^2*d^4-2*a*c*d^4-22*b*c*d^4+24*c^2*d^4+44*a*d^5+33*b*d^5+31*c*d^5+26*d^6,a*c^3*d^2-42*a^3*d^3+34*a^2*b*d^3-10*a*b^2*d^3+30*b^3*d^3-6*a^2*c*d^3-30*a*b*c*d^3-34*b^2*c*d^3+29*a*c^2*d^3+35*b*c^2*d^3+13*c^3*d^3+8*a^2*d^4+23*a*b*d^4-29*b^2*d^4+12*a*c*d^4-22*b*c*d^4-50*c^2*d^4-4*b*d^5+9*c*d^5+13*d^6,b^2*c^2*d^2+a^3*d^3-49*a^2*b*d^3+26*a*b^2*d^3+20*b^3*d^3+24*a^2*c*d^3-2*a*b*c*d^3+31*b^2*c*d^3-30*a*c^2*d^3+21*b*c^2*d^3-24*c^3*d^3-38*a^2*d^4-14*a*b*d^4-14*b^2*d^4+6*a*c*d^4+3*b*c*d^4+13*c^2*d^4-11*a*d^5-38*b*d^5+22*c*d^5+48*d^6,a*b*c^2*d^2+18*a^3*d^3-29*a^2*b*d^3-21*a*b^2*d^3-2*b^3*d^3-25*a^2*c*d^3+37*a*b*c*d^3-14*b^2*c*d^3-47*a*c^2*d^3-6*b*c^2*d^3-34*c^3*d^3+43*a^2*d^4+22*a*b*d^4-39*b^2*d^4-41*a*c*d^4-17*b*c*d^4-13*c^2*d^4-43*a*d^5+28*b*d^5-42*c*d^5-49*d^6,a^2*c^2*d^2-33*a^3*d^3+30*a^2*b*d^3-13*a*b^2*d^3+18*b^3*d^3-8*a^2*c*d^3-18*a*b*c*d^3-15*b^2*c*d^3-21*a*c^2*d^3+45*b*c^2*d^3-35*c^3*d^3-4*a^2*d^4-4*a*b*d^4+10*b^2*d^4-19*a*c*d^4-18*b*c*d^4-22*c^2*d^4-27*a*d^5+20*b*d^5-14*c*d^5+24*d^6,b^3*c*d^2-10*a^3*d^3+37*a*b^2*d^3-43*b^3*d^3-10*a^2*c*d^3-9*a*b*c*d^3+47*a*c^2*d^3-24*b*c^2*d^3+12*c^3*d^3+7*a^2*d^4+19*a*b*d^4-27*b^2*d^4-2*a*c*d^4-35*b*c*d^4+45*c^2*d^4-44*a*d^5-43*b*d^5+24*c*d^5+16*d^6,a*b^2*c*d^2+2*a^3*d^3-14*a^2*b*d^3+2*a*b^2*d^3+18*b^3*d^3-48*a^2*c*d^3+43*a*b*c*d^3-25*b^2*c*d^3+15*a*c^2*d^3-7*b*c^2*d^3+42*c^3*d^3-16*a^2*d^4+7*b^2*d^4-23*a*c*d^4+24*b*c*d^4+25*c^2*d^4-17*a*d^5-16*b*d^5-32*c*d^5-50*d^6,a^2*b*c*d^2-16*a^3*d^3+7*a^2*b*d^3-20*a*b^2*d^3+11*b^3*d^3+16*a^2*c*d^3+6*a*b*c*d^3-25*b^2*c*d^3+42*a*c^2*d^3-39*b*c^2*d^3-15*c^3*d^3-25*a^2*d^4+46*a*b*d^4-3*b^2*d^4+5*a*c*d^4+28*b*c*d^4+6*c^2*d^4-20*a*d^5-15*b*d^5-30*c*d^5+17*d^6,a^3*c*d^2+39*a^3*d^3+22*a^2*b*d^3-21*a*b^2*d^3+10*b^3*d^3+40*a^2*c*d^3-37*a*b*c*d^3+11*b^2*c*d^3+43*a*c^2*d^3+28*b*c^2*d^3-10*c^3*d^3+30*a^2*d^4+36*a*b*d^4-45*b^2*d^4-40*a*c*d^4-31*b*c*d^4+28*c^2*d^4+35*a*d^5+6*b*d^5+14*c*d^5+25*d^6,b^4*d^2+50*a^3*d^3+12*a^2*b*d^3+29*a*b^2*d^3-38*b^3*d^3-44*a^2*c*d^3+28*a*b*c*d^3+18*b^2*c*d^3-31*a*c^2*d^3+16*b*c^2*d^3-18*c^3*d^3+5*a^2*d^4-43*a*b*d^4+16*b^2*d^4+9*a*c*d^4-30*b*c*d^4+50*c^2*d^4+3*a*d^5+33*b*d^5+3*c*d^5-48*d^6,a*b^3*d^2+13*a^3*d^3-28*a^2*b*d^3-33*a*b^2*d^3-25*b^3*d^3-41*a^2*c*d^3+a*b*c*d^3+19*b^2*c*d^3+41*a*c^2*d^3-17*b*c^2*d^3+34*c^3*d^3-10*a^2*d^4+30*a*b*d^4+34*b^2*d^4+13*a*c*d^4+b*c*d^4-35*c^2*d^4-34*a*d^5+23*b*d^5-7*c*d^5+6*d^6,a^2*b^2*d^2+22*a^3*d^3-32*a^2*b*d^3+29*a*b^2*d^3+21*b^3*d^3-30*a^2*c*d^3-47*a*b*c*d^3-11*b^2*c*d^3-16*a*c^2*d^3-14*b*c^2*d^3+49*c^3*d^3+47*a^2*d^4-11*a*b*d^4+4*b^2*d^4+13*a*c*d^4+7*b*c*d^4-30*c^2*d^4+31*a*d^5+10*b*d^5-8*c*d^5-27*d^6,a^3*b*d^2-43*a^3*d^3-2*a^2*b*d^3+15*a*b^2*d^3+42*b^3*d^3+25*a^2*c*d^3+22*a*b*c*d^3-4*b^2*c*d^3-29*a*c^2*d^3-31*b*c^2*d^3-3*c^3*d^3+33*a^2*d^4+20*a*b*d^4-34*b^2*d^4+8*a*c*d^4+48*b*c*d^4-29*c^2*d^4-46*a*d^5+27*b*d^5+29*c*d^5+33*d^6,a^4*d^2+30*a^3*d^3-42*a*b^2*d^3-16*b^3*d^3-33*a^2*c*d^3+13*a*b*c*d^3+7*b^2*c*d^3-23*a*c^2*d^3+28*b*c^2*d^3-37*c^3*d^3+3*a^2*d^4-34*a*b*d^4+16*b^2*d^4-21*a*c*d^4-39*b*c*d^4+5*c^2*d^4+35*a*d^5+39*b*d^5-26*c*d^5-47*d^6,c^5*d+48*a^3*d^3-37*a^2*b*d^3+31*a*b^2*d^3-19*b^3*d^3+49*a^2*c*d^3-5*a*b*c*d^3+45*b^2*c*d^3+24*a*c^2*d^3-26*b*c^2*d^3-10*c^3*d^3-a^2*d^4+43*a*b*d^4-26*b^2*d^4+45*a*c*d^4-3*b*c*d^4+38*c^2*d^4+10*a*d^5-5*b*d^5-34*c*d^5+22*d^6,b*c^4*d+30*a^3*d^3-40*a^2*b*d^3-39*a*b^2*d^3+33*b^3*d^3+31*a^2*c*d^3-17*a*b*c*d^3-44*b^2*c*d^3+24*a*c^2*d^3+22*b*c^2*d^3-44*c^3*d^3-29*a^2*d^4+4*a*b*d^4-4*b^2*d^4+8*a*c*d^4-42*b*c*d^4+15*c^2*d^4-42*a*d^5+15*b*d^5-41*c*d^5-46*d^6,a*c^4*d-11*a^3*d^3-5*a^2*b*d^3+33*a*b^2*d^3+7*b^3*d^3-31*a^2*c*d^3-47*a*b*c*d^3-50*b^2*c*d^3-50*a*c^2*d^3-39*b*c^2*d^3+25*c^3*d^3+5*a^2*d^4+35*a*b*d^4-34*b^2*d^4+42*a*c*d^4-44*b*c*d^4-17*c^2*d^4+11*a*d^5+b*d^5+31*c*d^5+45*d^6,b^2*c^3*d+12*a^3*d^3-41*a^2*b*d^3+29*a*b^2*d^3-42*b^3*d^3-32*a^2*c*d^3+47*a*b*c*d^3-13*b^2*c*d^3-20*a*c^2*d^3+45*b*c^2*d^3-49*c^3*d^3-34*a^2*d^4+16*a*b*d^4+11*b^2*d^4-49*a*c*d^4-27*b*c*d^4-31*c^2*d^4+29*a*d^5-23*b*d^5+13*c*d^5+42*d^6,a*b*c^3*d-16*a^3*d^3-35*a^2*b*d^3+12*a*b^2*d^3-39*b^3*d^3-32*a*b*c*d^3-4*b^2*c*d^3+31*a*c^2*d^3+43*b*c^2*d^3-42*c^3*d^3+36*a^2*d^4-5*a*b*d^4-4*b^2*d^4+5*a*c*d^4+20*b*c*d^4+31*c^2*d^4+15*a*d^5+25*b*d^5-16*c*d^5-28*d^6,a^2*c^3*d-16*a^3*d^3+8*a^2*b*d^3+30*a*b^2*d^3-16*b^3*d^3+20*a^2*c*d^3-11*b^2*c*d^3-48*a*c^2*d^3+11*b*c^2*d^3-20*c^3*d^3-24*a^2*d^4-23*a*b*d^4+9*b^2*d^4+13*a*c*d^4-42*b*c*d^4+22*c^2*d^4-29*a*d^5-28*b*d^5-7*c*d^5-2*d^6,b^3*c^2*d+42*a^3*d^3-11*a^2*b*d^3+18*a*b^2*d^3-13*b^3*d^3+22*a^2*c*d^3-10*a*b*c*d^3-25*b^2*c*d^3-17*a*c^2*d^3-23*b*c^2*d^3-37*c^3*d^3-3*a^2*d^4-33*a*b*d^4+44*b^2*d^4-41*a*c*d^4+6*b*c*d^4-36*c^2*d^4-43*a*d^5+b*d^5+25*c*d^5+48*d^6,a*b^2*c^2*d+21*a^3*d^3+5*a^2*b*d^3+38*a*b^2*d^3+25*b^3*d^3-12*a^2*c*d^3+7*a*b*c*d^3+28*b^2*c*d^3+a*c^2*d^3+33*b*c^2*d^3+22*c^3*d^3+10*a^2*d^4-7*a*b*d^4-5*b^2*d^4+50*a*c*d^4-23*b*c*d^4+22*c^2*d^4-4*a*d^5+45*b*d^5-42*c*d^5+d^6,a^2*b*c^2*d-45*a^3*d^3+2*a^2*b*d^3+44*a*b^2*d^3-5*b^3*d^3-19*a^2*c*d^3-3*a*b*c*d^3+18*b^2*c*d^3-22*a*c^2*d^3+46*b*c^2*d^3+41*c^3*d^3-26*a^2*d^4-a*b*d^4-42*b^2*d^4-40*a*c*d^4+39*b*c*d^4+24*c^2*d^4-6*a*d^5-6*b*d^5+13*c*d^5-28*d^6,a^3*c^2*d+4*a^3*d^3+31*a^2*b*d^3+21*a*b^2*d^3+39*b^3*d^3-8*a^2*c*d^3+49*a*b*c*d^3-48*b^2*c*d^3-16*a*c^2*d^3-33*b*c^2*d^3+35*c^3*d^3+41*a^2*d^4+18*a*b*d^4+47*b^2*d^4-3*a*c*d^4+12*b*c*d^4+13*c^2*d^4+32*a*d^5-40*b*d^5+50*c*d^5-2*d^6,b^4*c*d+23*a^3*d^3+47*a^2*b*d^3-10*a*b^2*d^3-43*b^3*d^3+49*a^2*c*d^3+7*a*b*c*d^3+34*b^2*c*d^3-40*a*c^2*d^3-37*b*c^2*d^3-6*c^3*d^3+30*a^2*d^4-34*a*b*d^4-6*b^2*d^4+21*a*c*d^4+41*b*c*d^4-33*c^2*d^4-9*a*d^5+2*b*d^5+8*c*d^5+7*d^6,a*b^3*c*d-5*a^3*d^3-42*a^2*b*d^3+22*a*b^2*d^3-35*b^3*d^3+a^2*c*d^3+20*a*b*c*d^3-10*b^2*c*d^3+23*a*c^2*d^3-17*b*c^2*d^3+30*c^3*d^3+24*a^2*d^4+32*a*b*d^4-7*b^2*d^4-48*a*c*d^4-25*b*c*d^4-6*c^2*d^4-33*a*d^5+29*b*d^5+12*c*d^5+26*d^6,a^2*b^2*c*d+6*a^3*d^3-46*a^2*b*d^3-30*a*b^2*d^3+b^3*d^3-35*a^2*c*d^3+41*a*b*c*d^3-4*b^2*c*d^3-42*a*c^2*d^3+16*b*c^2*d^3+19*c^3*d^3-13*a^2*d^4-16*a*b*d^4+45*b^2*d^4-25*a*c*d^4-48*b*c*d^4+35*c^2*d^4+50*a*d^5+31*b*d^5-25*c*d^5+6*d^6,a^3*b*c*d+3*a^3*d^3-39*a^2*b*d^3+14*a*b^2*d^3-4*b^3*d^3-36*a^2*c*d^3+47*a*b*c*d^3+27*b^2*c*d^3+50*a*c^2*d^3-45*b*c^2*d^3+49*c^3*d^3-18*a^2*d^4+20*a*b*d^4+17*b^2*d^4+a*c*d^4+33*b*c*d^4+42*c^2*d^4+19*a*d^5+18*b*d^5+33*c*d^5+15*d^6,a^4*c*d-14*a^3*d^3-8*a^2*b*d^3-a*b^2*d^3-34*b^3*d^3-27*a^2*c*d^3-15*a*b*c*d^3-14*b^2*c*d^3+33*a*c^2*d^3-34*b*c^2*d^3-4*c^3*d^3+47*a^2*d^4+50*a*b*d^4-6*b^2*d^4+16*a*c*d^4+26*c^2*d^4-27*a*d^5+2*b*d^5-31*c*d^5+47*d^6,b^5*d+3*a^3*d^3-9*a^2*b*d^3+46*a*b^2*d^3+b^3*d^3-2*a^2*c*d^3-39*a*b*c*d^3-31*b^2*c*d^3-30*a*c^2*d^3+23*b*c^2*d^3+25*c^3*d^3+9*a^2*d^4-15*a*b*d^4-2*b^2*d^4-12*a*c*d^4+11*b*c*d^4+9*c^2*d^4+3*a*d^5+9*b*d^5+41*c*d^5-38*d^6,a*b^4*d-48*a^3*d^3+42*a^2*b*d^3+27*a*b^2*d^3+32*b^3*d^3+21*a^2*c*d^3-5*a*b*c*d^3-39*b^2*c*d^3+6*a*c^2*d^3-20*b*c^2*d^3+45*c^3*d^3-48*a^2*d^4+44*a*b*d^4+25*b^2*d^4-29*a*c*d^4+4*b*c*d^4+50*c^2*d^4-6*a*d^5-40*b*d^5-11*c*d^5-28*d^6,a^2*b^3*d-41*a^3*d^3+21*a^2*b*d^3+39*a*b^2*d^3-2*b^3*d^3+24*a*b*c*d^3-10*b^2*c*d^3+31*a*c^2*d^3-34*b*c^2*d^3-31*c^3*d^3+20*a^2*d^4+41*a*b*d^4-10*b^2*d^4-40*a*c*d^4+5*b*c*d^4+31*c^2*d^4+6*a*d^5+26*b*d^5+29*c*d^5-5*d^6,a^3*b^2*d-11*a^3*d^3-39*a^2*b*d^3+2*a*b^2*d^3-44*b^3*d^3-23*a^2*c*d^3+21*a*b*c*d^3-44*b^2*c*d^3-7*a*c^2*d^3+49*b*c^2*d^3+46*c^3*d^3+17*a^2*d^4+49*a*b*d^4-14*b^2*d^4+29*a*c*d^4-20*b*c*d^4-49*c^2*d^4-13*a*d^5-41*b*d^5-18*c*d^5+50*d^6,a^4*b*d+9*a^3*d^3+50*a^2*b*d^3+46*a*b^2*d^3-48*b^3*d^3+43*a^2*c*d^3-45*a*b*c*d^3+24*b^2*c*d^3-4*a*c^2*d^3-b*c^2*d^3-34*c^3*d^3+33*a^2*d^4+14*a*b*d^4-37*b^2*d^4-13*a*c*d^4+48*b*c*d^4-31*c^2*d^4-22*a*d^5+42*b*d^5+49*c*d^5-43*d^6,a^5*d+33*a^3*d^3-23*a^2*b*d^3+30*a*b^2*d^3+5*b^3*d^3-26*a^2*c*d^3-35*a*b*c*d^3-50*b^2*c*d^3-21*a*c^2*d^3+4*b*c^2*d^3+10*c^3*d^3+39*a^2*d^4-2*a*b*d^4+23*b^2*d^4+17*a*c*d^4-50*b*c*d^4-8*c^2*d^4-39*a*d^5+36*b*d^5-43*c*d^5-39*d^6,c^6+20*a^3*d^3-41*a*b^2*d^3+39*b^3*d^3+26*a^2*c*d^3-8*a*b*c*d^3-49*b^2*c*d^3+25*a*c^2*d^3+32*b*c^2*d^3-32*c^3*d^3-2*a^2*d^4-38*a*b*d^4-38*b^2*d^4+17*a*c*d^4+22*b*c*d^4-36*c^2*d^4-41*a*d^5+37*b*d^5-49*c*d^5-19*d^6,b*c^5-36*a^3*d^3+32*a^2*b*d^3-14*a*b^2*d^3-31*b^3*d^3-2*a^2*c*d^3-8*a*b*c*d^3-39*b^2*c*d^3-46*a*c^2*d^3+10*b*c^2*d^3+27*c^3*d^3+25*a^2*d^4-30*a*b*d^4+3*b^2*d^4-36*a*c*d^4+44*b*c*d^4+17*c^2*d^4-46*a*d^5-37*b*d^5-2*c*d^5-47*d^6,a*c^5-49*a^3*d^3+11*a^2*b*d^3-21*a*b^2*d^3-14*b^3*d^3+26*a^2*c*d^3-a*b*c*d^3+24*b^2*c*d^3-46*a*c^2*d^3+23*b*c^2*d^3+33*c^3*d^3-11*a^2*d^4-a*b*d^4+49*b^2*d^4-17*a*c*d^4+49*b*c*d^4+36*c^2*d^4+10*a*d^5-19*b*d^5+26*c*d^5-32*d^6,b^2*c^4-14*a^3*d^3+9*a^2*b*d^3-5*a*b^2*d^3+17*b^3*d^3+2*a^2*c*d^3+12*a*b*c*d^3-37*b^2*c*d^3-43*a*c^2*d^3+5*b*c^2*d^3-9*c^3*d^3-27*a^2*d^4+14*a*b*d^4-19*b^2*d^4+29*a*c*d^4+32*b*c*d^4-15*c^2*d^4-26*a*d^5-31*b*d^5+46*c*d^5-22*d^6,a*b*c^4+33*a^3*d^3-22*a^2*b*d^3-14*a*b^2*d^3-30*b^3*d^3-48*a^2*c*d^3+34*a*b*c*d^3-8*b^2*c*d^3-44*a*c^2*d^3-4*b*c^2*d^3+3*c^3*d^3+26*a^2*d^4+4*a*b*d^4+7*b^2*d^4-28*a*c*d^4-22*b*c*d^4-35*c^2*d^4-50*a*d^5-43*b*d^5+46*c*d^5-49*d^6,a^2*c^4-9*a^3*d^3+3*a^2*b*d^3+34*a*b^2*d^3+4*b^3*d^3+5*a^2*c*d^3-17*a*b*c*d^3-48*b^2*c*d^3+10*a*c^2*d^3+2*b*c^2*d^3-12*c^3*d^3-7*a^2*d^4-6*a*b*d^4+37*b^2*d^4-16*a*c*d^4+47*b*c*d^4+6*c^2*d^4-35*a*d^5-45*b*d^5-12*c*d^5-30*d^6,b^3*c^3-21*a^3*d^3-6*a^2*b*d^3-26*a*b^2*d^3-22*b^3*d^3-29*a*b*c*d^3-26*b^2*c*d^3+50*a*c^2*d^3-41*b*c^2*d^3+22*c^3*d^3-41*a^2*d^4+25*a*b*d^4+16*b^2*d^4+11*a*c*d^4+34*b*c*d^4+19*c^2*d^4-38*a*d^5-8*b*d^5-42*c*d^5-6*d^6,a*b^2*c^3+3*a^3*d^3-45*a^2*b*d^3+39*a*b^2*d^3+22*b^3*d^3+48*a^2*c*d^3-7*a*b*c*d^3-46*b^2*c*d^3-22*a*c^2*d^3-17*b*c^2*d^3-27*c^3*d^3-35*a^2*d^4+47*a*b*d^4+6*b^2*d^4-5*a*c*d^4-30*b*c*d^4+25*c^2*d^4-10*a*d^5+46*b*d^5+5*c*d^5-18*d^6,a^2*b*c^3-36*a^3*d^3+33*a^2*b*d^3+47*a*b^2*d^3-16*b^3*d^3-41*a^2*c*d^3+42*a*b*c*d^3-29*b^2*c*d^3+39*a*c^2*d^3-12*b*c^2*d^3-25*c^3*d^3-11*a^2*d^4-37*a*b*d^4+29*b^2*d^4-18*a*c*d^4+43*b*c*d^4+12*c^2*d^4-37*a*d^5+7*b*d^5+7*c*d^5-5*d^6,a^3*c^3+25*a^3*d^3+34*a^2*b*d^3+29*a*b^2*d^3-34*b^3*d^3-46*a^2*c*d^3-17*a*b*c*d^3+49*b^2*c*d^3-35*a*c^2*d^3-21*b*c^2*d^3-45*c^3*d^3+43*a^2*d^4+29*a*b*d^4+36*b^2*d^4+37*a*c*d^4+12*b*c*d^4-17*c^2*d^4+12*a*d^5+47*c*d^5-23*d^6,b^4*c^2-10*a^3*d^3+38*a^2*b*d^3+33*a*b^2*d^3+9*b^3*d^3-25*a^2*c*d^3+38*a*b*c*d^3-19*b^2*c*d^3-33*a*c^2*d^3-49*b*c^2*d^3-16*c^3*d^3-14*a^2*d^4-3*a*b*d^4-30*b^2*d^4-32*a*c*d^4+28*b*c*d^4-3*c^2*d^4-16*a*d^5+31*b*d^5-49*c*d^5-3*d^6,a*b^3*c^2+25*a^3*d^3-47*a^2*b*d^3+47*b^3*d^3+13*a^2*c*d^3-17*a*b*c*d^3+26*b^2*c*d^3-43*a*c^2*d^3+39*b*c^2*d^3-4*c^3*d^3+20*a^2*d^4+6*a*b*d^4+49*b^2*d^4+14*a*c*d^4-17*b*c*d^4+38*c^2*d^4+21*a*d^5-9*b*d^5-26*c*d^5+47*d^6,a^2*b^2*c^2+12*a^3*d^3+10*a^2*b*d^3-40*a*b^2*d^3+14*b^3*d^3+36*a^2*c*d^3-9*a*b*c*d^3+9*b^2*c*d^3+7*a*c^2*d^3+12*b*c^2*d^3-37*c^3*d^3-44*a^2*d^4-48*a*b*d^4+11*b^2*d^4-13*a*c*d^4+31*b*c*d^4+47*c^2*d^4+28*a*d^5+39*b*d^5+27*c*d^5-d^6,a^3*b*c^2-28*a^3*d^3-22*a^2*b*d^3-8*a*b^2*d^3+40*b^3*d^3-13*a^2*c*d^3+35*a*b*c*d^3-4*b^2*c*d^3+28*a*c^2*d^3+30*b*c^2*d^3-13*c^3*d^3+16*a^2*d^4+48*a*b*d^4-42*b^2*d^4+10*a*c*d^4-b*c*d^4+37*c^2*d^4-17*a*d^5-15*b*d^5+40*c*d^5+27*d^6,a^4*c^2+17*a^3*d^3+45*a^2*b*d^3+42*a*b^2*d^3-20*b^3*d^3-39*a^2*c*d^3-20*a*b*c*d^3-44*b^2*c*d^3+33*a*c^2*d^3+39*b*c^2*d^3-37*c^3*d^3+39*a^2*d^4+39*a*b*d^4-44*b^2*d^4+8*a*c*d^4-34*b*c*d^4+36*c^2*d^4-47*a*d^5+38*b*d^5-46*c*d^5+23*d^6,b^5*c+24*a^3*d^3+17*a^2*b*d^3-22*a*b^2*d^3-27*b^3*d^3+27*a^2*c*d^3+48*a*b*c*d^3+4*b^2*c*d^3+a*c^2*d^3-21*b*c^2*d^3-14*c^3*d^3+3*a^2*d^4+15*a*b*d^4+41*b^2*d^4-27*a*c*d^4+4*b*c*d^4+3*c^2*d^4-46*a*d^5+28*b*d^5+6*c*d^5+36*d^6,a*b^4*c-29*a^3*d^3+30*a^2*b*d^3+31*a*b^2*d^3+44*b^3*d^3-12*a^2*c*d^3-27*a*b*c*d^3+48*b^2*c*d^3+4*a*c^2*d^3+2*b*c^2*d^3-17*c^3*d^3-7*a^2*d^4+25*a*b*d^4-45*b^2*d^4-17*a*c*d^4-14*b*c*d^4-11*c^2*d^4-45*a*d^5-36*b*d^5-12*c*d^5-44*d^6,a^2*b^3*c-10*a^3*d^3-30*a^2*b*d^3-22*a*b^2*d^3-35*b^3*d^3+37*a^2*c*d^3-35*a*b*c*d^3-12*b^2*c*d^3-16*b*c^2*d^3+49*c^3*d^3+38*a^2*d^4-21*a*b*d^4-20*b^2*d^4-6*a*c*d^4+41*b*c*d^4+49*c^2*d^4+13*a*d^5-38*b*d^5-32*c*d^5-12*d^6,a^3*b^2*c+5*a^2*b*d^3-40*a*b^2*d^3+14*b^3*d^3-4*a^2*c*d^3-13*a*b*c*d^3+47*b^2*c*d^3+28*a*c^2*d^3+15*b*c^2*d^3+47*c^3*d^3-8*a^2*d^4-20*a*b*d^4+3*b^2*d^4+42*a*c*d^4+18*b*c*d^4-23*c^2*d^4-48*a*d^5+12*b*d^5-25*c*d^5-39*d^6,a^4*b*c+29*a^3*d^3+21*a^2*b*d^3-32*a*b^2*d^3+48*b^3*d^3-44*a^2*c*d^3-3*a*b*c*d^3-27*b^2*c*d^3+27*a*c^2*d^3+43*b*c^2*d^3-30*c^3*d^3+4*a^2*d^4+16*a*b*d^4+33*b^2*d^4+37*a*c*d^4-32*b*c*d^4+14*c^2*d^4+50*a*d^5-49*c*d^5-33*d^6,a^5*c-26*a^3*d^3-50*a^2*b*d^3+2*a*b^2*d^3+3*b^3*d^3-15*a^2*c*d^3-32*a*b*c*d^3-4*b^2*c*d^3-13*a*c^2*d^3-13*b*c^2*d^3+3*c^3*d^3+32*a^2*d^4-32*a*b*d^4-47*b^2*d^4-39*a*c*d^4-34*b*c*d^4-9*c^2*d^4-7*a*d^5-22*b*d^5+16*c*d^5+44*d^6,b^6+45*a^3*d^3-42*a^2*b*d^3-35*a*b^2*d^3+13*b^3*d^3+28*a^2*c*d^3-2*a*b*c*d^3-37*b^2*c*d^3-9*a*c^2*d^3+44*b*c^2*d^3-24*c^3*d^3+36*a^2*d^4+42*a*b*d^4-38*b^2*d^4-34*a*c*d^4-46*b*c*d^4+23*c^2*d^4-9*a*d^5-28*b*d^5+37*c*d^5+26*d^6,a*b^5-14*a^3*d^3+38*a^2*b*d^3-37*a*b^2*d^3-33*b^3*d^3-24*a^2*c*d^3+15*a*b*c*d^3+44*b^2*c*d^3-45*a*c^2*d^3+3*b*c^2*d^3-41*c^3*d^3-48*a^2*d^4-36*a*b*d^4+39*b^2*d^4+46*a*c*d^4-3*b*c*d^4+21*c^2*d^4-36*a*d^5-20*b*d^5+24*c*d^5-33*d^6,a^2*b^4-27*a^3*d^3-10*a^2*b*d^3-5*a*b^2*d^3+8*b^3*d^3+21*a^2*c*d^3+31*a*b*c*d^3-44*b^2*c*d^3+41*a*c^2*d^3+17*b*c^2*d^3-8*c^3*d^3+19*a^2*d^4+25*a*b*d^4+b^2*d^4+3*a*c*d^4+2*b*c*d^4-40*c^2*d^4+31*a*d^5-19*b*d^5+35*c*d^5-28*d^6,a^3*b^3-12*a^3*d^3-25*a^2*b*d^3+37*a*b^2*d^3-37*b^3*d^3+46*a^2*c*d^3+43*a*b*c*d^3+b^2*c*d^3-41*a*c^2*d^3-38*b*c^2*d^3-36*c^3*d^3-11*a*b*d^4+20*b^2*d^4-a*c*d^4-26*b*c*d^4+14*c^2*d^4-48*a*d^5+17*b*d^5+9*c*d^5+30*d^6,a^4*b^2+36*a^3*d^3+9*a^2*b*d^3-31*b^3*d^3+50*a^2*c*d^3+41*a*b*c*d^3+40*b^2*c*d^3+48*a*c^2*d^3-41*b*c^2*d^3-17*c^3*d^3+33*a^2*d^4+47*a*b*d^4+22*b^2*d^4+2*a*c*d^4+23*b*c*d^4-47*c^2*d^4+34*a*d^5-15*b*d^5-33*c*d^5-38*d^6,a^5*b-12*a^3*d^3-38*a^2*b*d^3+46*a*b^2*d^3-32*b^3*d^3-41*a^2*c*d^3+14*a*b*c*d^3-34*b^2*c*d^3+7*a*c^2*d^3-6*b*c^2*d^3+31*c^3*d^3+30*a^2*d^4+12*a*b*d^4-17*b^2*d^4-7*a*c*d^4-45*b*c*d^4+10*c^2*d^4+29*a*d^5-28*b*d^5+34*c*d^5-15*d^6,a^6-33*a^3*d^3-45*a^2*b*d^3+19*a*b^2*d^3+39*b^3*d^3-5*a^2*c*d^3-46*a*b*c*d^3+9*b^2*c*d^3+15*a*c^2*d^3-21*b*c^2*d^3+46*c^3*d^3-39*a^2*d^4-9*a*b*d^4+50*b^2*d^4-45*a*c*d^4-39*b*c*d^4-18*c^2*d^4-4*a*d^5-19*b*d^5+12*c*d^5+39*d^6,d^7,c*d^6,b*d^6,a*d^6,c^2*d^5,b*c*d^5,a*c*d^5,b^2*d^5,a*b*d^5,a^2*d^5,c^3*d^4,b*c^2*d^4,a*c^2*d^4,b^2*c*d^4,a*b*c*d^4,a^2*c*d^4,b^3*d^4,a*b^2*d^4,a^2*b*d^4,a^3*d^4;
2023  M;
2024  TestSSresAttribs(M);
2025*/ 
2026  kill AGR;
2027
2028  ring r = 0, (a, b, c, d, e, f), dp; r; ideal M = maxideal(1); M;
2029  TestSSresAttribs(M); 
2030  kill r; 
2031}
2032
2033// TODO: betti!!!
Note: See TracBrowser for help on using the repository browser.