Changeset f7d745 in git


Ignore:
Timestamp:
May 26, 2011, 1:55:32 PM (13 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '021f6f0284cb2a2a1108cf70e32750fb1edddf5c')
Children:
38ac8cadfce1628aa28008b1a3d9bbd297dd2983
Parents:
1fe2271e3800804bd9a9bef62db37a53fa11b38e
Message:
format

git-svn-id: file:///usr/local/Singular/svn/trunk@14246 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular/LIB
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/assprimeszerodim.lib

    r1fe227 rf7d745  
    458458      {
    459459         if(printlevel >= 9) { "size(L) = "+string(size(L)); }
    460          
     460
    461461         F = cleardenom(F[1]);
    462462
  • Singular/LIB/fpadim.lib

    r1fe227 rf7d745  
    1111
    1212OVERVIEW: Given the free algebra A = K<x_1,...,x_n> and a (finite) Groebner basis
    13 @*      GB = {g_1,..,g_w}, one is interested in the K-dimension and in the
    14 @*      explicit K-basis of A/<GB>.
    15 @*      Therefore one is interested in the following data:
     13      GB = {g_1,..,g_w}, one is interested in the K-dimension and in the
     14      explicit K-basis of A/<GB>.
     15      Therefore one is interested in the following data:
    1616@*      - the Ufnarovskij graph induced by GB
    1717@*      - the mistletoes of A/<GB>
    1818@*      - the K-dimension of A/<GB>
    1919@*      - the Hilbert series of A/<GB>
    20 @*
    21 @*      The Ufnarovskij graph is used to determine whether A/<GB> has finite
    22 @*      K-dimension. One has to check if the graph contains cycles.
    23 @*      For the whole theory we refer to [ufna]. Given a
    24 @*      reduced set of monomials GB one can define the basis tree, whose vertex
    25 @*      set V consists of all normal monomials w.r.t. GB. For every two
    26 @*      monomials m_1, m_2 in V there is a direct edge from m_1 to m_2, if and
    27 @*      only if there exists x_k in {x_1,..,x_n}, such that m_1*x_k = m_2. The
    28 @*      set M = {m in V | there is no edge from m to another monomial in V} is
    29 @*      called the set of mistletoes. As one can easily see it consists of
    30 @*      the endpoints of the graph. Since there is a unique path to every
    31 @*      monomial in V the whole graph can be described only from the knowledge
    32 @*      of the mistletoes. Note that V corresponds to a basis of A/<GB>, so
    33 @*      knowing the mistletoes we know a K-basis. The name mistletoes was given
    34 @*      to those points because of these miraculous value and the algorithm is
    35 @*      named sickle, because a sickle is the tool to harvest mistletoes.
    36 @*      For more details see [studzins]. This package uses the Letterplace
    37 @*      format introduced by [lls]. The algebra can either be represented as a
    38 @*      Letterplace ring or via integer vectors: Every variable will only be
    39 @*      represented by its number, so variable one is represented as 1,
    40 @*      variable two as 2 and so on. The monomial x_1*x_3*x_2 for example will
    41 @*      be stored as (1,3,2). Multiplication is concatenation. Note that there
    42 @*      is no algorithm for computing the normal form needed for our case.
    43 @*      Note that the name fpadim.lib is short for dimensions of finite
    44 @*      presented algebras.
     20
     21      The Ufnarovskij graph is used to determine whether A/<GB> has finite
     22      K-dimension. One has to check if the graph contains cycles.
     23      For the whole theory we refer to [ufna]. Given a
     24      reduced set of monomials GB one can define the basis tree, whose vertex
     25      set V consists of all normal monomials w.r.t. GB. For every two
     26      monomials m_1, m_2 in V there is a direct edge from m_1 to m_2, if and
     27      only if there exists x_k in {x_1,..,x_n}, such that m_1*x_k = m_2. The
     28      set M = {m in V | there is no edge from m to another monomial in V} is
     29      called the set of mistletoes. As one can easily see it consists of
     30      the endpoints of the graph. Since there is a unique path to every
     31      monomial in V the whole graph can be described only from the knowledge
     32      of the mistletoes. Note that V corresponds to a basis of A/<GB>, so
     33      knowing the mistletoes we know a K-basis. The name mistletoes was given
     34      to those points because of these miraculous value and the algorithm is
     35      named sickle, because a sickle is the tool to harvest mistletoes.
     36      For more details see [studzins]. This package uses the Letterplace
     37      format introduced by [lls]. The algebra can either be represented as a
     38      Letterplace ring or via integer vectors: Every variable will only be
     39      represented by its number, so variable one is represented as 1,
     40      variable two as 2 and so on. The monomial x_1*x_3*x_2 for example will
     41      be stored as (1,3,2). Multiplication is concatenation. Note that there
     42      is no algorithm for computing the normal form needed for our case.
     43      Note that the name fpadim.lib is short for dimensions of finite
     44      presented algebras.
    4545
    4646References:
     
    145145    {for (i3 = 1; i3 <= n; i3++)
    146146      {for (i4 = 1; i4 <= (n^(i1-1)); i4++)
    147         {M[i2,i1] = i3;
    148           i2 = i2 + 1;
    149         }
     147      {
     148        M[i2,i1] = i3;
     149          i2 = i2 + 1;
     150       }
    150151      }
    151152    }
     
    194195      for (j = 1; j<= size(P); j++)
    195196      {if (P[j] <= size(Vt))
    196         {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
    197           if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
    198         }
     197        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
     198          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
     199        }
    199200      }
    200201      if (w == 0)
    201202      {vector Vtt;
    202         for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
    203         M = M,Vtt;
    204         kill Vtt;
     203        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
     204        M = M,Vtt;
     205        kill Vtt;
    205206      }
    206207    }
     
    210211      for (i = 1; i <= size(M); i++)
    211212      {kill Vt; intvec Vt;
    212         for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
    213         dimen = dimen + 1 + findDimen(Vt,n,L,P);
     213        for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
     214        dimen = dimen + 1 + findDimen(Vt,n,L,P);
    214215      }
    215216      return(dimen);
     
    223224      for (j = 1; j<= size(P); j++)
    224225      {if (P[j] <= size(Vt))
    225         {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
    226           if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
    227         }
     226        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
     227          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
     228        }
    228229      }
    229230      if (w == 0) {vector Vtt;
    230         for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
    231         M = M,Vtt;
    232         kill Vtt;
     231        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
     232        M = M,Vtt;
     233        kill Vtt;
    233234      }
    234235    }
     
    238239      for (i = 1; i <= size(M); i++)
    239240      {kill Vt; intvec Vt;
    240         for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
    241         dimen = dimen + 1 + findDimen(Vt,n,L,P,degbound);
     241        for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
     242        dimen = dimen + 1 + findDimen(Vt,n,L,P,degbound);
    242243      }
    243244      return(dimen);
     
    258259      for (j = 1; j <= size(P); j++)
    259260      {if (P[j] <= size(Vt))
    260         {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
    261           if (isInMat(Vt2,L[j]) > 0)
    262           {w = 1; break;}
    263         }
     261        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
     262          if (isInMat(Vt2,L[j]) > 0)
     263          {w = 1; break;}
     264        }
    264265      }
    265266      if (w == 0) {r = findCycle(Vt,L,P,n,ld,M);}
     
    275276      for (it = 1; it <= j; it++)
    276277      { for(it2 = 1; it2 <= nrows(M);it2++)
    277         {Mt[it,it2] = int(leadcoef(M[it2,it]));}
     278        {Mt[it,it2] = int(leadcoef(M[it2,it]));}
    278279      }
    279280      Vt = V[(size(V)-ld+1)..size(V)];
     
    282283      else
    283284      {vector Vtt;
    284         for (it =1; it <= size(Vt); it++)
    285         {Vtt = Vtt + Vt[it]*gen(it);}
    286         M = M,Vtt;
    287         kill Vtt;
    288         for (i = 1; i <= n; i++)
    289         {Vt = V,i; w = 0;
    290           for (j = 1; j <= size(P); j++)
    291           {if (P[j] <= size(Vt))
    292             {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
    293               //L[j]; type(L[j]);Vt2;type(Vt2);
    294               if (isInMat(Vt2,L[j]) > 0)
    295               {w = 1; break;}
    296             }
    297           }
    298           if (w == 0) {r = findCycle(Vt,L,P,n,ld,M);}
    299           if (r == 1) {break;}
    300         }
    301         return(r);
     285        for (it =1; it <= size(Vt); it++)
     286        {Vtt = Vtt + Vt[it]*gen(it);}
     287        M = M,Vtt;
     288        kill Vtt;
     289        for (i = 1; i <= n; i++)
     290        {Vt = V,i; w = 0;
     291          for (j = 1; j <= size(P); j++)
     292          {if (P[j] <= size(Vt))
     293            {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
     294              //L[j]; type(L[j]);Vt2;type(Vt2);
     295              if (isInMat(Vt2,L[j]) > 0)
     296              {w = 1; break;}
     297            }
     298          }
     299          if (w == 0) {r = findCycle(Vt,L,P,n,ld,M);}
     300          if (r == 1) {break;}
     301        }
     302        return(r);
    302303      }
    303304    }
     
    311312      for (i = 1; i <= n; i++)
    312313      {Vt = V,i; w = 0;
    313         for (j = 1; j <= size(P); j++)
    314         {if (P[j] <= size(Vt))
    315           {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
    316             //L[j]; type(L[j]);Vt2;type(Vt2);
    317             if (isInMat(Vt2,L[j]) > 0)
    318             {w = 1; break;}
    319           }
    320         }
    321         if (w == 0) {r = findCycle(Vt,L,P,n,ld,M);}
    322         if (r == 1) {break;}
     314        for (j = 1; j <= size(P); j++)
     315        {if (P[j] <= size(Vt))
     316          {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
     317            //L[j]; type(L[j]);Vt2;type(Vt2);
     318            if (isInMat(Vt2,L[j]) > 0)
     319            {w = 1; break;}
     320          }
     321        }
     322        if (w == 0) {r = findCycle(Vt,L,P,n,ld,M);}
     323        if (r == 1) {break;}
    323324      }
    324325      return(r);
     
    345346      for (j = 1; j<= size(P); j++)
    346347      {if (P[j] <= size(Vt))
    347         {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
    348           if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
    349         }
     348        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
     349          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
     350        }
    350351      }
    351352      if (w == 0)
    352353      {vector Vtt;
    353         for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
    354         M = M,Vtt;
    355         kill Vtt;
     354        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
     355        M = M,Vtt;
     356        kill Vtt;
    356357      }
    357358    }
     
    361362      for (i = 1; i <= size(M); i++)
    362363      {kill Vt; intvec Vt;
    363         for (j =1; j <= size(M[i]); j++) {Vt[j] =  int(leadcoef(M[i][j]));}
    364         h1 = h1 + 1; H1 = findHCoeff(Vt,n,L,P,H1);
     364        for (j =1; j <= size(M[i]); j++) {Vt[j] =  int(leadcoef(M[i][j]));}
     365        h1 = h1 + 1; H1 = findHCoeff(Vt,n,L,P,H1);
    365366      }
    366367      if (size(H1) < (size(V)+2)) {H1[(size(V)+2)] = h1;}
     
    377378      for (j = 1; j<= size(P); j++)
    378379      {if (P[j] <= size(Vt))
    379         {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
    380           if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
    381         }
     380        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
     381          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
     382        }
    382383      }
    383384      if (w == 0)
    384385      {vector Vtt;
    385         for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
    386         M = M,Vtt;
    387         kill Vtt;
     386        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
     387        M = M,Vtt;
     388        kill Vtt;
    388389      }
    389390    }
     
    393394      for (i = 1; i <= size(M); i++)
    394395      {kill Vt; intvec Vt;
    395         for (j =1; j <= size(M[i]); j++)
    396         {Vt[j] =  int(leadcoef(M[i][j]));}
    397         h1 = h1 + 1; H1 = findHCoeff(Vt,n,L,P,H1,degbound);
     396        for (j =1; j <= size(M[i]); j++)
     397        {Vt[j] =  int(leadcoef(M[i][j]));}
     398        h1 = h1 + 1; H1 = findHCoeff(Vt,n,L,P,H1,degbound);
    398399      }
    399400      if (size(H1) < (size(V)+2)) { H1[(size(V)+2)] = h1;}
     
    422423      for (j = 1; j<= size(P); j++)
    423424      {if (P[j] <= size(Vt))
    424         {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
    425           if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
    426         }
     425        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
     426          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
     427        }
    427428      }
    428429      if (w == 0)
    429430      {vector Vtt;
    430         for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
    431         M = M,Vtt;
    432         kill Vtt;
     431        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
     432        M = M,Vtt;
     433        kill Vtt;
    433434      }
    434435    }
     
    438439      for (i = 1; i <= size(M); i++)
    439440      {kill Vt; intvec Vt;
    440         for (j =1; j <= size(M[i]); j++)
    441         {Vt[j] =  int(leadcoef(M[i][j]));}
    442         if (size(R[1]) < (size(V)+2)) { R[1][(size(V)+2)] = 1;}
    443         else
    444         {R[1][(size(V)+2)] = R[1][(size(V)+2)] + 1;}
    445         R = findHCoeffMis(Vt,n,L,P,R);
     441        for (j =1; j <= size(M[i]); j++)
     442        {Vt[j] =  int(leadcoef(M[i][j]));}
     443        if (size(R[1]) < (size(V)+2)) { R[1][(size(V)+2)] = 1;}
     444        else
     445        {R[1][(size(V)+2)] = R[1][(size(V)+2)] + 1;}
     446        R = findHCoeffMis(Vt,n,L,P,R);
    446447      }
    447448      return(R);
     
    459460      for (j = 1; j<= size(P); j++)
    460461      {if (P[j] <= size(Vt))
    461         {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
    462           if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
    463         }
     462        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
     463          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
     464        }
    464465      }
    465466      if (w == 0)
    466467      {vector Vtt;
    467         for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
    468         M = M,Vtt;
    469         kill Vtt;
     468        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
     469        M = M,Vtt;
     470        kill Vtt;
    470471      }
    471472    }
     
    475476      for (i = 1; i <= ncols(M); i++)
    476477      {kill Vt; intvec Vt;
    477         for (j =1; j <= size(M[i]); j++)
    478         {Vt[j] =  int(leadcoef(M[i][j]));}
    479         if (size(R[1]) < (size(V)+2)) { R[1][(size(V)+2)] = 1;}
    480         else
    481         {R[1][(size(V)+2)] = R[1][(size(V)+2)] + 1;}
    482         R = findHCoeffMis(Vt,n,L,P,R,degbound);
     478        for (j =1; j <= size(M[i]); j++)
     479        {Vt[j] =  int(leadcoef(M[i][j]));}
     480        if (size(R[1]) < (size(V)+2)) { R[1][(size(V)+2)] = 1;}
     481        else
     482        {R[1][(size(V)+2)] = R[1][(size(V)+2)] + 1;}
     483        R = findHCoeffMis(Vt,n,L,P,R,degbound);
    483484      }
    484485      return(R);
     
    503504      for (j = 1; j<= size(P); j++)
    504505      {if (P[j] <= size(Vt))
    505         {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
    506           if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
    507         }
     506        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
     507          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
     508        }
    508509      }
    509510      if (w == 0)
    510511      {vector Vtt;
    511         for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
    512         M = M,Vtt;
    513         kill Vtt;
     512        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
     513        M = M,Vtt;
     514        kill Vtt;
    514515      }
    515516    }
     
    523524      for (i = 1; i <= size(M); i++)
    524525      {kill Vt; intvec Vt;
    525         for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
    526         R[1] = R[1] + 1; R = findMisDim(Vt,n,L,P,R);
     526        for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
     527        R[1] = R[1] + 1; R = findMisDim(Vt,n,L,P,R);
    527528      }
    528529      return(R);
     
    540541      for (j = 1; j<= size(P); j++)
    541542      {if (P[j] <= size(Vt))
    542         {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
    543           if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
    544         }
     543        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
     544          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
     545        }
    545546      }
    546547      if (w == 0)
    547548      {vector Vtt;
    548         for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
    549         M = M,Vtt;
    550         kill Vtt;
     549        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
     550        M = M,Vtt;
     551        kill Vtt;
    551552      }
    552553    }
     
    560561      for (i = 1; i <= size(M); i++)
    561562      {kill Vt; intvec Vt;
    562         for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
    563         R[1] = R[1] + 1; R = findMisDim(Vt,n,L,P,R,degbound);
     563        for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
     564        R[1] = R[1] + 1; R = findMisDim(Vt,n,L,P,R,degbound);
    564565      }
    565566      return(R);
     
    589590      for (j = 1; j <= size(P); j++)
    590591      {if (P[j] <= size(Vt))
    591         {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
    592           if (isInMat(Vt2,L[j]) > 0)
    593           {w = 1; break;}
    594         }
     592        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
     593          if (isInMat(Vt2,L[j]) > 0)
     594          {w = 1; break;}
     595        }
    595596      }
    596597      if (w == 0)
    597598      {vector Vtt;
    598         for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
    599         M = M,Vtt;
    600         kill Vtt;
     599        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
     600        M = M,Vtt;
     601        kill Vtt;
    601602      }
    602603    }
     
    606607      for (i = 1; i <= size(M); i++)
    607608      {kill Vt; intvec Vt;
    608         for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
    609         R = R + findmistletoes(Vt,n,L,P);
     609        for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
     610        R = R + findmistletoes(Vt,n,L,P);
    610611      }
    611612      return(R);
     
    620621      for (j = 1; j <= size(P); j++)
    621622      {if (P[j] <= size(Vt))
    622         {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
    623           if (isInMat(Vt2,L[j]) > 0){w = 1; break;}
    624         }
     623        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
     624          if (isInMat(Vt2,L[j]) > 0){w = 1; break;}
     625        }
    625626      }
    626627      if (w == 0)
    627628      {vector Vtt;
    628         for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
    629         M = M,Vtt;
    630         kill Vtt;
     629        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
     630        M = M,Vtt;
     631        kill Vtt;
    631632      }
    632633    }
     
    636637      for (i = 1; i <= ncols(M); i++)
    637638      {kill Vt; intvec Vt;
    638         for (j =1; j <= size(M[i]); j++)
    639         {Vt[j] =  int(leadcoef(M[i][j]));}
    640         //Vt; typeof(Vt); size(Vt);
    641         R = R + findmistletoes(Vt,n,L,P,degbound);
     639        for (j =1; j <= size(M[i]); j++)
     640        {Vt[j] =  int(leadcoef(M[i][j]));}
     641        //Vt; typeof(Vt); size(Vt);
     642        R = R + findmistletoes(Vt,n,L,P,degbound);
    642643      }
    643644      return(R);
     
    747748RETURN: ideal
    748749PURPOSE:Converting a list of intmats into an ideal of corresponding monomials
    749 @*      The rows of the intmat corresponds to an intvec, which stores the 
     750@*      The rows of the intmat corresponds to an intvec, which stores the
    750751@*      monomial.
    751752@*      For the encoding of the variables see the overview.
     
    779780RETURN: ideal
    780781PURPOSE:Converting an intmat into an ideal of the corresponding monomials.
    781 @*      The rows of the intmat corresponds to an intvec, which stores the 
     782@*      The rows of the intmat corresponds to an intvec, which stores the
    782783@*      monomial.
    783784@*      For the encoding of the variables see the overview.
     
    16751676@*        degbound <= attrib(basering,uptodeg) should hold.
    16761677NOTE: - If L is the list returned, then L[1] is an integer, the K-dimension,
    1677 @*      L[2] is an intvec, the Hilbert series and L[3] is an ideal, 
     1678@*      L[2] is an intvec, the Hilbert series and L[3] is an ideal,
    16781679@*      the mistletoes
    16791680@*    - If degbound is set, there will be a degree bound added. 0 means no
  • Singular/LIB/involut.lib

    r1fe227 rf7d745  
    1010OVERVIEW:
    1111Involution is an anti-automorphism of a non-commutative K-algebra
    12 @* with the property that applied an involution twice, one gets an identity.
    13 @* Involution is linear with respect to the ground field. In this library we compute
    14 @* linear involutions, distinguishing the case of a diagonal matrix (such involutions
    15 @* are called homothetic) and a general one. Also, linear automorphisms of different
    16 @* order can be computed.
     12with the property that applied an involution twice, one gets an identity.
     13Involution is linear with respect to the ground field. In this library we
     14compute linear involutions, distinguishing the case of a diagonal matrix
     15(such involutions are called homothetic) and a general one.
     16Also, linear automorphisms of different order can be computed.
    1717
    1818SUPPORT: Forschungsschwerpunkt 'Mathematik und Praxis' (Project of Dr. E. Zerz
  • Singular/LIB/jacobson.lib

    r1fe227 rf7d745  
    99OVERVIEW:
    1010We work over a ring R, that is an Euclidean principal ideal domain.
    11 @* If R is commutative, we suppose R to be a polynomial ring in one variable.
    12 @* If R is non-commutative, we suppose R to have two variables, say x and d.
    13 @* We treat then the basering as the Ore localization of R
    14 @* with respect to the mult. closed set S = K[x] without 0.
    15 @* Thus, we treat basering as principal ideal ring with d a polynomial
    16 @* variable and x an invertible one.
    17 @* Note, that in computations no division by x will actually happen.
    18 @*
    19 @* Given a rectangular matrix M over R, one can compute unimodular (that is
    20 @* invertible) square matrices U and V, such that U*M*V=D is a diagonal matrix.
    21 @* Depending on the ring, the diagonal entries of D have certain properties.
    22 @*
    23 @* We call a square matrix D as before 'a weak Jacobson normal form of M'.
    24 @* It is known, that over the first rational Weyl algebra K(x)<d>, D can be further
    25 @* transformed into a diagonal matrix (1,1,...,1,f,0,..,0), where f is in K(x)<d>. We call
    26 @* such a form of D the strong Jacobson normal form. The existence of strong form
    27 @* in not guaranteed if one works with algebra, which is not rational Weyl algebra.
     11If R is commutative, we suppose R to be a polynomial ring in one variable.
     12If R is non-commutative, we suppose R to have two variables, say x and d.
     13We treat then the basering as the Ore localization of R
     14with respect to the mult. closed set S = K[x] without 0.
     15Thus, we treat basering as principal ideal ring with d a polynomial
     16variable and x an invertible one.
     17Note, that in computations no division by x will actually happen.
     18
     19Given a rectangular matrix M over R, one can compute unimodular (that is
     20invertible) square matrices U and V, such that U*M*V=D is a diagonal matrix.
     21Depending on the ring, the diagonal entries of D have certain properties.
     22
     23We call a square matrix D as before 'a weak Jacobson normal form of M'.
     24It is known, that over the first rational Weyl algebra K(x)<d>, D can be further
     25transformed into a diagonal matrix (1,1,...,1,f,0,..,0), where f is in K(x)<d>.
     26We call such a form of D the strong Jacobson normal form.
     27The existence of strong form in not guaranteed if one works with algebra,
     28which is not rational Weyl algebra.
    2829
    2930
  • Singular/LIB/modstd.lib

    r1fe227 rf7d745  
    10461046//-------------------  Lift results to basering via farey  ---------------------
    10471047
    1048       tt = timer;     
     1048      tt = timer;
    10491049      N = T2[1];
    10501050      for(i = 2; i <= size(T2); i++) { N = N*T2[i]; }
  • Singular/LIB/nctools.lib

    r1fe227 rf7d745  
    16891689    A = embedMat(A,rB,cA);
    16901690  }
    1691   else 
     1691  else
    16921692  {
    16931693    // rA>rB: add zero rows to B
  • Singular/LIB/surf.lib

    r1fe227 rf7d745  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: surf.lib 13499 2010-10-15 09:55:26Z hannes $";
     2version="$Id$";
    33category="Visualization";
    44info="
  • Singular/LIB/surfacesignature.lib

    r1fe227 rf7d745  
    2525  We have implemented three approaches using Puiseux expansions, the resolution
    2626  of singularities resp. the spectral pairs of the singularity.
    27  
     27
    2828REFERENCES:
    2929
  • Singular/LIB/tropical.lib

    r1fe227 rf7d745  
    67546754    xc=substitute(bunchoflines[i][1]-cc,var(2),0,var(1),1);
    67556755    yc=substitute(bunchoflines[i][1]-cc,var(2),1,var(1),0);
    6756         if (xc!=0) // then there is a point on the line with y-coordinate zero
     6756    if (xc!=0) // then there is a point on the line with y-coordinate zero
    67576757    {
    67586758      gr[1]=-cc/leadcoef(xc);
     
    74907490      +(t0*r2*q1^2+s1*r0*r2*q1+s0*r2^2*q0));
    74917491  poly a6=(-27*t0^2*q0^2+(9*t0*s0*r0-s0^3)*q0-t0*r0^3)*q3^2+
    7492         (((9*t0^2*q0-t0*s0*r0)*q1+((-3*t0*s0*r1+(3*t0*s1*r0+
    7493         2*s1*s0^2))*q0+(t0*r0^2*r1-s1*s0*r0^2)))*q2+(-t0^2*q1^3
    7494         +(t0*s0*r1+(2*t0*s1*r0-s1*s0^2))*q1^2+((3*t0*s0*r2+
    7495         (-3*t0*s1*r1+2*s1^2*s0))*q0+((2*t0*r0^2-s0^2*r0)*r2+
    7496         (-t0*r0*r1^2+s1*s0*r0*r1-s1^2*r0^2)))*q1+((9*t0*s1*r2-
    7497         s1^3)*q0^2+(((-3*t0*r0+s0^2)*r1-s1*s0*r0)*r2+(t0*r1^3
    7498         -s1*s0*r1^2+s1^2*r0*r1))*q0)))*q3+(-t0^2*q0*q2^3+
    7499         (-t0*s1*r0*q1+((2*t0*s0*r2+(t0*s1*r1-s1^2*s0))*q0-
    7500         t0*r0^2*r2))*q2^2+(-t0*s0*r2*q1^2+(-t0*s1*r2*q0+
    7501         (t0*r0*r1-s1*s0*r0)*r2)*q1+((2*t0*r0-s0^2)*r2^2+
    7502         (-t0*r1^2+s1*s0*r1-s1^2*r0)*r2)*q0)*q2+
    7503         (-t0*r0*r2^2*q1^2+(t0*r1-s1*s0)*r2^2*q0*q1-
     7492        (((9*t0^2*q0-t0*s0*r0)*q1+((-3*t0*s0*r1+(3*t0*s1*r0+
     7493        2*s1*s0^2))*q0+(t0*r0^2*r1-s1*s0*r0^2)))*q2+(-t0^2*q1^3
     7494        +(t0*s0*r1+(2*t0*s1*r0-s1*s0^2))*q1^2+((3*t0*s0*r2+
     7495        (-3*t0*s1*r1+2*s1^2*s0))*q0+((2*t0*r0^2-s0^2*r0)*r2+
     7496        (-t0*r0*r1^2+s1*s0*r0*r1-s1^2*r0^2)))*q1+((9*t0*s1*r2-
     7497        s1^3)*q0^2+(((-3*t0*r0+s0^2)*r1-s1*s0*r0)*r2+(t0*r1^3
     7498        -s1*s0*r1^2+s1^2*r0*r1))*q0)))*q3+(-t0^2*q0*q2^3+
     7499        (-t0*s1*r0*q1+((2*t0*s0*r2+(t0*s1*r1-s1^2*s0))*q0-
     7500        t0*r0^2*r2))*q2^2+(-t0*s0*r2*q1^2+(-t0*s1*r2*q0+
     7501        (t0*r0*r1-s1*s0*r0)*r2)*q1+((2*t0*r0-s0^2)*r2^2+
     7502        (-t0*r1^2+s1*s0*r1-s1^2*r0)*r2)*q0)*q2+
     7503        (-t0*r0*r2^2*q1^2+(t0*r1-s1*s0)*r2^2*q0*q1-
    75047504     t0*r2^3*q0^2));
    75057505  poly b2=a1^2+4*a2;
Note: See TracChangeset for help on using the changeset viewer.