Changeset 178bd3 in git


Ignore:
Timestamp:
Dec 17, 2018, 7:56:25 AM (5 years ago)
Author:
Karim Abou Zeid <karim23697@…>
Branches:
(u'spielwiese', 'e7cc1ebecb61be8b9ca6c18016352af89940b21a')
Children:
c7231560b85e2e1683beb9629db0560ee8ca4255
Parents:
04d263ab0fcd4cc5a8215c12fdf4423b782d3283ee3e7cd650e2cf6d6e770d6b57b1681594c7cda7
Message:
Merge branch 'spielwiese' into christmas-release
Files:
1 added
54 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/fpadim.lib

    ree3e7cd r178bd3  
    132132"PURPOSE: Checks, if all the Assumptions are holding
    133133"
    134 {if (attrib(basering,"isLetterplaceRing")==0) {ERROR("Basering is not a Letterplace ring!");}
    135   if (d > attrib(basering,"uptodeg")) {ERROR("Specified degree bound exceeds ring parameter!");}
     134{if (!isFreeAlgebra(basering)) {ERROR("Basering is not a Letterplace ring!");}
     135  if (d > lpDegBound(basering)) {ERROR("Specified degree bound exceeds ring parameter!");}
    136136  int i;
    137137  for (i = 1; i <= size(L); i++)
    138   {if (entryViolation(L[i], attrib(basering,"isLetterplaceRing")))
     138  {if (entryViolation(L[i], lpBlockSize(basering)))
    139139    {ERROR("Not allowed monomial/intvec found!");}
    140140  }
    … …  
    907907  // construct the Graph of normal words [Studzinski page 78]
    908908  // construct set of vertices
    909   int v = attrib(basering,"isLetterplaceRing"); int d = attrib(basering,"uptodeg");
     909  int v = lpBlockSize(basering); int d = lpDegBound(basering);
    910910  ideal V; poly p,q,w;
    911911  ideal LG = lead(G);
    … …  
    16911691EXAMPLE: example lpDHilbert; shows examples
    16921692"
    1693 {int degbound = attrib(basering,"uptodeg");int n = attrib(basering, "isLetterplaceRing");
     1693{int degbound = lpDegBound(basering);int n = lpBlockSize(basering);
    16941694  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
    16951695  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
    … …  
    17331733EXAMPLE: example lpDHilbertSickle; shows examples
    17341734"
    1735 {int degbound = attrib(basering,"uptodeg");int n = attrib(basering, "isLetterplaceRing");
     1735{int degbound = lpDegBound(basering);int n = lpBlockSize(basering);
    17361736  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
    17371737  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
    … …  
    17781778SEE ALSO: ncHilb_lib
    17791779"
    1780 {int degbound = attrib(basering,"uptodeg");int n = attrib(basering, "isLetterplaceRing");
     1780{int degbound = lpDegBound(basering);int n = lpBlockSize(basering);
    17811781  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
    17821782  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
    … …  
    18091809EXAMPLE: example lpKDimCheck; shows examples
    18101810"
    1811 {int n = attrib(basering,"isLetterplaceRing");
     1811{int n = lpBlockSize(basering);
    18121812  list L;
    18131813  ideal R;
    … …  
    18441844EXAMPLE: example lpKDim; shows examples
    18451845"
    1846 {int degbound = attrib(basering, "uptodeg");int n = attrib(basering, "isLetterplaceRing");
     1846{int degbound = lpDegBound(basering);int n = lpBlockSize(basering);
    18471847  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
    18481848  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
    … …  
    19481948EXAMPLE: example lpSickle; shows examples
    19491949"
    1950 {int degbound = attrib(basering,"uptodeg"); int n = attrib(basering, "isLetterplaceRing");
     1950{int degbound = lpDegBound(basering); int n = lpBlockSize(basering);
    19511951  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
    19521952  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
    … …  
    19881988EXAMPLE: example lpSickleDim; shows examples
    19891989"
    1990 {int degbound = attrib(basering,"uptodeg");int n = attrib(basering, "isLetterplaceRing");
     1990{int degbound = lpDegBound(basering);int n = lpBlockSize(basering);
    19911991  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
    19921992  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
    … …  
    20282028EXAMPLE: example lpSickleHil; shows examples
    20292029"
    2030 {int degbound = attrib(basering,"uptodeg");int n = attrib(basering, "isLetterplaceRing");
     2030{int degbound = lpDegBound(basering);int n = lpBlockSize(basering);
    20312031  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
    20322032  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
    … …  
    20752075"
    20762076{int m,d,h,degbound;
    2077   m = 1; d = 0; h = 0; degbound = attrib(basering,"uptodeg");
     2077  m = 1; d = 0; h = 0; degbound = lpDegBound(basering);
    20782078  if (size(#) > 0) {if (typeof(#[1])=="int"){if (#[1] < 1) {m = 0;}}}
    20792079  if (size(#) > 1) {if (typeof(#[1])=="int"){if (#[2] > 0) {d = 1;}}}
    … …  
    20822082  if (m == 1)
    20832083  {if (d == 0)
    2084     {if (h == 0) {return(lpSickle(G,degbound,attrib(basering,"isLetterplaceRing")));}
    2085       else        {return(lpSickleHil(G,degbound,attrib(basering,"isLetterplaceRing")));}
     2084    {if (h == 0) {return(lpSickle(G,degbound,lpBlockSize(basering)));}
     2085      else        {return(lpSickleHil(G,degbound,lpBlockSize(basering)));}
    20862086    }
    20872087    else
    2088     {if (h == 0) {return(lpSickleDim(G,degbound,attrib(basering,"isLetterplaceRing")));}
    2089       else {return(lpDHilbertSickle(G,degbound,attrib(basering,"isLetterplaceRing")));}
     2088    {if (h == 0) {return(lpSickleDim(G,degbound,lpBlockSize(basering)));}
     2089      else {return(lpDHilbertSickle(G,degbound,lpBlockSize(basering)));}
    20902090    }
    20912091  }
    … …  
    20932093  {if (d == 0)
    20942094    {if (h == 0) {ERROR("You request to do nothing, so relax and do so");}
    2095       else        {return(lpHilbert(G,degbound,attrib(basering,"isLetterplaceRing")));}
     2095      else        {return(lpHilbert(G,degbound,lpBlockSize(basering)));}
    20962096    }
    20972097    else
    2098     {if (h == 0) {return(lpKDim(G,degbound,attrib(basering,"isLetterplaceRing")));}
    2099       else {return(lpDHilbert(G,degbound,attrib(basering,"isLetterplaceRing")));}
     2098    {if (h == 0) {return(lpKDim(G,degbound,lpBlockSize(basering)));}
     2099      else {return(lpDHilbert(G,degbound,lpBlockSize(basering)));}
    21002100    }
    21012101  }

  • Singular/LIB/fpaprops.lib

    ree3e7cd r178bd3  
    9191  // if longest word has length 1 we handle it as a special case
    9292  if (l == 1) {
    93     int n = attrib(basering, "isLetterplaceRing"); // variable count
     93    int n = lpBlockSize(basering); // variable count
    9494    int k = size(G);
    9595    if (k == n) { // only the field left
    … …  
    746746    ERROR("Ufnarovskij graph not implemented for l = 1");
    747747  }
    748   int lV = attrib(basering, "isLetterplaceRing");
     748  int lV = lpBlockSize(basering);
    749749  // TODO: what if l <= 0?
    750750  dbprint("computing standard words");
    … …  
    836836    return (words); // no standard words
    837837  }
    838   int lV = attrib(basering, "isLetterplaceRing"); // variable count
     838  int lV = lpBlockSize(basering); // variable count
    839839  list prevWords = ivStandardWords(G, length - 1);
    840840  list words;
    … …  
    907907  // if longest word has length 1, or G is the zero ideal, we handle it as a special case
    908908  if (l == 1 || size(G) == 0) {
    909     int n = attrib(basering, "isLetterplaceRing"); // variable count
     909    int n = lpBlockSize(basering); // variable count
    910910    int k = size(G);
    911911    if (k == n) { // V = {1} no edges
    … …  
    10011001  // delete variables in LM(G1) from the ring
    10021002  def save = basering;
    1003   ring R = basering;
     1003  def R = basering;
    10041004  if (size(G1) > 0) {
    10051005    while (size(G1) > 0) {
    1006       if (attrib(R, "isLetterplaceRing") > 1) {
    1007         ring R = lpDelVar(lp2iv(G1[1])[1]);
     1006      if (lpBlockSize(R) > 1) {
     1007        def @R = R - string(G1[1]);
     1008        R = @R;
     1009        kill @R;
     1010        setring R;
     1011        /* ring R = lpDelVar(lp2iv(G1[1])[1]); // TODO replace with proper method */
    10081012        ideal G1 = imap(save,G1);
    10091013        G1 = simplify(G1, 2); // remove zero generators
    … …  
    10781082{
    10791083  list LG = lpId2ivLi(lead(G));
    1080   int n = attrib(basering, "isLetterplaceRing");
    1081   int degbound = attrib(basering, "uptodeg");
     1084  int n = lpBlockSize(basering);
     1085  int degbound = lpDegBound(basering);
    10821086
    10831087  list V;
    … …  
    13761380}
    13771381
    1378 // TODO: use original ring attrib to create a new letterplace ring
    1379 // removes a variable from a letterplace ring (a bit of a hack)
    1380 static proc lpDelVar(int index) {
    1381   int lV = attrib(basering, "isLetterplaceRing"); // number of variables in the main block
    1382   int d = attrib(basering, "uptodeg"); // degree bround
    1383   list LR = ringlist(basering);
    1384 
    1385   if (!(index >= 1 && index <= lV)) { return (basering); } // invalid index
    1386 
    1387   // remove frome the variable list
    1388   for (int i = (d-1)*lV + index; i >= 1; i = i - lV) {
    1389     LR[2] = delete(LR[2], i);
    1390   } kill i;
    1391 
    1392   // remove from a ordering
    1393   intvec aiv = LR[3][1][2];
    1394   aiv = aiv[1..(d*lV-d)];
    1395   LR[3][1][2] = aiv;
    1396 
    1397   // remove block orderings
    1398   int del = (lV - index);
    1399   int cnt = -1;
    1400   for (int i = size(LR[3]); i >= 2; i--) {
    1401     if (LR[3][i][2] != 0) {
    1402       for (int j = size(LR[3][i][2]); j >= 1; j--) {
    1403         cnt++; // next 1
    1404         if (cnt%lV == del) {
    1405           // delete
    1406           if (size(LR[3][i][2]) > 1) { // if we have more than one element left, delete one
    1407             LR[3][i][2] = delete(LR[3][i][2],j);
    1408           } else { // otherwise delete the whole block
    1409             LR[3] = delete(LR[3], i);
    1410             break;
    1411           }
    1412         }
    1413       } kill j;
    1414     }
    1415   } kill i;
    1416 
    1417   def R = setLetterplaceAttributes(ring(LR),d,lV-1);
    1418   return (R);
    1419 }
    1420 example
    1421 {
    1422   "EXAMPLE:"; echo = 2;
    1423   ring r = 0,(x,y,z),dp;
    1424   def A = makeLetterplaceRing(3);
    1425   setring A; A;
    1426   def R = lpDelVar(2); setring R; R;
    1427 }
     1382// no longer working with new interface and new orderings
     1383/* // TODO: use original ring attrib to create a new letterplace ring */
     1384/* // removes a variable from a letterplace ring (a bit of a hack) */
     1385/* static proc lpDelVar(int index) { */
     1386/*   int lV = lpBlockSize(basering); // number of variables in the main block */
     1387/*   int d = lpDegBound(basering); // degree bround */
     1388/*   list LR = ringlist(basering); */
     1389
     1390/*   if (!(index >= 1 && index <= lV)) { return (basering); } // invalid index */
     1391
     1392/*   // remove frome the variable list */
     1393/*   for (int i = (d-1)*lV + index; i >= 1; i = i - lV) { */
     1394/*     LR[2] = delete(LR[2], i); */
     1395/*   } kill i; */
     1396
     1397/*   // remove from a ordering */
     1398/*   intvec aiv = LR[3][1][2]; */
     1399/*   aiv = aiv[1..(d*lV-d)]; */
     1400/*   LR[3][1][2] = aiv; */
     1401
     1402/*   // remove block orderings */
     1403/*   int del = (lV - index); */
     1404/*   int cnt = -1; */
     1405/*   for (int i = size(LR[3]); i >= 2; i--) { */
     1406/*     if (LR[3][i][2] != 0) { */
     1407/*       for (int j = size(LR[3][i][2]); j >= 1; j--) { */
     1408/*         cnt++; // next 1 */
     1409/*         if (cnt%lV == del) { */
     1410/*           // delete */
     1411/*           if (size(LR[3][i][2]) > 1) { // if we have more than one element left, delete one */
     1412/*             LR[3][i][2] = delete(LR[3][i][2],j); */
     1413/*           } else { // otherwise delete the whole block */
     1414/*             LR[3] = delete(LR[3], i); */
     1415/*             break; */
     1416/*           } */
     1417/*         } */
     1418/*       } kill j; */
     1419/*     } */
     1420/*   } kill i; */
     1421
     1422/*   def R = setLetterplaceAttributes(ring(LR),d,lV-1); */
     1423/*   return (R); */
     1424/* } */
     1425/* example */
     1426/* { */
     1427/*   "EXAMPLE:"; echo = 2; */
     1428/*   ring r = 0,(x,y,z),dp; */
     1429/*   def A = makeLetterplaceRing(3); */
     1430/*   setring A; A; */
     1431/*   def R = lpDelVar(2); setring R; R; */
     1432/* } */

  • Singular/LIB/freegb.lib

    ree3e7cd r178bd3  
    2222
    2323PROCEDURES:
    24 makeLetterplaceRing(d);          creates a ring with d blocks of shifted original variables
    25 setLetterplaceAttributes(R,d,b); supplies ring R with the letterplace structure
    26 lieBracket(a,b[, N]);            Lie bracket ab-ba of two letterplace polynomials
     24freeAlgebra(r, d);               creates a ring with d blocks of shifted original variables
     25isFreeAlgebra(r);                check whether r is a letterplace ring (free algebra)
     26lpDegBound(R);                   returns the degree bound of a letterplace ring
     27lpBlockSize(R);                  returns the size of the letterplace blocks
     28
    2729letplaceGBasis(I);               two-sided Groebner basis of a letterplace ideal I
     30
    2831lpDivision(f,I);                 two-sided division with remainder
    2932lpGBPres2Poly(L,I);              reconstructs a polynomial from the output of lpDivision
     33
     34lieBracket(a,b[, N]);            Lie bracket ab-ba of two letterplace polynomials
    3035isOrderingShiftInvariant(i);     tests shift-invariance of the monomial ordering
    31 
    3236isVar(p);                        check whether p is a power of a single variable
    3337
    3438lpLmDivides(ideal I, poly p)     tests if there is a polynomial q in I with LM(q)|LM(p)
    3539lpVarAt(poly p, int pos)         returns the variable (as a poly) at position pos of the poly p
     40
     41makeLetterplaceRing(d);          (deprecated) creates a ring with d blocks of shifted original variables
     42setLetterplaceAttributes(R,d,b); (for testing) supplies ring R with the letterplace structure
    3643
    3744SEE ALSO: fpadim_lib, fpaprops_lib, fpalgebras_lib, LETTERPLACE
    … …  
    109116  attrib(RL, "maxExp", 1);
    110117  def @R = ring(RL);
    111   attrib(@R, "uptodeg", uptodeg);
     118  attrib(@R, "uptodeg", uptodeg); // no longer needed
    112119  attrib(@R, "isLetterplaceRing", lV);
    113120  return (@R);
    … …  
    118125  ring r = 0,(x(1),y(1),x(2),y(2),x(3),y(3),x(4),y(4)),dp;
    119126  def R = setLetterplaceAttributes(r, 4, 2); setring R;
    120   attrib(R,"isLetterplaceRing");
     127  lpBlockSize(R);
    121128  lieBracket(x(1),y(1),2);
    122129}
    … …  
    444451  J;
    445452}
     453
     454/* // temporary name for testing */
     455/* proc lpRightStd(ideal F, ideal Q) */
     456/* { */
     457/*   return (system("rightgb", F, Q)); */
     458/* } */
    446459
    447460/*
    … …  
    983996}
    984997
     998proc lpDegBound(def R)
     999"USAGE:  lpDegBound(R); R a letterplace ring
     1000RETURN:  int
     1001PURPOSE: returns the degree bound of the letterplace ring
     1002EXAMPLE: example lpDegBound; shows examples
     1003"
     1004{
     1005  int lV = attrib(R, "isLetterplaceRing");
     1006  if (lV < 1) {
     1007    ERROR("not a letterplace ring");
     1008  }
     1009  return (nvars(R) div lV);
     1010}
     1011example
     1012{
     1013  "EXAMPLE:"; echo = 2;
     1014  ring r = 0,(x,y,z),dp;
     1015  def R = freeAlgebra(r, 7);
     1016  lpDegBound(R);
     1017}
     1018
     1019proc lpBlockSize(def R)
     1020"USAGE:  lpBlockSize(R); R a letterplace ring
     1021RETURN:  int
     1022PURPOSE: returns the block size of the letterplace ring, that is the number of variables of the original ring.
     1023EXAMPLE: example lpBlockSize; shows examples
     1024"
     1025{
     1026  int lV = attrib(R, "isLetterplaceRing");
     1027  if (lV < 1) {
     1028    ERROR("not a letterplace ring");
     1029  }
     1030  return (lV);
     1031}
     1032example
     1033{
     1034  "EXAMPLE:"; echo = 2;
     1035  ring r = 0,(x,y,z),dp;
     1036  def R = freeAlgebra(r, 7);
     1037  lpBlockSize(R);
     1038}
     1039
     1040proc isFreeAlgebra(def r)
     1041"USAGE:  isFreeAlgebra(r); r a ring
     1042RETURN:  boolean
     1043PURPOSE: check whether R is a letterplace ring (free algebra)
     1044EXAMPLE: example isFreeAlgebra; shows examples
     1045"
     1046{
     1047  int lV = attrib(r, "isLetterplaceRing");
     1048  if (lV < 1) {
     1049    return (0);
     1050  }
     1051  return (1);
     1052}
     1053example
     1054{
     1055  "EXAMPLE:"; echo = 2;
     1056  ring r = 0,(x,y,z),dp;
     1057  isFreeAlgebra(r);
     1058  def R = freeAlgebra(r, 7);
     1059  isFreeAlgebra(R);
     1060}
     1061
     1062proc freeAlgebra(def r, int d)
     1063"USAGE:  freeAlgebra(r, d); r a ring, d an integer
     1064RETURN:  ring
     1065PURPOSE: creates a letterplace ring with the ordering of r
     1066EXAMPLE: example freeAlgebra; shows examples
     1067"
     1068{
     1069  return (system("freeAlgebra", r, d));
     1070}
     1071example
     1072{
     1073  "EXAMPLE:"; echo = 2;
     1074  ring r = 0,(x,y,z),dp;
     1075  def R = freeAlgebra(r, 7);
     1076  R;
     1077  ring r2 = 0,(x,y,z),lp;
     1078  def R2 = freeAlgebra(r2, 7);
     1079  R2;
     1080}
     1081
    9851082// united all previous makes, including mLR1 (homog) and mLR2 (nonhomog)
    9861083proc makeLetterplaceRing(int d, list #)
    987 "USAGE:  makeLetterplaceRing(d [,h]); d an integer, h an optional integer
     1084"USAGE:  makeLetterplaceRing(d [,h]); d an integer, h an optional integer (deprecated, use freeAlgebra instead)
    9881085RETURN:  ring
    9891086PURPOSE: creates a ring with the ordering, used in letterplace computations
    990 NOTE: h = 0 (default) : Dp ordering will be used
     1087NOTE: h = -1 (default) : the ordering of the current ring will be used
     1088h = 0 : Dp ordering will be used
    9911089h = 2 : weights 1 used for all the variables, a tie breaker is a list of block of original ring
    9921090h = 1 : the pure homogeneous letterplace block ordering (applicable in the situation of homogeneous input ideals) will be used.
    … …  
    9941092"
    9951093{
    996   int alternativeVersion = 0;
     1094  int alternativeVersion = -1;
    9971095  if ( size(#)>0 )
    9981096  {
    … …  
    10121110    }
    10131111    else {
    1014       def @A = makeLetterplaceRing4(d);
     1112      if (alternativeVersion == 0)
     1113      {
     1114        def @A = makeLetterplaceRing4(d);
     1115      }
     1116      else {
     1117        def @A = freeAlgebra(basering, d);
     1118      }
    10151119    }
    10161120  }
    … …  
    10231127  def A = makeLetterplaceRing(2); // same as  makeLetterplaceRing(2,0)
    10241128  setring A;  A;
    1025   attrib(A,"isLetterplaceRing");
    1026   attrib(A,"uptodeg");  // degree bound
     1129  lpBlockSize(A);
     1130  lpDegBound(A);  // degree bound
    10271131  setring r; def B = makeLetterplaceRing(2,1); // to compare:
    10281132  setring B;  B;
    1029   attrib(B,"isLetterplaceRing");
    1030   attrib(B,"uptodeg");  // degree bound
     1133  lpBlockSize(B);
     1134  lpDegBound(B);  // degree bound
    10311135  setring r; def C = makeLetterplaceRing(2,2); // to compare:
    10321136  setring C;  C;
    1033   attrib(C,"isLetterplaceRing");
    1034   attrib(C,"uptodeg");  // degree bound
     1137  lpDegBound(C);
     1138  lpDegBound(C);  // degree bound
    10351139}
    10361140
    … …  
    11141218  setring A;
    11151219  A;
    1116   attrib(A,"isLetterplaceRing");// number of variables in the main block
    1117   attrib(A,"uptodeg");  // degree bound
     1220  lpBlockSize(A);// number of variables in the main block
     1221  lpDegBound(A);  // degree bound
    11181222}
    11191223
    … …  
    12191323  setring A;
    12201324  A;
    1221   attrib(A,"isLetterplaceRing"); // number of variables in the main block
    1222   attrib(A,"uptodeg");  // degree bound
     1325  lpBlockSize(A); // number of variables in the main block
     1326  lpDegBound(A);  // degree bound
    12231327}
    12241328
    … …  
    12831387  setring A;
    12841388  A;
    1285   attrib(A,"isLetterplaceRing"); // number of variables in the main block
    1286   attrib(A,"uptodeg");  // degree bound
     1389  lpBlockSize(A); // number of variables in the main block
     1390  lpDegBound(A);  // degree bound
    12871391}
    12881392
    … …  
    13891493  setring A;
    13901494  A;
    1391   attrib(A,"isLetterplaceRing"); // number of variables in the main block
    1392   attrib(A,"uptodeg");  // degree bound
     1495  lpBlockSize(A); // number of variables in the main block
     1496  lpDegBound(A);  // degree bound
    13931497}
    13941498
    … …  
    26502754//   }
    26512755//   intvec v = w;
    2652 //   for(i=1; i< attrib(basering,"uptodeg"); i++)
     2756//   for(i=1; i< lpDegBound(basering); i++)
    26532757//   {
    26542758//     v = v,w;
    … …  
    28362940  // make new ring
    28372941  def save = basering;
    2838   int norigvars = attrib(save, "isLetterplaceRing");
     2942  int norigvars = lpBlockSize(save);
    28392943  def Rtagged; def temp = save;
    28402944  for (int i = 1; i <= size(I); i++) {
    … …  
    28432947  } kill i;
    28442948  // currently R + "var" doesn't preserve uptodeg
    2845   Rtagged = setLetterplaceAttributes(Rtagged, attrib(Rtagged, "isLetterplaceRing"), attrib(save, "uptodeg"));
     2949  Rtagged = setLetterplaceAttributes(Rtagged, lpBlockSize(Rtagged), lpDegBound(save));
    28462950  setring Rtagged;
    28472951
    … …  
    29553059{if (I==intvec(0)) {return(intvec(0));}
    29563060 int j,k,l;
    2957  int n = attrib(basering,"isLetterplaceRing"); int d = attrib(basering,"uptodeg");
     3061 int n = lpBlockSize(basering); int d = lpDegBound(basering);
    29583062 intvec w; j = 1;
    29593063 while (j <= d)
    … …  
    29913095"
    29923096{int i,j,k,r1,r2; intvec D;
    2993  int n = attrib(basering,"isLetterplaceRing");
     3097 int n = lpBlockSize(basering);
    29943098 k = size(V) div n; r1 = 0; r2 = 0;
    29953099 for (i=1; i<= k; i++)
    … …  
    30363140
    30373141 int i,j,r; intvec T; list R;
    3038  int n = attrib(basering,"isLetterplaceRing");
     3142 int n = lpBlockSize(basering);
    30393143 int k = size(V) - size(W) + 1;
    30403144 if (intvec(V[1..size(W)])-W == 0){R[1]=0;}
    … …  
    31373241  int shiftInvariant = 1;
    31383242
    3139   int n = attrib(basering, "isLetterplaceRing");
    3140   int d = attrib(basering, "uptodeg");
     3243  int d = lpDegBound(basering);
    31413244
    31423245  ideal monomials;
    … …  
    32053308  }
    32063309
    3207   int lV = attrib(basering, "isLetterplaceRing"); // variable count
     3310  int lV = lpBlockSize(basering); // variable count
    32083311  ideal prevMonomials = lpMonomialsWithHoles(d - 1);
    32093312
    … …  
    32313334static proc getlpCoeffs(poly q, poly p)
    32323335{list R; intvec cq,t,lv,rv,bla;
    3233  int n = attrib(basering,"isLetterplaceRing"); int d = attrib(basering,"uptodeg");
     3336 int n = lpBlockSize(basering); int d = lpDegBound(basering);
    32343337 int i;
    32353338 cq = leadexp(p)-leadexp(q); /* p/q */
    … …  
    32753378"PURPOSE: Checks, if all the Assumptions are holding
    32763379"
    3277 {if (attrib(basering,"isLetterplaceRing")==0) {ERROR("Basering is not a Letterplace ring!");}
    3278   if (d > attrib(basering,"uptodeg")) {ERROR("Specified degree bound exceeds ring parameter!");}
     3380{if (!isFreeAlgebra(basering)) {ERROR("Basering is not a Letterplace ring!");}
     3381  if (d > lpDegBound(basering)) {ERROR("Specified degree bound exceeds ring parameter!");}
    32793382  int i;
    32803383  for (i = 1; i <= size(L); i++)
    3281   {if (entryViolation(L[i], attrib(basering,"isLetterplaceRing")))
     3384  {if (entryViolation(L[i], lpBlockSize(basering)))
    32823385    {ERROR("Not allowed monomial/intvec found!");}
    32833386  }
    … …  
    32973400"
    32983401"
    3299 {if (attrib(basering,"isLetterplaceRing")==0) {ERROR("Basering is not a Letterplace ring!");}
     3402{if (!isFreeAlgebra(basering)) {ERROR("Basering is not a Letterplace ring!");}
    33003403 return();
    33013404}
    … …  
    33233426{int r = 0; intvec w;
    33243427 intvec l = leadexp(p);
    3325  int n = attrib(basering,"isLetterplaceRing"); int d = attrib(basering,"uptodeg");
     3428 int n = lpBlockSize(basering); int d = lpDegBound(basering);
    33263429 int i,j,c,c1;
    33273430 while (1 <= d)
    … …  
    34353538  // uptodeg and lV are defined
    34363539  // returns Boolean : yes/no [for assume violation]
    3437   def uptodeg = attrib(basering,"uptodeg");
     3540  def uptodeg = lpDegBound(basering);
    34383541  if ( typeof(uptodeg)!="int" )
    34393542  {
    34403543    return(1);
    34413544  }
    3442   int lV = attrib(basering,"isLetterplaceRing");
    3443   // isLetterplaceRing for rings is always defined and of type int
    3444   if ( lV==0 )
    3445   {
    3446     return(1);
    3447   }
    3448   return(0);
     3545  return (!isFreeAlgebra(basering))
    34493546}
    34503547
    … …  
    36023699{if (I[1] == 0) {return(1);}
    36033700  int i = size(I);
    3604   if (i > attrib(basering,"uptodeg")) {ERROR("polynomial exceeds degreebound");}
     3701  if (i > lpDegBound(basering)) {ERROR("polynomial exceeds degreebound");}
    36053702  int j; poly p = 1;
    36063703  for (j = 1; j <= i; j++) {if (I[j] > 0) { p = p*var(I[j]);}} //ignore zeroes, because they correspond to 1
    … …  
    37203817  intvec I;
    37213818  int i,j;
    3722   if (deg(p) > attrib(basering,"uptodeg")) {ERROR("Monomial exceeds degreebound");}
     3819  if (deg(p) > lpDegBound(basering)) {ERROR("Monomial exceeds degreebound");}
    37233820  if (p == 1) {return(I);}
    37243821  if (p == 0) {ERROR("Monomial is not allowed to equal zero");}
    37253822  intvec lep = leadexp(p);
    3726   for ( i = 1; i <= attrib(basering,"isLetterplaceRing"); i++) {if (lep[i] == 1) {I = i; break;}}
    3727   for (i = (attrib(basering,"isLetterplaceRing")+1); i <= size(lep); i++)
     3823  for ( i = 1; i <= lpBlockSize(basering); i++) {if (lep[i] == 1) {I = i; break;}}
     3824  for (i = (lpBlockSize(basering)+1); i <= size(lep); i++)
    37283825  {if (lep[i] == 1)
    3729     { j = (i mod attrib(basering,"isLetterplaceRing"));
    3730       if (j == 0) {I = I,attrib(basering,"isLetterplaceRing");}
     3826    { j = (i mod lpBlockSize(basering));
     3827      if (j == 0) {I = I,lpBlockSize(basering);}
    37313828      else {I = I,j;}
    37323829    }

  • Singular/LIB/ncHilb.lib

    ree3e7cd r178bd3  
    6969EXAMPLE: example fpahilb; shows an example "
    7070{
    71     if (attrib(basering, "isLetterplaceRing")==0)
     71    if (!isFreeAlgebra(basering))
    7272    {
    7373      ERROR("Basering should be Letterplace ring");
    … …  
    7575    def save = basering;
    7676    int sz=size(#);
    77     int lV=attrib(save,"isLetterplaceRing"); // nvars(orig comm ring)
     77    int lV=lpBlockSize(save); // nvars(orig comm ring)
    7878    int ig=0;
    7979    int mgrad=0;
    … …  
    137137    }
    138138    // new: truncation should be < than degbound/2
    139     int degbnd = attrib(save,"uptodeg");
     139    int degbnd = lpDegBound(save);
    140140    if (tdeg == 0)
    141141    {
    … …  
    403403EXAMPLE: example rcolon; shows an example"
    404404{
    405     int lV =  attrib(R,"isLetterplaceRing"); //nvars(save);
     405    int lV =  lpBlockSize(R); //nvars(save);
    406406    if (lV == 0)
    407407    {
    … …  
    419419        }
    420420    }
    421     int degbnd = attrib(R,"uptodeg");
     421    int degbnd = lpDegBound(R);
    422422    if ( 2*maxdegI != degbnd)
    423423    {

  • Singular/extra.cc

    ree3e7cd r178bd3  
    12431243    else
    12441244  #endif
     1245 /*==================== freeAlgebra for freeGB  ==================*/
     1246  #ifdef HAVE_SHIFTBBA
     1247    if (strcmp(sys_cmd, "freeAlgebra") == 0)
     1248    {
     1249      // copied from freegb.cc
     1250      const short t[]={2,RING_CMD,INT_CMD};
     1251      if (iiCheckTypes(h,t,1))
     1252      {
     1253        ring r=(ring)h->Data();
     1254        int d=(int)((long)h->next->Data());
     1255        if (d<2)
     1256        {
     1257          WerrorS("degree must be >=2");
     1258          return TRUE;
     1259        }
     1260        int i=0;
     1261        while(r->order[i]!=0)
     1262        {
     1263          if ((r->order[i]==ringorder_c) ||(r->order[i]==ringorder_C)) i++;
     1264          else if ((r->block0[i]==1)&&(r->block1[i]==r->N)) i++;
     1265          else
     1266          {
     1267            WerrorS("only for rings with a global ordering of one block");
     1268            return TRUE;
     1269          }
     1270        }
     1271        if ((r->order[i]!=0)
     1272            || (rHasLocalOrMixedOrdering(r)))
     1273        {
     1274          //WerrorS("only for rings with a global ordering of one block");
     1275          Werror("only for rings with a global ordering of one block,i=%d, o=%d",i,r->order[i]);
     1276          return TRUE;
     1277        }
     1278        ring R=freeAlgebra(r,d);
     1279        res->rtyp=RING_CMD;
     1280        res->data=R;
     1281        return R==NULL;
     1282      }
     1283      else return TRUE;
     1284    }
     1285    else
     1286  #endif
    12451287  /*==================== pcv ==================================*/
    12461288  #ifdef HAVE_PCV

  • Singular/iparith.cc

    r04d263 r178bd3  
    18731873  res->data=(void*)id_Delete_Pos(I,pos-1,currRing);
    18741874  return res->data==NULL;
     1875}
     1876static BOOLEAN jjDET2(leftv res, leftv u, leftv v)
     1877{
     1878  matrix m=(matrix)u->Data();
     1879  DetVariant d=mp_GetAlgorithmDet((char*)v->Data());
     1880  res ->data = mp_Det(m,currRing,d);
     1881  return FALSE;
     1882}
     1883static BOOLEAN jjDET2_S(leftv res, leftv u, leftv v)
     1884{
     1885  DetVariant d=mp_GetAlgorithmDet((char*)v->Data());
     1886  ideal m=(ideal)u->Data();
     1887  res ->data = sm_Det(m,currRing,d);
     1888  return FALSE;
    18751889}
    18761890static BOOLEAN jjDIFF_P(leftv res, leftv u, leftv v)
    … …  
    38673881{
    38683882  matrix m=(matrix)v->Data();
    3869   poly p;
    3870   if (sm_CheckDet((ideal)m,m->cols(),TRUE, currRing))
    3871   {
    3872     ideal I=id_Matrix2Module(mp_Copy(m, currRing),currRing);
    3873     p=sm_CallDet(I, currRing);
    3874     idDelete(&I);
    3875   }
    3876   else
    3877     p=singclap_det(m,currRing);
    3878   res ->data = (char *)p;
     3883  res ->data = mp_Det(m,currRing);
    38793884  return FALSE;
    38803885}
    … …  
    39323937{
    39333938  ideal I=(ideal)v->Data();
    3934   poly p;
    3935   if (IDELEMS(I)<1) return TRUE;
    3936   if (!sm_CheckDet(I,IDELEMS(I),FALSE, currRing))
    3937   {
    3938     matrix m=id_Module2Matrix(id_Copy(I,currRing),currRing);
    3939     p=singclap_det(m,currRing);
    3940     idDelete((ideal *)&m);
    3941   }
    3942   else
    3943     p=sm_CallDet(I, currRing);
    3944   res->data = (char *)p;
     3939  res->data=(char*)sm_Det(I,currRing);
    39453940  return FALSE;
    39463941}

  • Singular/table.h

    r04d263 r178bd3  
    120120,{D(jjDET_BI),     DET_CMD,         BIGINT_CMD,     BIGINTMAT_CMD , ALLOW_NC |ALLOW_RING}
    121121,{D(jjDET_I),      DET_CMD,         INT_CMD,        INTMAT_CMD    , ALLOW_NC |ALLOW_RING}
     122,{D(jjDET_S),      DET_CMD,         POLY_CMD,       SMATRIX_CMD   , NO_NC |NO_RING}
    122123,{D(jjDET),        DET_CMD,         POLY_CMD,       MATRIX_CMD    , NO_NC |ALLOW_RING}
    123 ,{D(jjDET_S),      DET_CMD,         POLY_CMD,       MODUL_CMD     , NO_NC |NO_RING}
    124124,{D(jjDIM),        DIM_CMD,         INT_CMD,        IDEAL_CMD     , ALLOW_PLURAL |ALLOW_RING}
    125125,{D(jjDIM),        DIM_CMD,         INT_CMD,        MODUL_CMD     , ALLOW_PLURAL |ALLOW_RING}
    … …  
    616616,{D(jjDelete_ID), DELETE_CMD,     MODUL_CMD,      MODUL_CMD,  INT_CMD, ALLOW_NC |ALLOW_RING}
    617617,{D(lDelete),     DELETE_CMD,     LIST_CMD,       LIST_CMD,   INT_CMD, ALLOW_NC |ALLOW_RING}
     618,{D(jjDET2_S),    DET_CMD,        POLY_CMD,       SMATRIX_CMD,STRING_CMD, NO_NC |NO_RING}
     619,{D(jjDET2),      DET_CMD,        POLY_CMD,       MATRIX_CMD, STRING_CMD, NO_NC |ALLOW_RING}
    618620,{D(jjDIFF_P),    DIFF_CMD,       POLY_CMD,       POLY_CMD,   POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
    619621,{D(jjDIFF_P),    DIFF_CMD,       VECTOR_CMD,     VECTOR_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
    … …  
    10111013  { "delete",      0, DELETE_CMD ,        CMD_2},
    10121014  { "denominator", 0, DENOMINATOR_CMD ,   CMD_1},
    1013   { "det",         0, DET_CMD ,           CMD_1},
     1015  { "det",         0, DET_CMD ,           CMD_12},
    10141016  { "diff",        0, DIFF_CMD ,          CMD_2},
    10151017  { "dim",         0, DIM_CMD ,           CMD_12},

  • Tst/Buch/Example_2_6_15.res.gz.uu

    r04d263 r178bd3  
    11begin 640 Example_2_6_15.res.gz
    2 M'XL(",(123X``T5X86UP;&5?,E\V7S$U+G)E<P"55VUOVS80_JY?013[(-N4
    3 M+5+O]>0A=A*@0.T!S=`O@9>ZMKP)<"1#5AQMP_[[[BB*I!*[P!1%HLCGCO?&
    4 MN_/#;[>?5H00-B.?/\W)A_I4CP_Y]P]3ZT&N\!F!R:>\R&M[,+7P368S<M=L
    5 MGH^'[(D_A4\L&!?9Z_A4;VI%YLV(&OMC<JS*+<F:.BMVV6Y55L^;PST\[>=-
    6 M7>4-60X4.!B3?]1'.(8'R8OZG&W).67C<5&5KR=[.9AJ]K$)>DT[Q,A`CXIM
    7 M>>B3,5>020%6Z;8LMIO:WE=9]ESN7@Z9W1$/*-`I,B[(5FE=;8K3L3QE-NR<
    8 M556VL_74:C`P2'QSIT5Z>OD.8WM%S_1LH%I=%^DAW]?V@KX39($\R612_YF!
    9 MLN>L.F4=SW)/%HI/;.YV:^[V:JC/6_5O+^EQ.S"!K<*'_%23+UFZH+=*9-XJ
    10 M5F7U2U787S*@TF2@SK_J(]+1P$&^\ECG96'#7@]S;0&>S$B5%W^0+ZE+[69`
    11 MP0J[HU[W7!&D'UK5^F'J,;V#!Q)W<?48K.%.&26,NN)/H3PAO'$YG#KO4/Y;
    12 M%'$IW)PR$Q5<1B'.0(774(#3FABV\F*ER4IIPBD1-\BJ<,D[S@P$1)S0O,/Y
    13 M[CN=)<X13X5CEW'L+8Y?V+=C1IC2R8=LL&P#>_4^L/&P#)?#E8;[,T@8$(YX
    14 M8"W'FP!+#GL'8A13%,>'IQ5,X.6$\._AT&&XSA!EH0RH//&HE)^@3'!9'E(Q
    15 M8!-'8H1X'L&#M'LA#-^2RA=Z*=D"[1X_5.ZY29=.,S14"W3<^H9'??"H.$J?
    16 MTTOI\,:@2C15X(ZE03X_LC5@7-J+(:$A6,?C@5IQX@GWO2A02+!9?Z;'!6P7
    17 M`K$339CGN@;1Q(^CH#?AF=_$8F$\82$7;!F*0!&$,\W(:U?0,3U9^)MOM+P?
    18 M="C<(W$IN`=$ZFTMUIN1E"$1W$U9'!XEG=X.GR3PZEM%<[G`5MI'6=W(*0'7
    19 M'N!K3(^-[_B--PH:#N^13W$+F3M,N^+5.)Q>67)%E%Y=<MLT<WD)%K5\1KT-
    20 M?!667QFF#7_=53<,'[CI<JA'_;'ZTI$80,AW_#CR8^M4@/A:EXD@-`2(9)#?
    21 MI_O-MBZK_.],V.T1LHC).)Z1^ZD%K#Y:H-43,F;MB*_3AH_DAP<?#K=@4N`P
    22 M%7'%PS@FH2L;C6-Y^.O7_5VQ*[L&8TYQCAQ5GQ$RH\\(11X#[Y)<"1?ZW=Q.
    23 MMA1&J0I%*E=G?UMF^_W)/M+SIK*94?K#V,#=/>[6<*=&EMAI:.0:T(6$W@B+
    24 M#>\T2DBZ+RL[3_DT_UF*!GDC'XV4<I&07:D7=87G+KT;SC6O6$XOTL7HYC'O
    25 M[Q0+>50)C\7&LM0OM-BQ;]3YV$B.L4Z.#ZGAD"6];V/G=VYPB72(,9:>ZIW]
    26 M,/S*#$#<E018QZ*01%%(F<>2`--VQ-R(,I]C6;#\.(XQ!T4\B*DEEKHD*4\2
    27 MSA&=TV,CAA)0^Y*\WMKHB1)FB,LOB)MP+2ZJ"<7+QP(*^SNBB%IXKE$JF/&Z
    28 M`3R9EBHQCG2BC_2\.\M@"`K<Z5?#C@DX8)?5&*KD[85'YQ=<Q78Q(`T)21N%
    29 M1!Z208N`'K"L2+G=OF`S"">`M,P/>9'!!A_)MVL[?%-B&,D@@60`?%ZVF;T<
    30 MHLQH+72BZ!;%F7<M<>!=10+.-DBX).%XL/H$(C=HNL2DDV0F58MCKJO$8RX;
    31 MZ\Y<="ASR(-SHY5EKG+F0BAM,1:X4!<C+P97QIP'D\2':!2QY;7S7CL%CK5P
    32 MG7MA0O%<!I).EFTV:2-WTL9N/]6;65^T+E#1/-J68"K6KZ%9(%JFMO-I7S]`
    33 MNU1/=//_#\VUK3S#M#IHS[)L@!/A-26&<2%B>R&]')X=/H2?1F9@,Q<BJN\?
    34 MM1+UO'/-.;YRTG67!'+PMASW^B1ISK=UN8>1S07_`48;VC!>;!@/6GK\W8T_
    35 2JE].4%2F/UG_`<J,H^FM#P``
     2M'XL("(HA$5P"`T5X86UP;&5?,E\V7S$U+G)E<P"55UMOXD84?O>O&*WZ8&`,
     3MGO'XMJFI$I)(*RU4VE3[$M$L"Z:U1#`R#G%;];_WS'@\<[R!;4N(/9?OW,^<
     4M,SS\<OMA00AA4_+QPPUY5Q_K\:[X^N[*>=`[?$I@\:G8%[4[N'+DFTRGY*Y9
     5M/1]V^1-_BIY8.-[GK^-CO:H-63`E9BS&Y%"5:Y(W=;[?Y)M%63VO=O?P=)]7
     6M=54T9#XPX'!,_C*3:`P/4NSK4[XFIXR-Q_NJ?#VZ\X%5,,&8UZP#C!!XM%^7
     7MNQX5\Q65%K_(UN5^O:K=;97GS^7F99>['>V`8C*NR!997:WVQT-YS%T0G%=5
     8MOG'MTF(P0"0"2YIEQY>O,'87]$1/"-5:.LMVQ;9V9_2-(C/)DTPF]>\YV'K*
     9MJV/>\2RW9&;X)%C:+9;V:J7QUOK;<V;<(MUY:^ZN.-;D4Y[-Z*W=:LVJ\OJE
     10MVKN?<D0$IOQM)K'-`PZZE8>Z*/<N"'JX023IE%3%_C?R*?.IVPPH>&!SL/N!
     11MK]+S76M6/T$#9B4$H&^748_A$KX9HX117_T95*!41Q^/4^\-2GR+(CZ%+Z<,
     12MH\+S*(E#J.@2"G#6$N2K(#&6+(PEG!+U!5T-+GW#F8&"$J<L[W#"?V.SQGGJ
     13M:7#L/(Y]B^-GY';,"#,V":@#\S:I%V^36AZ4X7RXL'`QA5(!N:C.JA=,@"4'
     14MV:$:)52J(^#IA!-X>1'\!W+H,;G/),J1.DCC24"U_D3J!!\GD%0,V"2Q&DD\
     15MC^%!6ED2)M^:2BB[C&ZA#8^(3'BNL[G7#)%IH<U;@2(J(*+J('W,SA7":T25
     16M6JK0'VN'?'QD2\#XM)=#RD+P3L!#L^,E$RZ".*0VA**_TN,"OHN`V(LG+/!]
     17M1#0121SV%@(\)PZ+D@F+N&++I`I4@N1*,PK:'1F8GB[\F[GTO`@[E)21^A3"
     18M`RKU1*O]9J1U2!5WK(O'X[2SV^.3%%Y]KU@N9]AJ_QBOHYH2<AL!+B/0"$\T
     19MP2AL.+Q'@DH)NG1@M\I/XW%Z8<M727IQRV^KS/DMV+3JH48;"I.5GYFL&F+9
     20M-3:9/?"E\Z$=]<=F9A,QA(SO^'')CRTS!>)+BXF0_%BG^'VV7:WKLBK^S)77
     21M'J&&8+[)E-Q?.<#IO0-&/4F^K!WQ9=;PD9X$,/&X`XL*)PL1-SS0(8E\?<$X
     22ME+L_?M[>[3=E=[&XH7*-',S](F+H?A&I*@:Q)851+A+=VD;?)5"CBE0A-R=_
     23M7>;;[=$]T-.J<AEJG%&"<'>/FR5\,U0C-A8:^P@ZT]!KY;'AG44I3;=EY189
     24MORI^U*I!U2A&(V-<K'0WYL5=V[G+[H8WEE>BEV?9;'3]6/0E)4H?T\`3)5BW
     25M^9E5.Q&HRR>H-":V-#YD*"!S>M^FSJ\<<8EMAC&6'>N-^S#\S!`@Z1H"[,N6
     26MD,9Q1%G`TE`6[9CY,66"RZ;@B"1)9`6*>9A01VUU)5(?)+F&*GJ"<B@%L\_I
     27M&Z"\31G2EI_1-N566VDE="XANR>(]U0'=>2IEDK!2M`-X,FL4BDZT*D]T#?=
     28M208_4.!./R,WIN#_35ZK3`7[?I(3>2T,24,BTN8<T4=BT"+@LE=6I%RO7^2M
     29M#_*=P/1K#AF6DY;KKMCGP/D]^:)9?S'BT)E/X<P#@Y=U[LZ'4C?I%1DK4$4=
     30M;-]1I]HW!!!11,`U`7]+H`J`I4LQG2;#5"V.^;Y1COEL;"_>ZA)R`[7.GF?F
     31MFX#)U&8L]*'KQ4$"L4HX#R>I@&Q3N1.TZT&[!)%SY#X/HI3*<Q=J.MV4V:3-
     32MS$F;F_U*CHNZNIA`OPIHVV"IVK^$9J&Z$%%]9]7[E]`^M0O=^O]#<^O)`'G5
     33M9N5)=P6('[RL6R$?>PD['YX\/H1?/#AMF0]Y="$N\7^(BS#QN1R-4`_\[\2@
     34J\R3['D;?&CC]%P^J-_);@OP&=W7Y4UK^3GXY0K^X^L'Y!VV`RI:`#P``
    3635`
    3736end

  • Tst/Buch/Example_2_6_15.stat

    r04d263 r178bd3  
    1 1 >> tst_memory_0 :: 1044976067:2003021115:2-0-4:ix86-Linux:nepomuck:199584 1292524760:3120- 13145 :3-1-2:ix86-Linux:mamawutz:230300
    2 1 >> tst_memory_1 :: 1044976067:2003021115:2-0-4:ix86-Linux:nepomuck:707464 1292524760:3120- 13145 :3-1-2:ix86-Linux:mamawutz:667336
    3 1 >> tst_memory_2 :: 1044976067:2003021115:2-0-4:ix86-Linux:nepomuck:707464 1292524760:3120- 13145 :3-1-2:ix86-Linux:mamawutz:700120
    4 1 >> tst_timer_1 :: 1044976067:2003021115:2-0-4:ix86-Linux:nepomuck:6 1292524760:3120- 13145 :3-1-2:ix86-Linux:mamawutz:12
     11 >> tst_memory_0 :: 1544626571:4113, 64 bit:4.1.1:x86_64-Linux:nepomuck:187832
     21 >> tst_memory_1 :: 1544626571:4113, 64 bit:4.1.1:x86_64-Linux:nepomuck:2199552
     31 >> tst_memory_2 :: 1544626571:4113, 64 bit:4.1.1:x86_64-Linux:nepomuck:2215936
     41 >> tst_timer_1 :: 1544626571:4113, 64 bit:4.1.1:x86_64-Linux:nepomuck:4

  • Tst/Manual/Example_of_use_of_@sc{Letterplace}.res.gz.uu

    ree3e7cd r178bd3  
    11begin 644 Example_of_use_of_@sc{Letterplace}.res.gz
    2 M'XL("%;?V5L"`T5X86UP;&5?;V9?=7-E7V]F7T!S8WM,971T97)P;&%C97TN
    3 M<F5S`&U2RVZ#,!"\\Q6KJ`<(Y$'>%<*JHO9`%/5`<JNBB,1.A$H`@:,:JOY[
    4 M%_-P#CE@[\[,SBR2=_MW[Q,`;`);;PT]GO-A%)YZ#F!U#..0ZX:C53<0`A\B
    5 MN*41.R:7XSV7UUM^_MTRSEF61L&9_0UC]C/,><"U7>,\:9PO&6/74VW>D5,"
    6 M61A?(0,7QI8NK,(J#8NF2C$C$,8<*+@S!T8CH.R*1G!*[C'M1'."^`5\=+D%
    7 MW^QA(1_==6HHOP6!G'$9ZBMTB2F4!1%X:"'Z!9A0]$L+2X%E!0P0$/(LU-B*
    8 M0)+R,(GUC-'=VG`>VGT01@^YKVW"!A-R3G5/D?:8P,;1-E_VP<4L$Z.QF52-
    9 M&!3R*P8U.#VXV,@6@4I94Y*<U:0P%2G,EIQ79-G,EIV@FY>B12NJYY2H\9&B
    10 G91U3MEL\=5JUHF:;)T[MW^/;JQY;]6KNN6X;SHOV#^"H^[67`@``
     2M'XL("'$H$5P"`T5X86UP;&5?;V9?=7-E7V]F7T!S8WM,971T97)P;&%C97TN
     3M<F5S`&U2RXZ"0!"\\Q4=LP<0?.![0YALC'O`F#VHMXTQ**.9+`*!,3NPV7^W
     4M9WAY\,!,=U5U59/,;K_RO@#`)K#QEM#A&>^'[-1Q`*LCBQC7#4>3-Q`"G\*_
     5M)2$]QI?C/5/71W;^VU#.:9J$_IG^]R/ZV\^XS[5=Y3RJG"\II==3:=Z08P(I
     6MBZZ0@@M#2Q=6;A6&M4I:Q80`BS@$X$X<&`P@H%<T@E-\CX)&-"6(7V"++C?_
     7MASXMM$5W/3!:OQF!C'(5NFW1.:8$U`_!0PO1S<&$O%M86`HL)=!#0*@S;\<6
     8M!.*$LSC24QKLEH;SU.Y]%C[EOM<):TS(>*![+6D/":P=;?UM'US,,C$:FY%L
     9M1"]77]XKP?'!Q4:U"$AE22ER4I+";$EAUN14DD4U6S2"9EZ)9K6HG&M%E8\2
     10GS<N8HM[BI=.B%E7;O'"J_Q[?GGQL\M7<,]TVG#?M`6PS(8B7`@``
    1111`
    1212end

  • Tst/Manual/Example_of_use_of_@sc{Letterplace}.stat

    ree3e7cd r178bd3  
    1 1 >> tst_memory_0 :: 1541005142:4113, 64 bit:4.1.1:x86_64-Darwin:161-029.eduroam.rwth-aachen.de:724464
    2 1 >> tst_memory_1 :: 1541005142:4113, 64 bit:4.1.1:x86_64-Darwin:161-029.eduroam.rwth-aachen.de:2097168
    3 1 >> tst_memory_2 :: 1541005142:4113, 64 bit:4.1.1:x86_64-Darwin:161-029.eduroam.rwth-aachen.de:2121872
    4 1 >> tst_timer_1 :: 1541005142:4113, 64 bit:4.1.1:x86_64-Darwin:161-029.eduroam.rwth-aachen.de:69
     11 >> tst_memory_0 :: 1544628337:4113, 64 bit:4.1.1:x86_64-Linux:megrez:312368
     21 >> tst_memory_1 :: 1544628337:4113, 64 bit:4.1.1:x86_64-Linux:megrez:2215936
     31 >> tst_memory_2 :: 1544628337:4113, 64 bit:4.1.1:x86_64-Linux:megrez:2215936
     41 >> tst_timer_1 :: 1544628337:4113, 64 bit:4.1.1:x86_64-Linux:megrez:8

  • Tst/Manual/Example_of_use_of_@sc{Letterplace}.tst

    ree3e7cd r178bd3  
    11LIB "tst.lib"; tst_init();
    22LIB "freegb.lib";
    3 ring r = 0,(x,y,z),dp;
     3ring r = 0,(x,y,z),Dp;
    44int d =4; // degree bound
    55def R = makeLetterplaceRing(d);

  • Tst/Manual/letterplace_reduce.res.gz.uu

    ree3e7cd r178bd3  
    11begin 644 letterplace_reduce.res.gz
    2 M'XL("(I=]%L"`VQE='1E<G!L86-E7W)E9'5C92YR97,`=5)+CX(P$+[S*R9F
    3 M#U"K@NXS9'O8[`5C]J![-RBC(<MBA9J%_OH=*@AH3`\ST_D>,TU7WY_!%P!X
    4 M`A;!!PQ4KL9)O!GX0-DZ3F-E.[Y511`"$E0*,YF$6UQG&)VV.$[Q;YRK4%FK
    5 M6FEJE`:[#'&_.6M=>C,!69SN(8-W<+E=\))KAT>R13P*B'`'2P+\AC^X:`V7
    6 M1+0]U_$A1V54EBWM24`<89A`0,22%:R$$6A6,LV!"E:8DC)N@J:2>JRHNG1@
    7 M2"4=BIJN-<6*I5N#Y\9@3@:YBNS`:9LO`N0A*4$VYJ11UA:Z5NVIO=:$(Q',
    8 M/%6[F:D/?:,G,R]M2R;YG-:?3"`]I!JS@V5X9W:3C6YO6E0=A]?UE4ZOOM$<
    9 M]=2[V&9HS^T.37OU-FB6,!NX%XYWX1S9\0YFVL'(.YA9%T/>\JX:_;7JDU>_
    10 0]Y3;GN,_6/_CGQMQ#P,`````
     2M'XL("(LH$5P"`VQE='1E<G!L86-E7W)E9'5C92YR97,`=5)+CX(P$+[S*R9F
     3M#U"KPKK/D.UAXP5C]J![-RBC(<MBA9J%_OH=*@AH3`\ST_D>,TU7W[/@"P`\
     4M`8O@$P8J5^,DW@Q\H&P=I[&R'=^J(@@!"2J%F4S"+:XSC$Y;'*?X-\Y5J*Q5
     5MK?1HE`:[#'&_.6M=>E,!69SN(8,/<+E=\))KA\]DBW@2$.$.E@3X#7]PT1HN
     6MB6A[KN-#CLJH+%O:LX`XPC"!@(@E*U@)(]"L9)H#%:PP)67<!$TE]5A1=>G`
     7MD$HZ%#5=:XH52[<&+XW!G`QR%=F!TS9?!<A#4H)LS$FCK"UTK=I3>ZL)1R*8
     8M>:IV,U,?^DY/9E[:EDSR.:T_F4!Z2#5F!\OPSNPF&]W>M*@Z#J_K*YU>?:,Y
     9MZJEWL<W0GML=FO;J;=`L839P+QSOPCFRXQW,8P<C[V"F70QYR[MJ]->J3U[]
     101WE-N>X[_8/T#<'*Z+`\#````
    1111`
    1212end

  • Tst/Manual/letterplace_reduce.stat

    ree3e7cd r178bd3  
    1 1 >> tst_memory_0 :: 1542741386:4113, 64 bit:4.1.1:x86_64-Darwin:Karims-MacBook-Pro.local:20012280
    2 1 >> tst_memory_1 :: 1542741386:4113, 64 bit:4.1.1:x86_64-Darwin:Karims-MacBook-Pro.local:23068672
    3 1 >> tst_memory_2 :: 1542741386:4113, 64 bit:4.1.1:x86_64-Darwin:Karims-MacBook-Pro.local:23094976
    4 1 >> tst_timer_1 :: 1542741386:4113, 64 bit:4.1.1:x86_64-Darwin:Karims-MacBook-Pro.local:610
     11 >> tst_memory_0 :: 1544628363:4113, 64 bit:4.1.1:x86_64-Linux:megrez:30936576
     21 >> tst_memory_1 :: 1544628363:4113, 64 bit:4.1.1:x86_64-Linux:megrez:33767424
     31 >> tst_memory_2 :: 1544628363:4113, 64 bit:4.1.1:x86_64-Linux:megrez:33828864
     41 >> tst_timer_1 :: 1544628363:4113, 64 bit:4.1.1:x86_64-Linux:megrez:19

  • Tst/Manual/letterplace_reduce.tst

    ree3e7cd r178bd3  
    11LIB "tst.lib"; tst_init();
    22LIB"freegb.lib";
    3 ring r = 0,(x,y,z),dp;
     3ring r = 0,(x,y,z),Dp;
    44def R = makeLetterplaceRing(10); setring R;
    55ideal I = y*x*y - z*y*z, x*y*x - z*x*y, z*x*z - y*z*x, x*x*x + y*y*y + z*z*z + x*y*z;

  • Tst/Manual/letterplace_std.res.gz.uu

    ree3e7cd r178bd3  
    11begin 644 letterplace_std.res.gz
    2 M'XL("*;?V5L"`VQE='1E<G!L86-E7W-T9"YR97,`39++;H,P%$3W?,55U`4X
    3 M@#"$/(3PHNH&%'619%>AB!0G0J4T`D<U_?I>&Q)GP<-S9\X`9G]XR]X!@#+8
    4 M9J\P$[WPF_HT2P#OCG5;"]M)+'4%QJ#A0O#NVI2?_-B+RF_YK]^+4EC["1-.
    5 MF'/'^>4TDA[#B$%7MQ?H((7`M:4[N'^.:U=7FSHNGD/',>8%@[H54/$+HHZG
    6 MGUM;82PVAICA\`P[5+_++[XUC[;#$CM^8BT9]%SH[IU15]A0\;*!#!&>)(.W
    7 M(@,9YA&11+J``I$>'F0PF?4]DV,&OX"=/=5L&.2)E7_0(M4,PT0Q+-(P5##4
    8 M(J*Q7DC5DLBY-FE;-&95]=T^O]L\8ULHVCJ(1@$)=!,%TU@;XB)%:9Q+Q5C%
    9 CU)B7],FZ+-+AL9S>A09,_P!J<V\][D_R8OT#2W36,BL"````
     2M'XL("!(J$5P"`VQE='1E<G!L86-E7W-T9"YR97,`39%!;X(P%,?O?(H7LP-4
     3M,!1$-(0>%B\8LX/NMA"#HQHRQ@S4K.S3[[6`]=#0_M_O_1Y-C^_;[`T`*(-]
     4M]@HST8E%79UG">#N5#65L)W$4E]@#&HN!&]O=?')3YTH%PW_772B$-9QU`2C
     5MYM)R?CT/ID<Q9-!6S15:2,%W;>GV[I_C;F^&6#*H&@$EOV+_Z?QS;TID(P-$
     6M#(L7.&#Z77SQO?F?`YKMR#'HBD''A1YX,&F,$TI>U)"API.D]V+2DWX>$DFD
     7M"Q@0Z>$BO>E93ST[[,%KV]G3F`V#76+M/FB>:H=Q8ACD:1`H&68AT5HOH.I(
     8MY%Q#&@N'7C5ZPN<3YAELJ6QK/QP"--!-Z(]E#41YBM%0E\H11]3`*_J$KO*T
     9:?QS'NU"?Z5=7+WKO;.HD+]8_KM^\/"`"````
    1010`
    1111end

  • Tst/Manual/letterplace_std.stat

    ree3e7cd r178bd3  
    1 1 >> tst_memory_0 :: 1541005222:4113, 64 bit:4.1.1:x86_64-Darwin:161-029.eduroam.rwth-aachen.de:741640
    2 1 >> tst_memory_1 :: 1541005222:4113, 64 bit:4.1.1:x86_64-Darwin:161-029.eduroam.rwth-aachen.de:2097168
    3 1 >> tst_memory_2 :: 1541005222:4113, 64 bit:4.1.1:x86_64-Darwin:161-029.eduroam.rwth-aachen.de:2121872
    4 1 >> tst_timer_1 :: 1541005222:4113, 64 bit:4.1.1:x86_64-Darwin:161-029.eduroam.rwth-aachen.de:71
     11 >> tst_memory_0 :: 1544628754:4113, 64 bit:4.1.1:x86_64-Linux:megrez:331512
     21 >> tst_memory_1 :: 1544628754:4113, 64 bit:4.1.1:x86_64-Linux:megrez:2215936
     31 >> tst_memory_2 :: 1544628754:4113, 64 bit:4.1.1:x86_64-Linux:megrez:2215936
     41 >> tst_timer_1 :: 1544628754:4113, 64 bit:4.1.1:x86_64-Linux:megrez:7

  • Tst/Manual/letterplace_std.tst

    ree3e7cd r178bd3  
    11LIB "tst.lib"; tst_init();
    22LIB "freegb.lib";
    3 ring r = 0,(x,y,z),(dp(1),dp(2));
     3ring r = 0,(x,y,z),Dp;
    44int degree_bound = 5;
    55def R = makeLetterplaceRing(5);

  • Tst/Manual/lpMonomialBasis.res.gz.uu

    ree3e7cd r178bd3  
    11begin 644 lpMonomialBasis.res.gz
    2 M'XL(")E5]%L"`VQP36]N;VUI86Q"87-I<RYR97,`G9-?:X,P%,7?_127L8=8
    3 M;#%J_R'-0QF,2K>'MF]EE&RF(\RJ:,;TVR\FVKC:I[WHS3TWYW<2R/[PM'D%
    4 M`$Q@NUG#@RC%).'O#R'(ZL13+I`=6LT?"($D?\G2[,)ILJ8E+R<I^YF4@@IK
    5 MW]IXK<TYIS&_:*>KZ!,H>/H)!:S`=5#EU+83YT8/",3L##LI7^@7VS(A6)$G
    6 M](/MY#8TMT,HF5`6.[-K2H#'C"80R7W5J!Y5,`;Y'=5F9D8@RP7/4E2P>+^6
    7 M1F9YH#RQS>B<**.$"45^5@=%46]B(2="*SKBMY7"C15,-CS=4$O=;&HI^)UP
    8 M(RDQ,.)`E@,==3FX?>0YV%%'1ZXM\YUTHDH6,DFM"DV61=!TZLX-N_?<W($;
    9 MUEZM4^NC$=,.,>L0\[\(/$3X,G#42]K+VJ755]9QE*\FJ7+6WM65UN-Y]WBN
    10 MX?WG+*?CP@1=FJ#8-4DQ-E&Q9[)BWX3%P6U:^1::!]8\GN\283M\M'X!]54A
    11 %VXL#````
     2M'XL("+,H$5P"`VQP36]N;VUI86Q"87-I<RYR97,`G9-?;X(P%,7?^10W9@_%
     3MH*&(_T+L@S%9)&X/ZIM93#?JT@R!0)?!MU]IP3+Q:2]P>\_M^9TVZ>&XV;X"
     4M`":PVZYA(`HQCOG[(`!9G7G"!;(#J_X#(1!G+VF27CF-U[3@Q3AA/^-"4&$=
     5M&ANOL;ED-.)7[703)P1RGGQ"#BMP'50ZE>UL,J/[!")V@;V4K_2+[9@0+,]B
     6M^L'V<AN:VP$43"B+O=DU)<`C1F,(Y;YR6`U+&('\#BLS,R.09H*G"<I9=%A+
     7M([,\4A[;9G1.E%',A"(_JX.BL#.QD!.!%9[PVTKA1@HF&YYNJ*5NUK44)JUP
     8M)RG1-V)/E@,M==F[?>0YV%%'1ZXM\YUUHE(6,DFE"DV6A5]WJM8-NX_<W)X;
     9MUEZ-4^.C$=,6,6L1\[\(W$=,9."PD[23M4VKKZSE*%]-4N6LN:L;K</S'O%<
     10MP_O/6<ZGA0FZ-$&Q:Y)B;*)BSV3%$Q,6^_=IY5NH'UC]>+X+A.W@R?H%=J9X
     11%38L#````
    1212`
    1313end

  • Tst/Manual/lpMonomialBasis.stat

    ree3e7cd r178bd3  
    1 1 >> tst_memory_0 :: 1542739353:4113, 64 bit:4.1.1:x86_64-Darwin:Karims-MacBook-Pro.local:720208
    2 1 >> tst_memory_1 :: 1542739353:4113, 64 bit:4.1.1:x86_64-Darwin:Karims-MacBook-Pro.local:2097168
    3 1 >> tst_memory_2 :: 1542739353:4113, 64 bit:4.1.1:x86_64-Darwin:Karims-MacBook-Pro.local:2121872
    4 1 >> tst_timer_1 :: 1542739353:4113, 64 bit:4.1.1:x86_64-Darwin:Karims-MacBook-Pro.local:90
     11 >> tst_memory_0 :: 1544628403:4113, 64 bit:4.1.1:x86_64-Linux:megrez:318584
     21 >> tst_memory_1 :: 1544628403:4113, 64 bit:4.1.1:x86_64-Linux:megrez:2215936
     31 >> tst_memory_2 :: 1544628403:4113, 64 bit:4.1.1:x86_64-Linux:megrez:2215936
     41 >> tst_timer_1 :: 1544628403:4113, 64 bit:4.1.1:x86_64-Linux:megrez:5

  • Tst/Manual/lpMonomialBasis.tst

    ree3e7cd r178bd3  
    11LIB "tst.lib"; tst_init();
    22LIB "fpadim.lib";
    3 ring r = 0,(x,y),dp;
     3ring r = 0,(x,y),Dp;
    44def R = makeLetterplaceRing(7); setring R;
    55ideal J = x*y*x - y*x*y;

  • Tst/Manual/makeLetterplaceRing.res.gz.uu

    ree3e7cd r178bd3  
    1 begin 640 makeLetterplaceRing.res.gz
    2 M'XL(")^SP%L"`VUA:V5,971T97)P;&%C95)I;F<N<F5S`*U4VVK"0!!]SU<,
    3 MTH<$@II$;9O0@*DO@A1:2U]++A.[F!N[FU;]^LX:FXA8A-:%;(;)F3.7D]WE
    4 MZVS^!`"6#XMY`#TI9#]C4<\#LMY9P:1N>)IZ@^]#'JYQ@5(BK[(PQA=6K/H%
    5 M?O6%#*6V/%#9!ZJ4(ZZBAJW]Z/C`*0HX/,#0U#?FUMP9IIY4NF68M-N&T8%'
    6 M/B28PI2P9S(3MH..?1`H]]13#^C1!@.(2TQ3%C,LI'#A^5GYBCJ/D$.9PF?(
    7 M!;@P4=[#BK(R7JMID+_D">[Y9M41HELN%&&.0ID;V,*NV<^0V<=DCPJ0=8TT
    8 MT]`;K&`[!,=HFYKX$$IJ*M*G9H^)D_Y[U+[38F^/L74ERP05`H#RD4E:0%36
    9 M1:+9;<C=<4CVIM"G`V)AE%&/K`#Y@20"&?M2M9;DOAL\]_9R!;_)95I-!EF2
    10 M,GD5<G1_:*QA1Q-0T<$5]<LNZW=)M>0BQ7GIG?_7,;I&'>.__H(6W0OJ(E`'
    11 0O!9T1KT;[1NUSY!H,P0`````
     1begin 644 makeLetterplaceRing.res.gz
     2M'XL(")XK$5P"`VUA:V5,971T97)P;&%C95)I;F<N<F5S`*U4:TO#,!3]WE]Q
     3M$#^T4*;MYFO%PNH0!!'F_"[M>EO#NK8DF8_]>F_:V:I,!FJ@3;@Y.?=Q;C)_
     4MF-[<`?!"W-Y$.-!*#PJ1'`3@U:,HA;:=P#(SPA"K>$FWI#7)NH@7="_*?%#2
     5MRT#I6%OS+96_I<HD49ZT;-WF,(3D4Y"XQ+%KO[IO[L9QIW6/&(5(*<.$`3O<
     6MV;[30T]"*-(-WR0`?];1$18599E8""JU&F,V,[9RO4I(HLKP'$N%,4Z-=3N2
     7MHEHL30G87LF4&KYI_0G1CS'*>$7*+%_QADW[WT'F?R:[,H"B3Z0M@=UBE=@0
     8MADZ7U&D(H:ZY=I,BIT3&]H0S]KKMLQ!%/:4\JM9E:O8`)D\IYQ-(C-'R._"Y
     9M`4?&S9R]-.COU1!Q4G!"HH1^(JXX+YJXK&''<O&AF?]%-#NM;<]QP9/O]*IX
     10MQ[TJT@\:,:.?Q'2]-B1=L6ZK.I8T[GB\GB?B+*-_5+?8K^X^3=.]%+L;8_CW
     11@.$;_$<?);QO4X_MMW@9SY]>*.R`XM-X!A7"/B$8$````
    1212`
    1313end

  • Tst/Manual/makeLetterplaceRing.stat

    ree3e7cd r178bd3  
    1 1 >> tst_memory_0 :: 1525958650:4112, 64 bit:4.1.1:x86_64-Linux:nepomuck:295192
    2 1 >> tst_memory_1 :: 1525958650:4112, 64 bit:4.1.1:x86_64-Linux:nepomuck:2215936
    3 1 >> tst_memory_2 :: 1525958650:4112, 64 bit:4.1.1:x86_64-Linux:nepomuck:2215936
    4 1 >> tst_timer_1 :: 1525958650:4112, 64 bit:4.1.1:x86_64-Linux:nepomuck:5
     11 >> tst_memory_0 :: 1544629151:4113, 64 bit:4.1.1:x86_64-Linux:megrez:300232
     21 >> tst_memory_1 :: 1544629151:4113, 64 bit:4.1.1:x86_64-Linux:megrez:2215936
     31 >> tst_memory_2 :: 1544629151:4113, 64 bit:4.1.1:x86_64-Linux:megrez:2215936
     41 >> tst_timer_1 :: 1544629151:4113, 64 bit:4.1.1:x86_64-Linux:megrez:7

  • Tst/Manual/makeLetterplaceRing.tst

    ree3e7cd r178bd3  
    11LIB "tst.lib"; tst_init();
    22LIB "freegb.lib";
    3 ring r = 0,(x,y,z),(dp(1),dp(2));
     3ring r = 0,(x,y,z),Dp;
    44def A = makeLetterplaceRing(2);
    55setring A;  A;
    6 attrib(A,"isLetterplaceRing");
    7 attrib(A,"uptodeg");  // degree bound
    8 attrib(A,"lV"); // number of variables in the main block
    9 setring r; def B = makeLetterplaceRing(2,1); // to compare:
     6isFreeAlgebra(A);
     7lpDegBound(A);  // degree bound
     8lpBlockSize(A); // number of variables in the main block
     9ring r2 = 0,(x,y,z),(dp(1), dp(2));
     10setring r2; def B = makeLetterplaceRing(2,1); // to compare:
    1011setring B;  B;
    1112tst_status(1);$

  • Tst/Manual/serreRelations.res.gz.uu

    ree3e7cd r178bd3  
    1 begin 640 serreRelations.res.gz
    2 M'XL(".U<NUL"`W-E<G)E4F5L871I;VYS+G)E<P!54MUKPC`0?^]?<<@>VO5#
    3 MDZAS%`MN@U&0/=2]B9.X)A)6:TDCV_[[79NN50C<Y??5ZY'-^TOZ!@`D@77Z
    4 M!"-3FZA0AU$,V.U5J8SKQ4Y3(4F@%EJ+3!3<J'-91Z7XCFK#C;/I4FB7(K40
    5 MQX,-ZDF6@"K-B1M8;=D.#RQ[;AH!#2`D`4R"'IQ%+=(0;$#G$6HL$<-X#*\?
    6 M9$_AF6O#2\!TK7YZ[4,"6I5'T+!$DRM)(&D@F1?DU3#7HIT++I4YY^*(RMG`
    7 M/2:0"PD9HB?^)=;"&*&K@G^*#'/=SN/U!C)IEF3:CV8#BMM5N>`%I!ATNT1W
    8 M%1`OMH0Z5862OVX:$)_ZBZM87&P:.^F6[):2W$N*)Z1M;6Z^['I44*M@H606
    9 M8!8@G<6ZB=]Y&\44%7AC_0FG;1TP?_[?TAO%@/E7=D0P=693&[(;E;6C6@/M
    10 8?PV?1?/4FG=TJ5W<Q9WS!_\$9/B5`@``
     1begin 644 serreRelations.res.gz
     2M'XL("-`H$5P"`W-E<G)E4F5L871I;VYS+G)E<P!54E]KPC`0?^^G.,8>ZII6
     3MDZAS%`MNPBC('NK>Q$F<B8356MK(MF^_2].U"H&[_/[U>F3]ODS?`(`FL$J?
     4MX<[4)LKU_BX&[':ZT,8?Q)ZMD"10RZJ2F<R%T>>BC@KY'=5&&&_=IK`V1552
     5M'O<NJ"-Y`KHP)V%@L>%;/##ON'$$C$!("8Q(!TZB!K$$[]%IA!I'Q#`<PNL'
     6MW3%X$941!6!ZI7\Z[6,"E2Z.4,$<3;ZB1#&B^(`LRWZN63,77$IS/L@C*B<]
     7M]Y3`02K($#V)+[F2QLBJS,6GS##7;SV#SD!'=DFF^6C6H[A=?9`BAQ2#;I?H
     8M+P@=Q([0IS+7ZM=/"0U8,+N*Q<6FL9=NZ':NZ(-B>$+65'L+5-NC@CD%#Q5W
     9M`'<`;2W.38/6:Q5C5."-=R<<-[7'@NE_RVX4/19<V1'!U(E+M60[*F]&=0;6
     108_1H^"_O4[#NZU#[NXM[[`Q7*N7*5`@``
    1111`
    1212end

  • Tst/Manual/serreRelations.stat

    ree3e7cd r178bd3  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:308352
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:669628
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:752644
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:15
     11 >> tst_memory_0 :: 1544628432:4113, 64 bit:4.1.1:x86_64-Linux:megrez:299832
     21 >> tst_memory_1 :: 1544628432:4113, 64 bit:4.1.1:x86_64-Linux:megrez:2215936
     31 >> tst_memory_2 :: 1544628432:4113, 64 bit:4.1.1:x86_64-Linux:megrez:2215936
     41 >> tst_timer_1 :: 1544628432:4113, 64 bit:4.1.1:x86_64-Linux:megrez:5

  • Tst/Manual/serreRelations.tst

    ree3e7cd r178bd3  
    55-1, 2, -3,
    660, -1, 2; // G^1_2 Cartan matrix
    7 ring r = 0,(f1,f2,f3),dp;
     7ring r = 0,(f1,f2,f3),Dp;
    88int uptodeg = 5;
    99def R = makeLetterplaceRing(uptodeg);

  • Tst/Manual/setLetterplaceAttributes.tst

    ree3e7cd r178bd3  
    33ring r = 0,(x(1),y(1),x(2),y(2),x(3),y(3),x(4),y(4)),dp;
    44def R = setLetterplaceAttributes(r, 4, 2); setring R;
    5 attrib(R,"isLetterplaceRing");
     5isFreeAlgebra(R);
     6lpDegBound(R);
     7lpBlockSize(R);
    68lieBracket(x(1),y(1),2);
    79tst_status(1);$

  • Tst/Old/err4.res.gz.uu

    r04d263 r178bd3  
    11begin 640 err4.res.gz
    2 M'XL("`5A15@``V5R<C0N<F5S`-U96Y.;QA)^]Z^82O(`!DG,A=MN:4^5?:IL
    3 M5V6=I#9/<3D.B]":&('"Q=&0RG]/]X`&9&FUVD0YQXD>0,Q\?9GN;WH:Z>;[
    4 M_[YZ30BA5V0VBW*2E&51DF))G&DP#2-BI'F=E%42UR3-2?P^*HEC/KGII=@4
    5 MI(P/9=)465(.XWQ*RC2_(^7<L8V-+>W6M(W8SM;FI<:(*_(1U(*UCP8UYV\V
    6 MTI+,WMCT[8!Q1QB&&&:U@)E(V]G!>2,<1UQK(V07Y%^15;%HLH1<S]&DC3IM
    7 M%!@PP8"IYE6],*Y'D^$5C%X^N:[>T+?S-ZA^P^1DPUIK(UM+HF>LG6PDFTAN
    8 M3S;<4M,M/KY%*::DI#_ATFLM+ETUU0H0]0`O16NQ#0PPU-%RN,+<IG41Q"$X
    9 MK9C(UD4D8*P>T[H6*)J`,+,0ASYQ\(+!-(!02&D>J93>A(&,Q;30!)5;K:?<
    10 MY,I-9=>SV%:Y@M@;I5NI1GT6N*.>$(((7#=:MA!H]5/@(<[R3@D8:X4R)#I#
    11 M$A>,"Q03=-WJM"M5$%:,G_K>F>Q##"CE-$;=:KOPNKTZKARTE$JNO&(V:E#2
    12 MF)R6*;S7X8>4`6L<-`I(!?![P&Z.$8)N6+V:H$-Q7+BEO.3=[%A5"*!N10`!
    13 M#T!+"T]JCCHPJ9Q#9VWEA.QFD&>2*[.@'MF!B,G&DG:/0$Z-V*[&,('#;E)#
    14 M&.K=S;-E-74TY5_/[Y(<MH.--]'=W('_%&J$K@;&=66_AKEW?V8O;!6R*_(A
    15 MS3)2#C8XUJ')7_IH76)Z3TUK\D6R3/-D0?)HE52D:.IU4Y,EH&ZS(OY`GNM2
    16 M1MU1*=O8QF)M/Q^%!`H/.#^;D;A(ELLT3I.\KB[(=]_A6-ZL;A-E^&-45N2"
    17 M4!SM/YTA4`'C1;E(E)'%>H08/A>]G_#9'%#!QBJ>:]_\_>@&9XQN>%]TXS*J
    18 MWE^017)G.";Y-:J(CK<.*W-0FAC/IM=16:?Y,$&/Q9L!8]9%)LER&`+&H*DE
    19 MH"94CXJ]Q3/W?(MGWM'%*R;=K=:SE`?>;/(-&Y;GW[?NX-"1N1@=F"S<KGUN
    20 M0`$P?Z14SW'8Q%5S6]7&$H+&0$A2:C$FJ0-71X86Y7`++)<%CO0M*OQ`8'4/
    21 M72^`^BP8$XX4_9U;+*">(YE%*?.$M)@C`FV*[D66L[\>61U:S@^&]A8[D;@H
    22 M2Z@])HGR13<<]Q'7<>2B"_#+Z<UT&-2;>/`9=FZZ2**,I/-1''U%IC))C-14
    23 M^WJ1KI*\2HN<&-$2.6R2.7'4C,(-PVI\JP<V&D@J)0,I.61PU62U&M98`;E+
    24 MYX[V0=`C/JS+XN>ILL7&/FR'85Q;$VSP@>M!/G)A@(HS)E"X!Q.XERGA=9EZ
    25 M7M3U;5,-XVJ+Z*=`H>JDJDD5E^FZ*]-04*'DKE9`!(T,QW*NLTVY4!O*H-,I
    26 M=4Q;XI?0M%N\!Z9I+]8Z\BY$OA2GEW/FGZ&>0R,*%X87CA>!%Q<O'EY\O`1X
    27 M"?$"2R`2122*2!21*")11**(1!&)(A)%6@2W"&X1W"*X17"+X!;!+8!//E5<
    28 M8!4NORZ-4M@L`!H!]C\J(7V`6(`'*L:IC/*[A$"@(5(*U5,BCAO8R`M\H\`C
    29 M-X&,)J0SD,%>`B,7Y*==*S]I!_BV_H@A<8J_Y`SD=8^3=Z9.LKY?T(QU[V&R
    30 MN\-D]S"3D0E@YA,RNSMD]H#,T'E!F0CUFCT@*\0'DU/5\TZ+D5IT.#`\AHC+
    31 M)_J9GRM*WN'.*AX??XM$42`O\NJ7)BH3'15/A9B\N'ZA1[RA/,/,TZ<$R($-
    32 M@QHC1C\W:/"WM?L5F:NCTF[EL&Q\AXL@,ANR(O.?H[BX-5Z-HA)B>:V-U9:Y
    33 MO:.";`C?=L)&I\!\%&N]$%C;J]9T]9V]X]*GY\J#SX[G(5T2.!EBLH[*:`6-
    34 M.TDK$JE0ZUCZ_--L^&+OL/3=PVWN#S_,H*UP^,'JR,]0'(DD[<FER;^G&?_,
    35 MO`3RJJ34>@0*PV_Z`39^EE8UN&=$63;P-H#&>'B`K/VN'Z#ZU4;9]0I?[KLZ
    36 M_L#;&E'Z;5*E;=*_DI0/"#D@]!27@6`H7P^"^\*$\/0$W5C;0@375?VNJJ.Z
    37 MJ=XM4]B'1W0#Y<4T3WZ=(EZ'`HBZ&[U_U>K^$00/AO=.=:L'U@;G*GQ!.)RE
    38 M45,74*[3F%1=)2_6-?3*U;9/3(NF4@6MVDJ'W<OGBV]G+V_T&&RO3M!0K.F5
    39 M7.!1]'V49NK^OBR:N_?;TRDA315!?P.[>;7620KAU.T50>)OZC*JDSLY[..0
    40 M7YUL:*3@`:-"*\V+PV;=T\T>-X4D[%Y4%>G@?7/40H?^GZ#H__1GD3`X5R#"
    41 MHXFFCG/^1%.'/I!HZK#SK(\Z_-/.A3KB:OSCS)!WZMS3(7P&/X11Q_L[$N$_
    42 MD/U'T.QTH^%#V:>/(-U14W3O9QZ*/]?VV3<<.S)W&8"_W!YF@!&9_W\24'$D
    43 M,(_-`W6/)Y\>8]RCC?D/)OT8UTY*=KB7;.8,R?;WDLWHO67>_RS2S8Y5P<=F
    44 M@/'CZ6;GY!9S'THW.X%=QTWL_3-`V;E:,\JZUBPNFFP!;_\U6:35.HODEA!+
    45 M<$7UZ!4QJBQ9UA\O+FY4TVN8V[=2RKL.[9MG0X=&^>X_`\!&U$*R.9VQR^P-
    46 F_M,+WS0:"/#UJV?D"VBZIUEZ^\7ET'T;U+S\ZLD?>+*E/OH>````
     2M'XL("$<A$5P"`V5R<C0N<F5S`-U96Y.;1A9^]Z_HRNX#&"31%VXSI=DJ>ZL<
     3M5^TX24V>XO(ZC$!C8@1:+HZ:K?WO.:=!#;(TTB0FN\GJ`8;N[USZG*]/'YB[
     4M[__^^@TAA-Z0Q2+*25*614F*-7'FP3R,B)'F=5)6R:HF:4Y6'Z*2..:SNUZ*
     5MS4'*^%@F394EY3#.YZ1,\P=2+AW;V-G2;DW;6-G9UKS6&'%#/H%:L/;)H.;R
     6M[4Y:DMD[F[X;,.X(PQ##K!8P,VD[!SAOA..(:VV$'(+\&[(IXB9+R.T23=JH
     7MTT:!`1,,F&I9U;%Q.YH,;V#T^MEM]9:^6[Y%]3LF9SO66CO96A(]8^UL)]E,
     8M<GNVXY::;O'Q'4HQ)27]&9=>:W'IJJE6@*@'>"E:B^U@@*&.EL,5YG:MBR`.
     9MP6G%3+8N(@%C]9C6M4#1#(29A3CTB8,7#*8!A$)*\TBE]&8,9"RFA6:HW&H]
     10MY297;BJ[GL7VRA7$WBG=2C7JL\`=]8001."ZT;*%0*N?`@]QEG=*P%@KE"'1
     11M&9*X8%R@F*'K5J==J8*P8OS4WYW)/L2`4DYCU*VV"Z_;J^/*04NIY,HK9J,&
     12M)8W):9G">QU^2!FPQD&C@%0`OP<<YA@AZ(;5JPDZ%,>%6\I+WLV.584`ZE8$
     13M$/``M+3PI.:H`Y/*.7365D[(;@9Y)KDR"^J1'8B8[2QI]PCDU(CM:@P3..PF
     14M-82A/MP\>U931U/^S?(AR6$[V'@3W<T=^$^A1NAJ8-Q6]AN8>_];]L)>(;LA
     15M'],L(^5@@V,=FGW13^L2\T=J6I/'R3K-DYCDT2:I2-'4VZ8F:T#=9\7J(WFI
     16M2QEU1Z5L9QOQUGXY"@D4'G!^L2"K(EFOTU6:Y'5U1;[[#L?R9G.?*,.?HK(B
     17M5X3B:/_K#($*&"_*.%%&XNT(,?RN>C_AMSNA@HU5O-2^^<?1#2:,;OA8=%=E
     18M5'VX(G'R8#@F^3FJB(ZW#BMS4)H8+^:W45FG^3!!S\6;`6.V12;)>A@"QJ"I
     19M-:!F5(^*H\4S=[K%,^_LXA63'C;;1<H#;S'[A@W+\Q];=W#JR(Q'!R8+]VM?
     20M&E``S']2JN<X;.*JN:]J8PU!8R`D*;48D]2!JR-#BW*X!9;+`D?Z%A5^(+"Z
     21MAZX70'T6C`E'BO[.+190SY',HI1Y0EK,$8$V18\BR]F71U:'EO.3H;W'3F15
     22ME"74'I-$>=P-K_J(ZSART07XZ_G=?!C4FWCP&79N&B=11M+E*(Z^(E.9)$9J
     23MJGT=IYLDK](B)T:T1@Z;9$D<-:-PP[`:W^N!C0:22LE`2@X9W#19K88U5D#N
     24MTJ6C?1#TC`_;LOAIKFRQL0_[81C7U@0;?.!ZD(]<&*!BP@0*]V0"CS(EO"Y3
     25M+XNZOF^J85QM$?T4*%2=5#6I5F6Z[<HT%%0HN9L-$$$CP[&<Z^Q3+M2&,NA\
     26M3AW3EOA':-HMW@/3M..MCKP+D2_%T\LY\R>HY]"(PH7AA>-%X,7%BX<7'R\!
     27M7D*\P!*(1!&)(A)%)(I(%)$H(E%$HHA$D1;!+8);!+<(;A'<(KA%<`O@)Y\J
     28M+K`*EU^71BEL%@"-`/LWE9`^0"S``Q7C5$;Y0T(@T!`IA>HIL5HUL)%C?*/`
     29M(S>!C":D,Y#!7@(C5^3'0RL_:@?XOOZ((7&*OV0"\KKGR;M0)UG?+VC&NH\P
     30MV3U@LGN:R<@$,/,9F=T#,GM`9NB\H$R$>LT>D!7B@\FIZF6GQ4@M.AP8'D/$
     31M]3/]S*>*DB?.1DFM*TX4!?(BK_[51&6BH^*I$)-7MZ_TB#>49YAY_IP`.;!A
     32M4&/$Z.<&#?Z^=K\F2W54VJT<EHWO<!%$9D<V9/E3M"KNC=>CJ(187FMCLV=N
     33M[Z@@.\+WG;#1*3!_%6N]$%C;J]9T]9VCX]*G4^7!9^?SD*X)G`PKLHW*:`.-
     34M.TDK$JE0ZUCZ_/-L^.+HL/3=TVWN#S\LH*UP^,GJR"<HCD22]LFER??^%%X"
     35M>552:CT"A>'?^@$V?I96-;AG1%DV\#:`QGAX@*S]1S]`]:N-LNL5_D+._N!M
     36MC2C]-JG2-NE?2<H+0@X(/<=E(!C*UT5P7Y@0GCY!-]:V$,%U5;^OZJANJO?K
     37M%/;A&=U`>3'/DY_GB->A`*(>1N__:G5_"H('PWNGNM4#:X.I"E\0#F=IU-0%
     38ME.MT1:JNDA?;&GKE:M\GID53J8)6[:7#[N7SU;>+K^_T&&RO3M!0K.F57.%1
     39M]'V49NK^H2R:AP_[TRDA315!?P.[>;/520KAU.T50>+OZC*JDP<Y[..0WSS9
     40MT$C!!:-"*\V+TV;=FXG6AR3L7E05Z>!]<]1"A_YOH.A_];-(&$P5B/!LHJGC
     41M3)]HZM`+B:8.FV9]U.&?=R[4$3?CCS-#WJGC_F$_A%''^ST2X5_(?O![&`TO
     42M99\Z$V6?'GWFH?BYML^^X=B1><@`_')[F@%&9/[O24#%F<#\VCQ0]WSRJ3>E
     43M,?]BTH/+YLZ;"(^2S9PAV?Y1LAE]M,S[?XAT,S9A!A@_GVXV);>8>RG=S/O"
     44M=#/_.-U3M6:4=:W9JFBR&-[^:Q*GU3:+Y)X0:W!%]>@5,:HL6=>?KJ[N5--K
     45MF/NW4LJ[#NV;%T.'1OGA?P:`C:B%9$NZ8-?96_Q/+_RET4"`?[Q^0;Z"IGN>
     466I?=?70_=MT'-Z[\^^P5XLJ4^^AX`````
    4747`
    4848end

  • Tst/Old/err4.stat

    r04d263 r178bd3  
    1 1 >> tst_memory_0 :: 1480941829:4100, 64 bit:4.1.0:x86_64-Linux:nepomuck:105456
    2 1 >> tst_memory_1 :: 1480941829:4100, 64 bit:4.1.0:x86_64-Linux:nepomuck:2359296
    3 1 >> tst_memory_2 :: 1480941829:4100, 64 bit:4.1.0:x86_64-Linux:nepomuck:2375680
    4 1 >> tst_timer_1 :: 1480941829:4100, 64 bit:4.1.0:x86_64-Linux:nepomuck:1
     11 >> tst_memory_0 :: 1544626503:4113, 64 bit:4.1.1:x86_64-Linux:nepomuck:80528
     21 >> tst_memory_1 :: 1544626503:4113, 64 bit:4.1.1:x86_64-Linux:nepomuck:2277376
     31 >> tst_memory_2 :: 1544626503:4113, 64 bit:4.1.1:x86_64-Linux:nepomuck:2286496
     41 >> tst_timer_1 :: 1544626503:4113, 64 bit:4.1.1:x86_64-Linux:nepomuck:1

  • doc/NEWS.texi

    r04d263 r178bd3  
    4040Changes in the kernel/build system:
    4141@itemize
     42@item improved heuristic for @code{det} (@nref{det})
    4243@item improved reading of long polynomials
    4344@item improved groebner bases over Z coefficients

  • gfanlib/gfanlib_mixedvolume.cpp

    r04d263 r178bd3  
    55 *      Author: anders
    66 */
    7 
     7#include <stddef.h>
    88#include "gfanlib_mixedvolume.h"
    99

  • gfanlib/gfanlib_polyhedralfan.cpp

    r04d263 r178bd3  
    66 */
    77
     8#include <stddef.h>
    89#include <sstream>
    910#include "gfanlib_polyhedralfan.h"

  • gfanlib/gfanlib_polymakefile.cpp

    r04d263 r178bd3  
    55 *      Author: anders
    66 */
    7 
     7#include <stddef.h>
    88#include "gfanlib_polymakefile.h"
    99

  • gfanlib/gfanlib_symmetriccomplex.cpp

    r04d263 r178bd3  
    66 */
    77
     8#include <stddef.h>
    89#include "gfanlib_symmetriccomplex.h"
    910#include "gfanlib_polymakefile.h"

  • gfanlib/gfanlib_symmetry.cpp

    r04d263 r178bd3  
    55 *      Author: anders
    66 */
    7 
     7#include <stddef.h>
    88#include "gfanlib_symmetry.h"
    99#include <map>

  • gfanlib/gfanlib_traversal.cpp

    r04d263 r178bd3  
     1#include <stddef.h>
    12#include "gfanlib_traversal.h"
    23#include "gfanlib_symmetry.h"

  • gfanlib/gfanlib_zcone.cpp

    r04d263 r178bd3  
    55 *      Author: anders
    66 */
    7 
     7#include <stddef.h>
    88#include "gfanlib_zcone.h"
    99

  • gfanlib/gfanlib_zfan.cpp

    r04d263 r178bd3  
    55 *      Author: anders
    66 */
    7 
     7#include <stddef.h>
    88#include "gfanlib_zfan.h"
    99#include "gfanlib_polymakefile.h"

  • kernel/GBEngine/kInline.h

    ree3e7cd r178bd3  
    132132    if (r->isLPring)
    133133    {
    134       shift = p_mFirstVblock(p_in, r);
     134      shift = si_max(p_mFirstVblock(p_in, r) - 1, 0);
    135135      if (!shift) p_Test(p_in, r);
    136136    }
    … …  
    147147    if (currRing->isLPring)
    148148    {
    149       shift = p_mFirstVblock(p_in, currRing);
     149      shift = si_max(p_mFirstVblock(p_in, currRing) - 1, 0);
    150150      if (!shift) p_Test(p_in, currRing);
    151151    }
    … …  
    174174    if (c_r->isLPring)
    175175    {
    176       shift = p_mFirstVblock(p_in, c_r);
     176      shift = si_max(p_mFirstVblock(p_in, c_r) - 1, 0);
    177177      if (!shift) p_Test(p_in, currRing);
    178178    }

  • kernel/GBEngine/kspoly.cc

    ree3e7cd r178bd3  
    140140#ifdef HAVE_SHIFTBBA
    141141  poly lmRight;
    142   if (tailRing->isLPring) {
     142  if (tailRing->isLPring)
     143  {
     144    assume(PR->shift == 0);
     145    assume(PW->shift == si_max(p_mFirstVblock(PW->p, tailRing) - 1, 0));
    143146    k_SplitFrame(lm, lmRight, PW->shift + 1, tailRing);
    144147  }
    … …  
    271274  if (tailRing->isLPring)
    272275  {
     276    assume(PR->shift == 0);
     277    assume(PW->shift == si_max(p_mFirstVblock(PW->p, tailRing) - 1, 0));
    273278    k_SplitFrame(lm, lmRight, PW->shift + 1, tailRing);
    274279  }
    … …  
    623628#ifdef HAVE_SHIFTBBA
    624629  poly lmRight;
    625   if (tailRing->isLPring) {
     630  if (tailRing->isLPring)
     631  {
     632    assume(PR->shift == 0);
     633    assume(PW->shift == si_max(p_mFirstVblock(PW->p, tailRing) - 1, 0));
    626634    k_SplitFrame(lm, lmRight, PW->shift + 1, tailRing);
    627635  }
    … …  
    834842#ifdef HAVE_SHIFTBBA
    835843  poly lmRight;
    836   if (tailRing->isLPring) {
     844  if (tailRing->isLPring)
     845  {
     846    assume(PR->shift == 0);
     847    assume(PW->shift == si_max(p_mFirstVblock(PW->p, tailRing) - 1, 0));
    837848    k_SplitFrame(lm, lmRight, PW->shift + 1, tailRing);
    838849  }
    … …  
    10781089#ifdef HAVE_SHIFTBBA
    10791090  poly lmRight;
    1080   if (tailRing->isLPring) {
     1091  if (tailRing->isLPring)
     1092  {
     1093    assume(PR->shift == 0);
     1094    assume(PW->shift == si_max(p_mFirstVblock(PW->p, tailRing) - 1, 0));
    10811095    k_SplitFrame(lm, lmRight, PW->shift + 1, tailRing);
    10821096  }
    … …  
    11921206  if (tailRing->isLPring)
    11931207  {
    1194     // note: because of the crits, p2 is never shifted
     1208    assume(si_max(p_mFirstVblock(p2, tailRing) - 1, 0) == 0);
     1209    // note: because of how the pairs are created, p2 should never be shifted
    11951210    int split = p_mFirstVblock(p1, tailRing);
    11961211    k_SplitFrame(m1, m12, split, tailRing);
    … …  
    12691284  if (tailRing->isLPring)
    12701285  {
     1286    // just to be sure, check that the shift is correct
     1287    assume(Pair->shift == 0);
     1288    assume(si_max(p_mFirstVblock(Pair->p, tailRing) - 1, 0) == Pair->shift); // == 0
     1289
    12711290    p_LmDelete(m12, tailRing);
    12721291    p_LmDelete(m22, tailRing);

  • kernel/GBEngine/kstd1.cc

    ree3e7cd r178bd3  
    25682568#ifdef HAVE_SHIFTBBA
    25692569ideal kStdShift(ideal F, ideal Q, tHomog h,intvec ** w, intvec *hilb,int syzComp,
    2570                 int newIdeal, intvec *vw)
     2570                int newIdeal, intvec *vw, BOOLEAN rightGB)
    25712571{
    25722572  ideal r;
    … …  
    25752575  kStrategy strat=new skStrategy;
    25762576  intvec* temp_w=NULL;
     2577
     2578  strat->rightGB = rightGB;
    25772579
    25782580  if(!TEST_OPT_RETURN_SB)

  • kernel/GBEngine/kstd1.h

    ree3e7cd r178bd3  
    3939          int syzComp=0,int newIdeal=0, intvec *vw=NULL, s_poly_proc_t sp=NULL);
    4040
    41 ideal kStdShift(ideal F, ideal Q, tHomog h,intvec ** w, intvec *hilb,int syzComp,
    42                 int newIdeal, intvec *vw);
     41ideal kStdShift(ideal F, ideal Q, tHomog h,intvec ** mw, intvec *hilb=NULL,
     42    int syzComp=0, int newIdeal=0, intvec *vw=NULL, BOOLEAN rightGB=FALSE);
    4343
    4444/* the following global data are defined in kutil.cc */

  • kernel/GBEngine/kstd2.cc

    ree3e7cd r178bd3  
    41784178  initBbaShift(strat); /* DONE */
    41794179  /*set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair*/
    4180   /*Shdl=*/initBuchMoraShift(F, Q,strat); /* updateS with no toT, i.e. no init for T */
    4181   updateSShift(strat); /* initializes T */
     4180  /*Shdl=*/initBuchMora(F, Q,strat);
    41824181  if (strat->minim>0) strat->M=idInit(IDELEMS(F),F->rank);
    41834182  reduc = olddeg = 0;
    … …  
    43524351        // posInS only depends on the leading term
    43534352        strat->enterS(strat->P, pos, strat, strat->tl);
    4354         enterTShift(strat->P, strat);
     4353        if (!strat->rightGB)
     4354          enterTShift(strat->P, strat);
    43554355      }
    43564356
    … …  
    43694369          // and add pairs
    43704370          int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
    4371           int atR=strat->tl+1; // enterTShift introduces P.p=T[tl+1], T[tl+2]...
    4372           enterTShift(strat->P,strat,-1);
    4373           enterpairsShift(strat->P.p,strat->sl,strat->P.ecart,pos,strat, atR);
    4374           strat->enterS(strat->P, pos, strat, atR);
     4371          enterT(strat->P, strat);
     4372          enterpairsShift(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
     4373          strat->enterS(strat->P, pos, strat, strat->tl);
     4374          if (!strat->rightGB)
     4375            enterTShift(strat->P,strat);
    43754376        }
    43764377      }
    … …  
    43934394    for (int k = 0; k <= strat->sl; ++k)
    43944395    {
     4396      if ((strat->fromQ!=NULL) && (strat->fromQ[k])) continue; // do not reduce Q_k
    43954397      for (int j = 0; j<=strat->tl; ++j)
    43964398      {
    … …  
    44574459
    44584460
    4459 ideal freegb(ideal I)
     4461ideal freegb(ideal F)
    44604462{
    44614463  assume(rIsLPRing(currRing));
    4462   assume(idIsInV(I));
    4463   ideal RS = kStdShift(I,NULL, testHomog, NULL,NULL,0,0,NULL);
     4464  assume(idIsInV(F));
     4465  ideal RS = kStdShift(F, NULL, testHomog, NULL);
     4466  idSkipZeroes(RS); // is this even necessary?
     4467  assume(idIsInV(RS));
     4468  return(RS);
     4469}
     4470
     4471ideal rightgb(ideal F, ideal Q)
     4472{
     4473  assume(rIsLPRing(currRing));
     4474  assume(idIsInV(F));
     4475  ideal RS = kStdShift(F, Q, testHomog, NULL, NULL, 0, 0, NULL, TRUE);
    44644476  idSkipZeroes(RS); // is this even necessary?
    44654477  assume(idIsInV(RS));

  • kernel/GBEngine/kutil.cc

    ree3e7cd r178bd3  
    80358035      Print("\n  %d:",i);
    80368036      p_wrp(strat->S[i], currRing, strat->tailRing);
     8037      if (strat->fromQ!=NULL && strat->fromQ[i])
     8038        Print(" (from Q)");
    80378039    }
    80388040    strat->news = FALSE;
    … …  
    91519153        enterT(h,strat);
    91529154        strat->S_2_R[i] = strat->tl;
     9155#ifdef HAVE_SHIFTBBA
     9156        if (currRing->isLPring)
     9157          enterTShift(h, strat);
     9158#endif
    91539159      }
    91549160    }
    … …  
    92479253      enterT(h,strat);
    92489254      strat->S_2_R[i] = strat->tl;
     9255#ifdef HAVE_SHIFTBBA
     9256      if (currRing->isLPring)
     9257        enterTShift(h, strat);
     9258#endif
    92499259    }
    92509260    if (suc!= -1) updateS(toT,strat);
    … …  
    93619371void enterSBbaShift (LObject &p,int atS,kStrategy strat, int atR)
    93629372{
    9363   int toInsert = itoInsert(p.p, strat->tailRing);
    9364   for (int i = toInsert; i > 0; i--)
     9373  int maxPossibleShift = p_mLPmaxPossibleShift(p.p, strat->tailRing);
     9374  for (int i = maxPossibleShift; i > 0; i--)
    93659375  {
    93669376    LObject qq;
    … …  
    1020410214  strat->cp = 0;
    1020510215  strat->c3 = 0;
     10216#ifdef HAVE_SHIFTBBA
     10217  strat->cv = 0;
     10218#endif
    1020610219  strat->tail = pInit();
    1020710220  /*- set s -*/
    … …  
    1026710280    updateS(TRUE,strat);
    1026810281  }
    10269   if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
    10270   strat->fromQ=NULL;
     10282#ifdef HAVE_SHIFTBBA
     10283  if (!(rIsLPRing(currRing) && strat->rightGB)) // for right GB, we need to check later whether a poly is from Q
     10284#endif
     10285  {
     10286    if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
     10287    strat->fromQ=NULL;
     10288  }
    1027110289  assume(kTest_TS(strat));
    1027210290}
    … …  
    1028810306  pLmFree(&strat->tail);
    1028910307  strat->syzComp=0;
     10308
     10309#ifdef HAVE_SHIFTBBA
     10310  if (rIsLPRing(currRing) && strat->rightGB)
     10311  {
     10312    if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
     10313    strat->fromQ=NULL;
     10314  }
     10315#endif
    1029010316}
    1029110317
    … …  
    1218012206
    1218112207#ifdef HAVE_SHIFTBBA
    12182 /* including the self pairs */
    12183 void updateSShift(kStrategy strat)
    12184 {
    12185   /* to use after updateS(toT=FALSE,strat) */
    12186   /* fills T with shifted elt's of S */
    12187   int i;
    12188   LObject h;
    12189   int atT = -1; // or figure out smth better
    12190   strat->tl = -1; // init
    12191   for (i=0; i<=strat->sl; i++)
    12192   {
    12193     memset(&h,0,sizeof(h));
    12194     h.p =  strat->S[i];
    12195     strat->initEcart(&h);
    12196     h.sev = strat->sevS[i];
    12197     h.t_p = NULL;
    12198     h.GetTP(); // creates correct t_p
    12199     /*puts the elements of S with their shifts to T*/
    12200     //    int atT, int uptodeg, int lV)
    12201     strat->S_2_R[i] = strat->tl + 1; // the el't with shift 0 will be inserted first
    12202     // need a small check for above; we insert >=1 elements
    12203     // insert this check into kTest_TS ?
    12204     enterTShift(h,strat,atT);
    12205   }
    12206   /* what about setting strat->tl? */
     12208// creates if possible (q,p), (shifts(q),p)
     12209static void enterOnePairWithShifts (int q_inS /*also i*/, poly q, poly p, int ecartp, int p_isFromQ, kStrategy strat, int atR, int p_lastVblock, int q_lastVblock)
     12210{
     12211  // note: ecart and isFromQ is for p
     12212  assume(q_inS < 0 || strat->S[q_inS] == q); // if q is from S, q_inS should be the index of q in S
     12213  assume(pmFirstVblock(p) == 1);
     12214  assume(pmFirstVblock(q) == 1);
     12215  assume(p_lastVblock == pmLastVblock(p));
     12216  assume(q_lastVblock == pmLastVblock(q));
     12217
     12218  // TODO: is ecartq = 0 still ok?
     12219  int ecartq = 0; //Hans says it's ok; we're in the homog case, no ecart
     12220
     12221  int q_isFromQ = 0;
     12222  if (strat->fromQ != NULL && q_inS >= 0)
     12223    q_isFromQ = strat->fromQ[q_inS];
     12224
     12225  int degbound = currRing->N/currRing->isLPring;
     12226  int neededShift = p_lastVblock - 1;
     12227  int maxPossibleShift = degbound - q_lastVblock;
     12228  int maxShift = si_min(neededShift, maxPossibleShift);
     12229  int firstShift = (q == p ? 1 : 0); // do not add (q,p) if q=p
     12230  for (int j = firstShift; j <= maxShift; j++)
     12231  {
     12232    poly qq = pLPCopyAndShiftLM(q, j);
     12233    enterOnePairShift(qq, p, ecartp, p_isFromQ, strat, -1, ecartq, q_isFromQ, j, q_inS);
     12234  }
    1220712235}
    1220812236#endif
    1220912237
    1221012238#ifdef HAVE_SHIFTBBA
    12211 void initBuchMoraShift (ideal F,ideal Q,kStrategy strat)
    12212 {
    12213   strat->interpt = BTEST1(OPT_INTERRUPT);
    12214   strat->kHEdge=NULL;
    12215   if (rHasGlobalOrdering(currRing)) strat->kHEdgeFound=FALSE;
    12216   /*- creating temp data structures------------------- -*/
    12217   strat->cp = 0;
    12218   strat->c3 = 0;
    12219   strat->cv = 0;
    12220   strat->tail = pInit();
    12221   /*- set s -*/
    12222   strat->sl = -1;
    12223   /*- set L -*/
    12224   strat->Lmax = setmaxL;
    12225   strat->Ll = -1;
    12226   strat->L = initL();
    12227   /*- set B -*/
    12228   strat->Bmax = setmaxL;
    12229   strat->Bl = -1;
    12230   strat->B = initL();
    12231   /*- set T -*/
    12232   strat->tl = -1;
    12233   strat->tmax = setmaxT;
    12234   strat->T = initT();
    12235   strat->R = initR();
    12236   strat->sevT = initsevT();
    12237   /*- init local data struct.---------------------------------------- -*/
    12238   strat->P.ecart=0;
    12239   strat->P.length=0;
    12240   if (rHasLocalOrMixedOrdering(currRing))
    12241   {
    12242     if (strat->kHEdge!=NULL) pSetComp(strat->kHEdge, strat->ak);
    12243     if (strat->kNoether!=NULL) pSetComp(strat->kNoetherTail(), strat->ak);
    12244   }
    12245   if(rField_is_Ring(currRing))
    12246   {
    12247     /*Shdl=*/initSL(F, Q,strat); /*sets also S, ecartS, fromQ */
    12248   }
    12249   {
    12250     if(TEST_OPT_SB_1)
    12251     {
    12252       int i;
    12253       ideal P=idInit(IDELEMS(F)-strat->newIdeal,F->rank);
    12254       for (i=strat->newIdeal;i<IDELEMS(F);i++)
    12255       {
    12256         P->m[i-strat->newIdeal] = F->m[i];
    12257         F->m[i] = NULL;
    12258       }
    12259       initSSpecial(F,Q,P,strat);
    12260       for (i=strat->newIdeal;i<IDELEMS(F);i++)
    12261       {
    12262         F->m[i] = P->m[i-strat->newIdeal];
    12263         P->m[i-strat->newIdeal] = NULL;
    12264       }
    12265       idDelete(&P);
    12266     }
    12267     else
    12268     {
    12269       /*Shdl=*/initSL(F, Q,strat); /*sets also S, ecartS, fromQ */
    12270       // /*Shdl=*/initS(F, Q,strat); /*sets also S, ecartS, fromQ */
    12271     }
    12272   }
    12273   strat->fromT = FALSE;
    12274   if (!TEST_OPT_SB_1)
    12275   {
    12276     /* the only change: we do not fill the set T*/
    12277     if(!rField_is_Ring(currRing)) updateS(FALSE,strat);
    12278   }
    12279   if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
    12280   strat->fromQ=NULL;
    12281   /* more changes: fill the set T with all the shifts of elts of S*/
    12282   /* is done by other procedure */
     12239// creates if possible (q,p), use it when q is already shifted
     12240static void enterOnePairWithoutShifts (int p_inS /*also i*/, poly q, poly p, int ecartq, int q_isFromQ, kStrategy strat, int atR, int p_lastVblock, int q_shift)
     12241{
     12242  // note: ecart and isFromQ is for p
     12243  assume(p_inS < 0 || strat->S[p_inS] == p); // if p is from S, p_inS should be the index of p in S
     12244  assume(pmFirstVblock(p) == 1);
     12245  assume(p_lastVblock == pmLastVblock(p));
     12246  assume(q_shift == pmFirstVblock(q) - 1);
     12247
     12248  // TODO: is ecartp = 0 still ok?
     12249  int ecartp = 0; //Hans says it's ok; we're in the homog e:, no ecart
     12250
     12251  int p_isFromQ = 0;
     12252  if (strat->fromQ != NULL && p_inS >= 0)
     12253    p_isFromQ = strat->fromQ[p_inS];
     12254
     12255  int maxNeededShift = p_lastVblock - 1;
     12256  if (q_shift <= maxNeededShift)
     12257    enterOnePairShift(q, p, ecartp, p_isFromQ, strat, -1, ecartq, q_isFromQ, q_shift, -1);
    1228312258}
    1228412259#endif
    1228512260
    1228612261#ifdef HAVE_SHIFTBBA
    12287 /*1
    12288 * put the pairs (sh \dot s[i],p)  into the set B, ecart=ecart(p)
    12289 */
    12290 static void enterOnePairManyShifts (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
    12291 {
    12292   poly s = strat->S[i];
    12293   assume(i<=strat->sl); // from OnePair
    12294 
    12295   /* cycles through all shifts of s[i] until uptodeg - lastVblock(s[i]) */
    12296   /* that is create the pairs (f, s \dot g)  */
    12297 
    12298   //  poly q = pCopy(pHead(strat->S[i])); // lm in currRing
    12299   //  pNext(q) = prCopyR(pNext(strat->S[i]),strat->tailRing,currRing); // zero shift
    12300 
    12301  /* determine how many elements we have to insert for a given s[i] */
    12302   /* x(0)y(1)z(2) : lastVblock-1=2, to add until lastVblock=uptodeg-1 */
    12303   /* hence, a total number of elt's to add is: */
    12304   /*  int toInsert = 1 + (uptodeg-1) - (pLastVblock(p.p, lV) -1);  */
    12305   int toInsert =  itoInsert(s, currRing);
    12306 
    12307 
    12308   /* these vars hold for all shifts of s[i] */
    12309   int ecartq = 0; //Hans says it's ok; we're in the homog case, no ecart
    12310 
    12311   int qfromQ;
    12312   if (strat->fromQ != NULL)
    12313   {
    12314     qfromQ = strat->fromQ[i];
    12315   }
    12316   else
    12317   {
    12318     qfromQ = -1;
    12319   }
    12320 
    12321   // for the 0th shift: insert the orig. pair
    12322   enterOnePairShift(s, p, ecart, isFromQ, strat, -1, ecartq, qfromQ, 0, i);
    12323 
    12324   for (int j = 1; j <= toInsert; j++)
    12325   {
    12326     poly q = pLPCopyAndShiftLM(s, j);
    12327     enterOnePairShift(q, p, ecart, isFromQ, strat, -1, ecartq, qfromQ, j, i);
    12328   }
    12329 }
    12330 #endif
    12331 
    12332 #ifdef HAVE_SHIFTBBA
    12333 /*1
    12334 * put the pairs (sh \dot qq,p)  into the set B, ecart=ecart(p)
    12335 * despite the name, not only self shifts
    12336 */
    12337 void enterOnePairSelfShifts (poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int /*atR*/)
    12338 {
    12339   /* should cycle through all shifts of q until uptodeg - lastVblock(q) */
    12340   /* that is create the pairs (f, s \dot g)  */
    12341 
    12342   int toInsert =  itoInsert(qq, currRing);
    12343 
    12344   /* these vars hold for all shifts of s[i] */
    12345   int ecartq = 0; //Hans says it's ok; we're in the homog case, no ecart
    12346   int qfromQ = 0; // strat->fromQ[i];
    12347 
    12348   /* since this proc is applied twice for (h, s*g) and (g,s*h), init j with 1 */
    12349   for (int j = 1; j<= toInsert; j++)
    12350   {
    12351     poly q = pLPCopyAndShiftLM(qq, j);
    12352     enterOnePairShift(q, p, ecart, isFromQ, strat, -1, ecartq, qfromQ, j, -1);
    12353   }
    12354 }
    12355 #endif
    12356 
    12357 #ifdef HAVE_SHIFTBBA
     12262
     12263#ifdef KDEBUG
     12264// enable to print which pairs are considered or discarded and why
     12265/* #define CRITERION_DEBUG */
     12266#endif
    1235812267/*2
    1235912268* put the pair (q,p)  into the set B, ecart=ecart(p), q is the shift of some s[i]
    … …  
    1236112270void enterOnePairShift (poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS)
    1236212271{
     12272#ifdef CRITERION_DEBUG
     12273  if (TEST_OPT_DEBUG)
     12274  {
     12275    PrintS("Consider pair ("); wrp(q); PrintS(", "); wrp(p); PrintS(")"); PrintLn();
     12276    // also write the LMs in separate lines:
     12277    poly lmq = pHead(q);
     12278    poly lmp = pHead(p);
     12279    pSetCoeff(lmq, n_Init(1, currRing->cf));
     12280    pSetCoeff(lmp, n_Init(1, currRing->cf));
     12281    Print("    %s\n", pString(lmq));
     12282    Print("    %s\n", pString(lmp));
     12283    pLmDelete(lmq);
     12284    pLmDelete(lmp);
     12285  }
     12286#endif
    1236312287
    1236412288  /* Format: q and p are like strat->P.p, so lm in CR, tail in TR */
    … …  
    1237012294  assume(p_CheckIsFromRing(pNext(p),strat->tailRing));
    1237112295
    12372 #ifdef KDEBUG
    12373 //    if (TEST_OPT_DEBUG)
    12374 //    {
    12375 //       PrintS("enterOnePairShift(q,p) invoked with q = ");
    12376 //       wrp(q); //      wrp(pHead(q));
    12377 //       PrintS(", p = ");
    12378 //       wrp(p); //wrp(pHead(p));
    12379 //       PrintLn();
    12380 //    }
    12381 #endif
    12382 
    1238312296  /* poly q stays for s[i], ecartq = ecart(q), qisFromQ = applies to q */
    1238412297
    … …  
    1239712310  Lp.lcm = p_Lcm(p,q, currRing); // q is what was strat->S[i], so a poly in LM/TR presentation
    1239812311
    12399   /* apply the V criterion */
    12400   if (!pIsInV(Lp.lcm))
    12401   {
    12402 #ifdef KDEBUG
    12403     if (TEST_OPT_DEBUG)
    12404     {
    12405       PrintS("V crit applied to q = ");
    12406       wrp(q); //      wrp(pHead(q));
    12407       PrintS(", p = ");
    12408       wrp(p); //wrp(pHead(p));
    12409       PrintLn();
    12410     }
    12411 #endif
     12312  /* the V criterion */
     12313  if (!pmIsInV(Lp.lcm))
     12314  {
     12315    strat->cv++; // counter for applying the V criterion
    1241212316    pLmFree(Lp.lcm);
    12413     /* + counter for applying the V criterion */
    12414     strat->cv++;
     12317#ifdef CRITERION_DEBUG
     12318    if (TEST_OPT_DEBUG) PrintS("--- V crit\n");
     12319#endif
    1241512320    return;
    1241612321  }
    … …  
    1243712342      strat->cp++;
    1243812343      pLmFree(Lp.lcm);
     12344#ifdef CRITERION_DEBUG
     12345      if (TEST_OPT_DEBUG) PrintS("--- prod crit\n");
     12346#endif
    1243912347      return;
    1244012348    }
    … …  
    1244412352    {
    1244512353      pLmFree(Lp.lcm);
     12354#ifdef CRITERION_DEBUG
     12355      if (TEST_OPT_DEBUG) PrintS("--- ecartq > ecart\n");
     12356#endif
    1244612357      return;
    1244712358      /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
    … …  
    1246612377          {
    1246712378            pLmFree(Lp.lcm);
     12379#ifdef CRITERION_DEBUG
     12380            if (TEST_OPT_DEBUG) Print("--- divided by B[%d]\n", j);
     12381#endif
    1246812382            return;
    1246912383          }
    … …  
    1247512389        {
    1247612390          deleteInL(strat->B,&strat->Bl,j,strat);
     12391#ifdef CRITERION_DEBUG
     12392          if (TEST_OPT_DEBUG) Print("divides B[%d] -> delete B[%d]\n", j, j);
     12393#endif
    1247712394          strat->c3++;
    1247812395        }
    … …  
    1250412421          strat->cp++;
    1250512422          pLmFree(Lp.lcm);
     12423#ifdef CRITERION_DEBUG
     12424          if (TEST_OPT_DEBUG) PrintS("--- prod crit\n");
     12425#endif
    1250612426          return;
    1250712427      }
    … …  
    1250912429      {
    1251012430        pLmFree(Lp.lcm);
     12431#ifdef CRITERION_DEBUG
     12432        if (TEST_OPT_DEBUG) PrintS("--- ecartq > ecart\n");
     12433#endif
    1251112434        return;
    1251212435        /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
    … …  
    1252712450          {
    1252812451            pLmFree(Lp.lcm);
     12452#ifdef CRITERION_DEBUG
     12453            if (TEST_OPT_DEBUG) Print("--- divided by B[%d]\n", j);
     12454#endif
    1252912455            return;
    1253012456          }
    … …  
    1253512461        {
    1253612462          deleteInL(strat->B,&strat->Bl,j,strat);
     12463#ifdef CRITERION_DEBUG
     12464          if (TEST_OPT_DEBUG) Print("divides B[%d] -> delete B[%d]\n", j, j);
     12465#endif
    1253712466          strat->c3++;
    1253812467        }
    … …  
    1254712476    pNorm(p);
    1254812477  if ((q==NULL) || (p==NULL))
     12478  {
     12479#ifdef CRITERION_DEBUG
     12480    if (TEST_OPT_DEBUG) PrintS("--- q == NULL || p == NULL\n");
     12481#endif
    1254912482    return;
     12483  }
    1255012484  if ((strat->fromQ!=NULL) && (isFromQ!=0) && (qfromQ!=0))
     12485  {
    1255112486    Lp.p=NULL;
     12487#ifdef CRITERION_DEBUG
     12488    if (TEST_OPT_DEBUG) PrintS("--- pair from Q\n");
     12489#endif
     12490  }
    1255212491  else
    1255312492  {
    … …  
    1260712546    */
    1260812547    if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
     12548#ifdef CRITERION_DEBUG
     12549    if (TEST_OPT_DEBUG) PrintS("--- S-poly = 0\n");
     12550#endif
    1260912551  }
    1261012552  else
    … …  
    1264312585    l = strat->posInL(strat->B,strat->Bl,&Lp,strat);
    1264412586    enterL(&strat->B,&strat->Bl,&strat->Bmax,Lp,l);
     12587#ifdef CRITERION_DEBUG
     12588    if (TEST_OPT_DEBUG) PrintS("+++ Entered pair\n");
     12589#endif
    1264512590  }
    1264612591}
    … …  
    1265512600void initenterpairsShift (poly h,int k,int ecart,int isFromQ, kStrategy strat, int atR)
    1265612601{
     12602  int h_lastVblock = pmLastVblock(h);
     12603  assume(h_lastVblock != 0 || pLmIsConstantComp(h));
     12604  // TODO: is it allowed to skip pairs with constants? also with constants from other components?
     12605  if (h_lastVblock == 0) return;
     12606  assume(pmFirstVblock(h) == 1);
    1265712607  /* h comes from strat->P.p, that is LObject with LM in currRing and Tail in tailRing */
    1265812608  //  atR = -1;
    … …  
    1266012610  || (pGetComp(h)<=strat->syzComp))
    1266112611  {
    12662     int j;
     12612    int i,j;
    1266312613    BOOLEAN new_pair=FALSE;
    1266412614
     12615    int degbound = currRing->N/currRing->isLPring;
     12616    int maxShift = degbound - h_lastVblock;
     12617
    1266512618    if (pGetComp(h)==0)
    1266612619    {
     12620      if (strat->rightGB)
     12621      {
     12622        if (isFromQ)
     12623        {
     12624          // pairs (shifts(h),s[1..k]), (h, s[1..k])
     12625          for (i=0; i<=maxShift; i++)
     12626          {
     12627            poly hh = pLPCopyAndShiftLM(h, i);
     12628            for (j=0; j<=k; j++)
     12629            {
     12630              if (strat->fromQ == NULL || !strat->fromQ[j])
     12631              {
     12632                new_pair=TRUE;
     12633                poly s = strat->S[j];
     12634                enterOnePairWithoutShifts(j, hh, s, ecart, isFromQ, strat, atR, pmLastVblock(s), i);
     12635              }
     12636            }
     12637          }
     12638        }
     12639        else
     12640        {
     12641          new_pair=TRUE;
     12642          for (j=0; j<=k; j++)
     12643          {
     12644            poly s = strat->S[j];
     12645            if (strat->fromQ != NULL && strat->fromQ[j])
     12646            {
     12647              // pairs (shifts(s[j]),h), (s[j],h)
     12648              enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
     12649            }
     12650            else
     12651            {
     12652              // pair (h, s[j])
     12653              enterOnePairWithoutShifts(j, h, s, ecart, isFromQ, strat, atR, pmLastVblock(s), 0);
     12654            }
     12655          }
     12656        }
     12657      }
    1266712658      /* for Q!=NULL: build pairs (f,q),(f1,f2), but not (q1,q2)*/
    12668       if ((isFromQ)&&(strat->fromQ!=NULL))
    12669       {
    12670         for (j=0; j<=k; j++)
    12671         {
     12659      else if ((isFromQ)&&(strat->fromQ!=NULL))
     12660      {
     12661        // pairs (shifts(s[1..k]),h), (s[1..k],h)
     12662        for (j=0; j<=k; j++) {
    1267212663          if (!strat->fromQ[j])
    1267312664          {
    1267412665            new_pair=TRUE;
    12675             enterOnePairManyShifts(j,h,ecart,isFromQ,strat, atR);
    12676             // other side pairs:
    12677             enterOnePairSelfShifts(h,strat->S[j],ecart,isFromQ,strat, atR);
    12678           //Print("j:%d, Ll:%d\n",j,strat->Ll);
     12666            poly s = strat->S[j];
     12667            enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
    1267912668          }
    1268012669        }
     12670        // pairs (shifts(h),s[1..k])
     12671        if (new_pair)
     12672        {
     12673          for (i=1; i<=maxShift; i++)
     12674          {
     12675            poly hh = pLPCopyAndShiftLM(h, i);
     12676            for (j=0; j<=k; j++)
     12677            {
     12678              if (!strat->fromQ[j])
     12679              {
     12680                poly s = strat->S[j];
     12681                enterOnePairWithoutShifts(j, hh, s, ecart, isFromQ, strat, atR, pmLastVblock(s), i);
     12682              }
     12683            }
     12684          }
     12685        }
    1268112686      }
    1268212687      else
    1268312688      {
    1268412689        new_pair=TRUE;
     12690        // pairs (shifts(s[1..k]),h), (s[1..k],h)
     12691        for (j=0; j<=k; j++) {
     12692          poly s = strat->S[j];
     12693          // TODO: cache lastVblock of s[1..k] for later use
     12694          enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
     12695        }
     12696        // pairs (shifts(h),s[1..k]), (shifts(h), h)
     12697        for (i=1; i<=maxShift; i++)
     12698        {
     12699          poly hh = pLPCopyAndShiftLM(h, i);
     12700          for (j=0; j<=k; j++)
     12701          {
     12702            poly s = strat->S[j];
     12703            enterOnePairWithoutShifts(j, hh, s, ecart, isFromQ, strat, atR, pmLastVblock(s), i);
     12704          }
     12705          enterOnePairWithoutShifts(-1, hh, h, ecart, isFromQ, strat, atR, h_lastVblock, i);
     12706        }
     12707      }
     12708    }
     12709    else
     12710    {
     12711      new_pair=TRUE;
     12712      if (strat->rightGB)
     12713      {
    1268512714        for (j=0; j<=k; j++)
    1268612715        {
    12687           enterOnePairManyShifts(j,h,ecart,isFromQ,strat, atR);
    12688           // other side pairs
    12689           enterOnePairSelfShifts(h,strat->S[j],ecart,isFromQ,strat, atR);
    12690         }
    12691         /* HERE we put (h, s*h) pairs */
    12692        /* enterOnePairSelfShifts (poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV); */
    12693        enterOnePairSelfShifts (h, h, ecart, isFromQ, strat, atR);
    12694       }
    12695     }
    12696     else
    12697     {
    12698       for (j=0; j<=k; j++)
    12699       {
    12700         if ((pGetComp(h)==pGetComp(strat->S[j]))
    12701         || (pGetComp(strat->S[j])==0))
    12702         {
    12703           new_pair=TRUE;
    12704           enterOnePairManyShifts(j,h,ecart,isFromQ,strat, atR);
    12705           // other side pairs
    12706           enterOnePairSelfShifts(h,strat->S[j],ecart,isFromQ,strat, atR);
    12707         //Print("j:%d, Ll:%d\n",j,strat->Ll);
    12708         }
    12709       }
    12710       /* HERE we put (h, s*h) pairs */
    12711       enterOnePairSelfShifts (h, h, ecart, isFromQ, strat, atR);
     12716          if ((pGetComp(h)==pGetComp(strat->S[j]))
     12717              || (pGetComp(strat->S[j])==0))
     12718          {
     12719            assume(isFromQ == 0); // this case is not handeled here and should also never happen
     12720            poly s = strat->S[j];
     12721            if (strat->fromQ != NULL && strat->fromQ[j])
     12722            {
     12723              // pairs (shifts(s[j]),h), (s[j],h)
     12724              enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
     12725            }
     12726            else
     12727            {
     12728              // pair (h, s[j])
     12729              enterOnePairWithoutShifts(j, h, s, ecart, isFromQ, strat, atR, pmLastVblock(s), 0);
     12730            }
     12731          }
     12732        }
     12733      }
     12734      else
     12735      {
     12736        // pairs (shifts(s[1..k]),h), (s[1..k],h)
     12737        for (j=0; j<=k; j++) {
     12738          if ((pGetComp(h)==pGetComp(strat->S[j]))
     12739              || (pGetComp(strat->S[j])==0))
     12740          {
     12741            poly s = strat->S[j];
     12742            enterOnePairWithShifts(j, s, h, ecart, isFromQ, strat, atR, h_lastVblock, pmLastVblock(s));
     12743          }
     12744        }
     12745        // pairs (shifts(h),s[1..k]), (shifts(h), h)
     12746        for (i=1; i<=maxShift; i++)
     12747        {
     12748          poly hh = pLPCopyAndShiftLM(h, i);
     12749          for (j=0; j<=k; j++)
     12750          {
     12751            if ((pGetComp(h)==pGetComp(strat->S[j]))
     12752                || (pGetComp(strat->S[j])==0))
     12753            {
     12754              poly s = strat->S[j];
     12755              enterOnePairWithoutShifts(j, hh, s, ecart, isFromQ, strat, atR, pmLastVblock(s), i);
     12756            }
     12757          }
     12758          enterOnePairWithoutShifts(-1, hh, h, ecart, isFromQ, strat, atR, h_lastVblock, i);
     12759        }
     12760      }
    1271212761    }
    1271312762
    … …  
    1273812787    ||(pGetComp(h)<=strat->syzComp)))
    1273912788  {
    12740     //Print("start clearS k=%d, pos=%d, sl=%d\n",k,pos,strat->sl);
    1274112789    unsigned long h_sev = pGetShortExpVector(h);
    1274212790    loop
    1274312791    {
    1274412792      if (j > k) break;
    12745       clearS(h,h_sev, &j,&k,strat);
     12793      // TODO this currently doesn't clear all possible elements because of commutative division
     12794      if (!(strat->rightGB && strat->fromQ != NULL && strat->fromQ[j]))
     12795        clearS(h,h_sev, &j,&k,strat);
    1274612796      j++;
    1274712797    }
    12748     //Print("end clearS sl=%d\n",strat->sl);
    12749   }
    12750  // PrintS("end enterpairs\n");
     12798  }
    1275112799}
    1275212800#endif
    … …  
    1276512813  pAssume(p.p != NULL);
    1276612814
    12767   int toInsert = itoInsert(p.p, strat->tailRing);
    12768 
    12769   for (int i = 1; i <= toInsert; i++)
     12815  int maxPossibleShift = p_mLPmaxPossibleShift(p.p, strat->tailRing);
     12816
     12817  for (int i = 1; i <= maxPossibleShift; i++)
    1277012818  {
    1277112819    LObject qq;

  • kernel/GBEngine/kutil.h

    ree3e7cd r178bd3  
    368368  #ifdef HAVE_SHIFTBBA
    369369  int cv; // in shift bases: counting V criterion
     370  /*BOOLEAN*/ char rightGB;
    370371  #endif
    371372  /*BOOLEAN*/ char interpt;
    … …  
    852853void enterTShift(LObject p, kStrategy strat, int atT = -1);
    853854
    854 void initBuchMoraShift (ideal F,ideal Q,kStrategy strat);
    855 
    856 void enterOnePairSelfShifts (poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int atR);
    857 
    858855void enterOnePairShift (poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS);
    859856
    860857void enterpairsShift (poly h,int k,int ecart,int pos,kStrategy strat, int atR);
    861858
    862 void updateSShift(kStrategy strat);
    863 
    864859void initBbaShift(kStrategy strat);
    865860
    … …  
    868863int redFirstShift (LObject* h,kStrategy strat); // ok
    869864
    870 ideal freegb(ideal I);
     865ideal freegb(ideal F);
     866ideal rightgb(ideal F, ideal Q);
    871867
    872868ideal bbaShift(ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat);

  • kernel/GBEngine/shiftgb.cc

    ree3e7cd r178bd3  
    4343}
    4444
    45 /* for poly in lmCR/tailTR presentation */
    46 int itoInsert(poly p, const ring r)
     45int p_mLPmaxPossibleShift(poly p, const ring r)
    4746{
    48   /* the below situation (commented out) might happen! */
    49 //   if (r == currRing)
    50 //   {
    51 //     "Current ring is not expected in toInsert";
    52 //     return(0);
    53 //   }
    54   /* compute the number of insertions */
    55   int i = p_mLastVblock(p, currRing);
    56   if (pNext(p) != NULL)
    57   {
    58     i = si_max(i, p_LastVblock(pNext(p), r) );
    59   }
    60   //  i = uptodeg  - i +1;
     47  int lastBlock = p_mLastVblock(p, r);
     48  if (lastBlock == 0) return 0;
    6149  int uptodeg = r->N/r->isLPring;
    62   //  p_wrp(p,currRing,r); Print("----i:%d",i); PrintLn();
    63   return uptodeg - i;
     50  return uptodeg - lastBlock;
    6451}
    6552

  • kernel/GBEngine/shiftgb.h

    ree3e7cd r178bd3  
    1515#define pLPCopyAndShiftLM(p, sh) p_LPCopyAndShiftLM(p, sh, currRing)
    1616
    17 int itoInsert(poly p, const ring r);
     17int p_mLPmaxPossibleShift(poly p, const ring r);
     18#define pmLPmaxPossibleShift(p) p_mLPmaxPossibleShift(p, currRing)
    1819
    1920#endif

  • libpolys/polys/matpol.cc

    r04d263 r178bd3  
    2323#include "matpol.h"
    2424#include "prCopy.h"
     25#include "clapsing.h"
    2526
    2627#include "sparsmat.h"
    … …  
    20292030
    20302031//  mu-Matrix
    2031 static void mu(matrix A, matrix &X, const ring R)
     2032static matrix mu(matrix A, const ring R)
    20322033{
    20332034  int n=MATROWS(A);
    … …  
    20442045
    20452046    // X als n*n Null-Matrix initalisieren
    2046     X=mpNew(n,n);
     2047    matrix X=mpNew(n,n);
    20472048
    20482049    //  Diagonaleintraege von X berrechnen
    … …  
    20532054        sum=p_Sub(sum,p_Copy(MATELEM0(A,i,i),R),R);
    20542055    }
     2056    p_Delete(&sum,R);
    20552057
    20562058    //  Eintraege aus dem oberen Dreieck von A nach X uebertragen
    2057     for (int i = 0; i < n; i++)
     2059    for (int i = n-1; i >=0; i--)
    20582060    {
    20592061        for (int j = i+1; j < n; j++)
    … …  
    20622064        }
    20632065    }
     2066    return X;
    20642067}
    20652068
    … …  
    20802083
    20812084    //speichere A ab:
    2082     matrix B=mp_Copy(A,R);
    2083     A=mp_Copy(A,R);
     2085    matrix workA=mp_Copy(A,R);
    20842086
    20852087    // berechen X = mu(X)*A
    20862088    matrix X;
    2087     for (int i = 0; i < n-1; i++)
    2088     {
    2089         mu(A,X,R);
    2090         id_Delete((ideal*)&A,R);
    2091         A=mp_Mult(X,B,R);
     2089    for (int i = n-1; i >0; i--)
     2090    {
     2091        X=mu(workA,R);
     2092        id_Delete((ideal*)&workA,R);
     2093        workA=mp_Mult(X,A,R);
    20922094        id_Delete((ideal*)&X,R);
    20932095    }
    … …  
    20972099    if (n%2 == 0)
    20982100    {
    2099         res=p_Neg(MATELEM0(A,0,0),R);
     2101        res=p_Neg(MATELEM0(workA,0,0),R);
    21002102    }
    21012103    else
    21022104    {
    2103         res=MATELEM0(A,0,0);
    2104     }
    2105     MATELEM0(A,0,0)=NULL;
    2106     id_Delete((ideal*)&A,R);
     2105        res=MATELEM0(workA,0,0);
     2106    }
     2107    MATELEM0(workA,0,0)=NULL;
     2108    id_Delete((ideal*)&workA,R);
    21072109    return res;
    21082110}
    21092111
     2112DetVariant mp_GetAlgorithmDet(matrix m, const ring r)
     2113{
     2114  if (MATROWS(m)+2*r->N>20+5*rField_is_Zp(r)) return DetMu;
     2115  if (MATROWS(m)<10+5*rField_is_Zp(r)) return DetSBareiss;
     2116  BOOLEAN isConst=TRUE;
     2117  int s=0;
     2118  for(int i=MATCOLS(m)*MATROWS(m)-1;i>=0;i--)
     2119  {
     2120    poly p=m->m[i];
     2121    if (p!=NULL)
     2122    {
     2123      if(!p_IsConstant(p,r)) isConst=FALSE;
     2124      s++;
     2125    }
     2126  }
     2127  if (isConst && rField_is_Q(r)) return DetFactory;
     2128  if (s*2<MATCOLS(m)*MATROWS(m)) // few entries
     2129    return DetSBareiss;
     2130  return DetMu;
     2131}
     2132DetVariant mp_GetAlgorithmDet(const char *s)
     2133{
     2134  if (strcmp(s,"Bareiss")==0) return DetBareiss;
     2135  if (strcmp(s,"SBareiss")==0) return DetSBareiss;
     2136  if (strcmp(s,"Mu")==0) return DetMu;
     2137  if (strcmp(s,"Factory")==0) return DetFactory;
     2138  WarnS("unknown method for det");
     2139  return DetDefault;
     2140}
     2141
     2142
     2143poly mp_Det(matrix a, const ring r, DetVariant d/*=DetDefault*/)
     2144{
     2145  if ((MATCOLS(a)==0)
     2146  && (MATROWS(a)==0))
     2147    return p_One(r);
     2148  if (d==DetDefault) d=mp_GetAlgorithmDet(a,r);
     2149  switch (d)
     2150  {
     2151    case DetBareiss: return mp_DetBareiss(a,r);
     2152    case DetMu: return mp_DetMu(a,r);
     2153    case DetFactory: return singclap_det(a,r);
     2154    case DetSBareiss:
     2155    {
     2156      ideal I=id_Matrix2Module(mp_Copy(a, r),r);
     2157      poly p=sm_CallDet(I, r);
     2158      id_Delete(&I, r);
     2159      return p;
     2160    }
     2161    default:
     2162      WerrorS("unknown algorith for det");
     2163  }
     2164}
     2165
     2166poly sm_Det(ideal a, const ring r, DetVariant d/*=DetDefault*/)
     2167{
     2168  if ((MATCOLS(a)==0)
     2169  && (MATROWS(a)==0))
     2170    return p_One(r);
     2171  if (d==DetDefault) d=mp_GetAlgorithmDet((matrix)a,r);
     2172  if (d==DetSBareiss) return sm_CallDet(a,r);
     2173  matrix m=id_Module2Matrix(id_Copy(a,r),r);
     2174  poly p=mp_Det(m,r,d);
     2175  id_Delete((ideal *)&m,r);
     2176  return p;
     2177}

  • libpolys/polys/matpol.h

    r04d263 r178bd3  
    3232};
    3333
     34enum DetVariant
     35{
     36  DetDefault=0,
     37  DetBareiss,
     38  DetSBareiss,
     39  DetMu,
     40  DetFactory
     41};
     42
    3443typedef ip_smatrix *       matrix;
    3544
    … …  
    5968// BOOLEAN mpKoszul(leftv res,leftv b/*in*/, leftv c/*ip*/, leftv id=NULL);
    6069
     70poly mp_Det(matrix a, const ring r, DetVariant d=DetDefault);
    6171poly mp_DetBareiss (matrix a, const ring r);
    6272poly mp_DetMu(matrix A, const ring R);
    … …  
    106116BOOLEAN sm_Equal(ideal a, ideal b, const ring R);
    107117ideal sm_Tensor(ideal A, ideal B, const ring r);
     118poly sm_Det(ideal I, const ring, DetVariant d=DetDefault);
     119DetVariant mp_GetAlgorithmDet(matrix m, const ring r);
     120DetVariant mp_GetAlgorithmDet(const char *s);
    108121
    109122#define SMATELEM(A,i,j,R) p_Vec2Poly(A->m[j],i+1,R)

  • libpolys/polys/shiftop.cc

    ree3e7cd r178bd3  
    368368  p_GetExpV(m,e,ri);
    369369
     370  if (p_mLastVblock(m, e, ri) + sh > ri->N/lV)
     371  {
     372    Werror("letterplace degree bound is %d, but at least %d is needed for this shift", ri->N/lV, p_mLastVblock(m, e, ri) + sh);
     373  }
    370374  for (int i = ri->N - sh*lV; i > 0; i--)
    371375  {
    … …  
    506510  PrintLn(); WriteLPExpV(m2ExpV, ri);
    507511#endif
    508   if (m1Length + m2Length > ri->N)
    509   {
    510     WarnS("letterplace degree bound too low for this multiplication");
    511   }
    512   for (int i = 1 + m1Length; i < 1 + m1Length + m2Length; ++i)
     512  int last = m1Length + m2Length;
     513  if (last > ri->N)
     514  {
     515    Werror("letterplace degree bound is %d, but at least %d is needed for this multiplication", ri->N/ri->isLPring, last/ri->isLPring);
     516    last = ri->N;
     517  }
     518  for (int i = 1 + m1Length; i < 1 + last; ++i)
    513519  {
    514520    assume(m2ExpV[i - m1Length] <= 1);
    … …  
    531537  PrintLn(); WriteLPExpV(m2ExpV, ri);
    532538#endif
    533   if (m1Length + m2Length > ri->N)
    534   {
    535     WarnS("letterplace degree bound too low for this multiplication");
     539  int last = m1Length + m2Length;
     540  if (last > ri->N)
     541  {
     542    Werror("letterplace degree bound is %d, but at least %d is needed for this multiplication", ri->N/ri->isLPring, last/ri->isLPring);
     543    last = ri->N;
    536544  }
    537545
    538546  // shift m1 by m2Length
    539   for (int i = m2Length + m1Length; i >= 1 + m2Length; --i)
     547  for (int i = last; i >= 1 + m2Length; --i)
    540548  {
    541549    m1ExpV[i] = m1ExpV[i - m2Length];

  • libpolys/polys/sparsmat.cc

    r04d263 r178bd3  
    295295}
    296296
    297 /*2
    298 * Bareiss or Chinese remainder ?
    299 * I is dXd
    300 * sw = TRUE  -> I Matrix
    301 *      FALSE -> I Module
    302 * return True  -> change Type
    303 *        FALSE -> same Type
    304 */
    305 BOOLEAN sm_CheckDet(ideal I, int d, BOOLEAN sw, const ring r)
    306 {
    307   int s,t,i;
    308   poly p;
    309 
    310   if (d>100)
    311     return TRUE;
    312   if (!rField_is_Q(r))
    313     return TRUE;
    314   s = t = 0;
    315   // now: field is Q, n<=100
    316   for(i=IDELEMS(I)-1;i>=0;i--)
    317   {
    318     p=I->m[i];
    319     if (p!=NULL)
    320     {
    321       if(!p_IsConstant(p,r))
    322         return TRUE;
    323       s++;
    324       t+=n_Size(pGetCoeff(p),r->cf);
    325     }
    326   }
    327   s*=15;
    328   if (t>s)
    329     return FALSE;// few large constanst entries
    330   else
    331     return TRUE; //many small entries
    332 }
    333 
    334297/* ----------------- basics (used from 'C') ------------------ */
    335298/*2

  • libpolys/polys/sparsmat.h

    r04d263 r178bd3  
    3232void sm_KillModifiedRing(ring r);
    3333long sm_ExpBound(ideal, int, int, int, const ring);
    34 BOOLEAN sm_CheckDet(ideal, int, BOOLEAN, const ring);
    3534#endif
Note: See TracChangeset for help on using the changeset viewer.