Changeset 2e4b40 in git


Ignore:
Timestamp:
Jan 8, 2007, 5:29:02 PM (17 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b21a664aa22dc6e196223af8a74ad4885e83547c')
Children:
a143909496affcd2b7b44dbc4b68127153b56071
Parents:
4d13e709b2b2adc2f5660e94c6123ef21645c011
Message:
*hannes: format


git-svn-id: file:///usr/local/Singular/svn/trunk@9644 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/noether.lib

    r4d13e7 r2e4b40  
    11// AH last modified:  01.07.2007
    22//////////////////////////////////////////////////////////////////////////////
    3 version = "$Id: noether.lib,v 1.4 2007-01-08 12:59:38 pfister Exp $";
     3version = "$Id: noether.lib,v 1.5 2007-01-08 16:29:02 Singular Exp $";
    44category="Commutative Algebra";
    55info="
    6 LIBRARY: noether.lib   Noether normalization of an ideal (not nessecary 
     6LIBRARY: noether.lib   Noether normalization of an ideal (not nessecary
    77                       homogeneous)
    88AUTHORS: A. Hashemi,  Amir.Hashemi@lip6.fr
     
    1010
    1111OVERVIEW:
    12 A library for computing the Noether normalization of an ideal that DOES NOT 
     12A library for computing the Noether normalization of an ideal that DOES NOT
    1313require the computation of the dimension of the ideal.
    14 It checks whether an ideal is in Noether position.  A modular version of 
     14It checks whether an ideal is in Noether position.  A modular version of
    1515these algorithms is also provided.
    16 The procedures are based on a paper of Amir Hashemi 'Efficient Algorithms for 
     16The procedures are based on a paper of Amir Hashemi 'Efficient Algorithms for
    1717Computing Noether Normalization'
    18 Submitted to: Special Issue of Mathematics in Computer Science on Symbolic 
     18Submitted to: Special Issue of Mathematics in Computer Science on Symbolic
    1919and Numeric Computation.
    2020
    21 This library computes also Castelnuovo-Mumford regularity and satiety of an 
     21This library computes also Castelnuovo-Mumford regularity and satiety of an
    2222ideal.  A modular version of these algorithms is also provided.
    23 The procedures are based on a paper of Amir Hashemi 'Computation of 
     23The procedures are based on a paper of Amir Hashemi 'Computation of
    2424Castelnuovo-Mumford regularity and satiety'
    2525Submitted to: ISSAC 2007.
     
    4646proc NP_test (ideal I)
    4747"
    48 USAGE:  NP-test (I); I monomial ideal
    49 RETURN: A list which first element is 1 if i is in Noether position
    50         0  otherwise. The second element of this list is the list of variable which
    51         its first part is the variable such that a power of this varaibles belong to the initial of i.
    52         It return also the dimension of i if i is in Noether position
    53 ASSUME: i is a nonzero monomial ideal.
     48USAGE:  NP-test (I); I monomial ideal
     49RETURN: A list which first element is 1 if i is in Noether position
     50        0  otherwise. The second element of this list is the list of variable which
     51        its first part is the variable such that a power of this varaibles belong to the initial of i.
     52        It return also the dimension of i if i is in Noether position
     53ASSUME: i is a nonzero monomial ideal.
    5454"
    5555{
     
    6262   if (I[1]==1)
    6363   {
    64         print("The ideal is 1");return(1);
     64    print("The ideal is 1");return(1);
    6565   }
    6666   for ( ii = 1; ii <= n+1; ii++ )
    67      {
    68         L[ii]=0;
    69      }
     67   {
     68     L[ii]=0;
     69   }
    7070   for ( ii = 1; ii <= size(I); ii++ )
    7171   {
    72         Y=findvars(I[ii],1)[1];
    73         l=rvar(Y[1][1]);
    74         if (size(Y[1])==1)     
    75         {
    76                 L[l]=1;
    77                 P1=insert(P1,Y[1][1]);
    78         }
    79         if (L[l]==0)
    80         {
    81                 L[l]=-1;
    82         }
    83     }
     72     Y=findvars(I[ii],1)[1];
     73     l=rvar(Y[1][1]);
     74     if (size(Y[1])==1)       
     75     {
     76       L[l]=1;
     77       P1=insert(P1,Y[1][1]);
     78     }
     79     if (L[l]==0)
     80     {
     81       L[l]=-1;
     82     }
     83   }
    8484   t=size(P1);
    8585   if (t==0)
    8686   {
    87          for ( jj = 1; jj <= n+1; jj++ )
    88          {
    89                P3=insert(P3,varstr(jj));
    90          }       
     87     for ( jj = 1; jj <= n+1; jj++ )
     88     {
     89       P3=insert(P3,varstr(jj));
     90     }
    9191   }
    9292   else
    9393   {
    94          P2=findvars(ideal(P1[1..t]),1)[3];
    95          for ( jj = 1; jj <= size(P2[1]); jj++ )
    96          {
    97                P3=insert(P3,P2[1][jj]);
    98          }
     94     P2=findvars(ideal(P1[1..t]),1)[3];
     95     for ( jj = 1; jj <= size(P2[1]); jj++ )
     96     {
     97       P3=insert(P3,P2[1][jj]);
     98     }
    9999   }
    100100   if (L[n+1]==-1)
    101         {
    102                  return(list(0,P1+P3));
    103         }
     101   {
     102     return(list(0,P1+P3));       
     103   }
    104104   for ( ii = 1; ii <= n; ii++ )
     105   {
     106     if (L[ii]==-1)
    105107     {
    106         if (L[ii]==-1)
    107         {
    108                  return(list(0,P1+P3));
    109         }
    110         if (L[ii]==0 and L[ii+1]==1)
    111         {
    112                  return(list(0,P1+P3));
    113         }
    114     }
    115     d=n+1-sum(L);
    116     print("The dimension of the ideal is:");print(d);
    117     return(list(1,P1+P3));
    118 
     108       return(list(0,P1+P3));       
     109     }
     110     if (L[ii]==0 and L[ii+1]==1)
     111     {
     112       return(list(0,P1+P3));       
     113     }
     114   }
     115   d=n+1-sum(L);
     116   print("The dimension of the ideal is:");print(d);
     117   return(list(1,P1+P3));
    119118}
    120119//////////////////////////////////////////
    121120proc MNP_test (ideal i)
    122 "USAGE: MNP-test (i); i an ideal
    123 RETURN: 1 if i is in Noether position 0  otherwise.
    124 NOTE:   This test is a probabilistic test, and it computes the initial of the ideal modulo the prime number 2147483647 (the biggest prime less than 2^31).     
     121"USAGE: MNP-test (i); i an ideal
     122RETURN: 1 if i is in Noether position 0  otherwise.
     123NOTE:   This test is a probabilistic test, and it computes the initial of the ideal modulo the prime number 2147483647 (the biggest prime less than 2^31).       
    125124"
    126125{
    127        "// WARNING:
     126  "// WARNING:
    128127// The procedure is probabilistic and  it computes the initial of the ideal modulo the prime number 2147483647";
    129    int p;
    130    def br=basering;
    131    setring br;
    132    ideal I;
    133    list #;
    134    option(redSB);
    135    p=2147483647;
    136    #=ringlist(br);
    137    #[1]=p;
    138    def oro=ring(#);
    139    setring oro;
    140    ideal sbi,lsbi;
    141    sbi=fetch(br,i);
    142    lsbi=lead(std(sbi));
    143    setring br;
    144    I=fetch(oro,lsbi);
    145    I=simplify(I,1);
    146    attrib(I,"isSB",1);
    147    return(NP_test(I));
     128  int p;
     129  def br=basering;
     130  setring br;
     131  ideal I;
     132  list #;
     133  option(redSB);
     134  p=2147483647;
     135  #=ringlist(br);
     136  #[1]=p;
     137  def oro=ring(#);
     138  setring oro;
     139  ideal sbi,lsbi;
     140  sbi=fetch(br,i);
     141  lsbi=lead(std(sbi));
     142  setring br;
     143  I=fetch(oro,lsbi);
     144  I=simplify(I,1);
     145  attrib(I,"isSB",1);
     146  return(NP_test(I));
    148147}
    149148
     
    151150///////////////////////////////////////////////////////////////////////////////
    152151proc NP (ideal i)
    153 "
    154 USAGE:   NP (i); i ideal
    155 RETURN:  A linear map phi such that  phi(i) is in Noether position
     152"USAGE:  NP (i); i ideal
     153RETURN:  A linear map phi such that  phi(i) is in Noether position
    156154"
    157155{
    158156//--------------------------- initialisation ---------------------------------
    159    int ii,jj,d,time,n,nl;
    160    intmat ran;
    161    def r0 = basering;
    162    ideal K,chcoord;
    163    n = nvars(r0)-1;
    164    string s = "ring r1 = ",charstr(r0),",x(0..n),dp;";
    165    execute(s);
    166    ideal i,sbi,I,K,chcoord,m,L;
    167    list #;
    168    poly P;
    169    map phi;
    170    i = fetch(r0,i);
    171    time=rtimer;
    172    system("--ticks-per-sec",10);
    173    i=std(i);
    174    sbi=sort(lead(i))[1];
    175    #=NP_test(sbi);
    176    if ( #[1]== 1 )
    177      {
    178         return ("The ideal is in Noether position and the time of this computation is:",rtimer-time,"/10 sec.");
    179      }
    180    else
    181      {
    182                 L=maxideal(1);
    183                 chcoord=maxideal(1);
    184                 for ( ii = 1; ii<=n+1; ii++ )
    185                 {
    186                         chcoord[rvar(#[2][ii])]=L[ii];
    187                 }
    188                 phi=r1,chcoord;
    189                 sbi=phi(sbi);
    190                 if ( NP_test(sbi)[1] == 1 )
    191                 {
    192                  setring r0;
    193                  chcoord=fetch(r1,chcoord);
    194                  return (chcoord,"and the time of this computation is:",rtimer-time,"/10 sec.");
    195                 }
    196      }
    197    while ( nl < 30 )
    198    {
    199      nl=nl+1;
    200      I=i;       
    201      L=maxideal(1);
    202      for ( ii = n; ii>=0; ii-- )
    203      {
    204        chcoord=select1(maxideal(1),1,(ii));
    205        ran=random(100,1,ii);
    206        ran=intmat(ran,1,ii+1);
    207        ran[1,ii+1]=1;
    208        m=select1(maxideal(1),1,(ii+1));
    209        for ( jj = 1; jj<=ii+1; jj++ )
    210        {
    211                 P=P+ran[1,jj]*m[jj];
    212        }
    213        chcoord[ii+1]=P;
    214         L[ii+1]=P;
    215        P=0;
    216        phi=r1,chcoord;
    217        I=phi(I);
    218        if ( NP_test(sort(lead(std(I)))[1])[1] == 1 )
    219            {
    220                  K=x(ii..n);
    221                  setring r0;
    222                  K=fetch(r1,K);
    223                  ideal L=fetch(r1,L);
    224                  return (L,"and the time of this computation is:",rtimer-time,"/10 sec.");
    225            }
    226 
    227      }
    228    }
    229        "// WARNING:
     157  int ii,jj,d,time,n,nl;
     158  intmat ran;
     159  def r0 = basering;
     160  ideal K,chcoord;
     161  n = nvars(r0)-1;
     162  string s = "ring r1 = ",charstr(r0),",x(0..n),dp;";
     163  execute(s);
     164  ideal i,sbi,I,K,chcoord,m,L;
     165  list #;
     166  poly P;
     167  map phi;
     168  i = fetch(r0,i);
     169  time=rtimer;
     170  system("--ticks-per-sec",10);
     171  i=std(i);
     172  sbi=sort(lead(i))[1];
     173  #=NP_test(sbi);
     174  if ( #[1]== 1 )
     175  {
     176    return ("The ideal is in Noether position and the time of this computation is:",rtimer-time,"/10 sec.");
     177  }
     178  else
     179  {
     180    L=maxideal(1);
     181    chcoord=maxideal(1);
     182    for ( ii = 1; ii<=n+1; ii++ )
     183    {
     184      chcoord[rvar(#[2][ii])]=L[ii];
     185    }
     186    phi=r1,chcoord;
     187    sbi=phi(sbi);
     188    if ( NP_test(sbi)[1] == 1 )
     189    {
     190      setring r0;
     191      chcoord=fetch(r1,chcoord);
     192      return (chcoord,"and the time of this computation is:",rtimer-time,"/10 sec.");
     193    }
     194  }
     195  while ( nl < 30 )
     196  {
     197    nl=nl+1;
     198    I=i;       
     199    L=maxideal(1);
     200    for ( ii = n; ii>=0; ii-- )
     201    {
     202      chcoord=select1(maxideal(1),1,(ii));
     203      ran=random(100,1,ii);
     204      ran=intmat(ran,1,ii+1);
     205      ran[1,ii+1]=1;
     206      m=select1(maxideal(1),1,(ii+1));
     207      for ( jj = 1; jj<=ii+1; jj++ )
     208      {
     209        P=P+ran[1,jj]*m[jj];
     210      }
     211      chcoord[ii+1]=P;
     212      L[ii+1]=P;
     213      P=0;
     214      phi=r1,chcoord;
     215      I=phi(I);
     216      if ( NP_test(sort(lead(std(I)))[1])[1] == 1 )
     217      {
     218        K=x(ii..n);
     219        setring r0;
     220        K=fetch(r1,K);
     221        ideal L=fetch(r1,L);
     222        return (L,"and the time of this computation is:",rtimer-time,"/10 sec.");
     223      }
     224    }
     225  }
     226  "// WARNING:
    230227// The procedure has entered in more than 30 loops: in your example
    231228// the method may enter an infinite loop over a finite field!";
    232        return (-1);
     229  return (-1);
    233230}
    234231///////////////////////////////////////////////////////////////////////////////
    235232proc MNP (ideal i)
    236 "USAGE: MNP (i); i ideal
    237 RETURN: A linear map phi such that  phi(i) is in Noether position
    238 NOTE:   It uses the procedure  MNP_test to test Noether position.       
     233"USAGE:  MNP (i); i ideal
     234RETURN:  A linear map phi such that  phi(i) is in Noether position
     235NOTE:    It uses the procedure  MNP_test to test Noether position.       
    239236"
    240237{
     
    256253   #=MNP_test(i);
    257254   if ( #[1]== 1 )
     255   {
     256     return ("The ideal is in Noether position and the time of this computation is:",rtimer-time,"/10 sec.");
     257   }
     258   else
     259   {
     260     L=maxideal(1);
     261     chcoord=maxideal(1);
     262     for ( ii = 1; ii<=n+1; ii++ )
    258263     {
    259         return ("The ideal is in Noether position and the time of this computation is:",rtimer-time,"/10 sec.");
     264       chcoord[rvar(#[2][ii])]=L[ii];
    260265     }
    261    else
     266     phi=r1,chcoord;
     267     I=phi(i);
     268     if ( MNP_test(I)[1] == 1 )
    262269     {
    263                 L=maxideal(1);
    264                 chcoord=maxideal(1);
    265                 for ( ii = 1; ii<=n+1; ii++ )
    266                 {
    267                         chcoord[rvar(#[2][ii])]=L[ii];
    268                 }
    269                 phi=r1,chcoord;
    270                 I=phi(i);
    271                 if ( MNP_test(I)[1] == 1 )
    272                 {
    273                  setring r0;
    274                  chcoord=fetch(r1,chcoord);
    275                  return (chcoord,"and the time of this computation is:",rtimer-time,"/10 sec.");
    276                 }
     270       setring r0;
     271       chcoord=fetch(r1,chcoord);
     272       return (chcoord,"and the time of this computation is:",rtimer-time,"/10 sec.");
    277273     }
     274   }
    278275   while ( nl < 30 )
    279276   {
    280277     nl=nl+1;
    281      I=i;       
     278     I=i;       
    282279     L=maxideal(1);
    283280     for ( ii = n; ii>=0; ii-- )
     
    290287       for ( jj = 1; jj<=ii+1; jj++ )
    291288       {
    292                 P=P+ran[1,jj]*m[jj];
     289         P=P+ran[1,jj]*m[jj];
    293290       }
    294291       chcoord[ii+1]=P;
     
    298295       I=phi(I);
    299296       if ( MNP_test(I)[1] == 1 )
    300            {
    301                  K=x(ii..n);
    302                  setring r0;
    303                  K=fetch(r1,K);
    304                  ideal L=fetch(r1,L);
    305                  return (L,"and the time of this computation is:",rtimer-time,"/10 sec.");
    306            }
    307 
     297       {
     298         K=x(ii..n);
     299         setring r0;
     300         K=fetch(r1,K);
     301         ideal L=fetch(r1,L);
     302         return (L,"and the time of this computation is:",rtimer-time,"/10 sec.");
     303       }
    308304     }
    309305   }
    310        "// WARNING:
     306   "// WARNING:
    311307// The procedure has entered in more than 30 loops: in your example
    312308// the method may enter an infinite loop over a finite field!";
    313        return (-1);
     309   return (-1);
    314310}
    315311
    316312////////////////////////////////////////////////////////////////////////////////////
    317313proc Test (ideal i)
    318 "
    319 USAGE:   Test (i); i a monomial ideal,
     314"USAGE:   Test (i); i a monomial ideal,
    320315RETURN:  1 if the last variable is in generic position for i and 0 otherwise.
    321 THEORY:  The last variable is in generic position if the quotient of the ideal 
    322         with respect to this variable is equal to the quotient of the ideal with respect to the maximal ideal.
     316THEORY:  The last variable is in generic position if the quotient of the ideal
     317        with respect to this variable is equal to the quotient of the ideal with respect to the maximal ideal.
    323318"
    324319{
    325320//--------------------------- initialisation ---------------------------------
    326    int n,ret;
    327    def r0 = basering;
    328    n = nvars(r0)-1;
    329    string s = "ring r1 = ",charstr(r0),",x(0..n),dp;";
    330    execute(s);
    331    ideal I,i;
    332    i = fetch(r0,i);
    333    attrib(i,"isSB",1);
    334    I=quotient(select(i,n+1),x(n));
    335    I=I*maxideal(1);
    336    ret=1;
    337    if (size(reduce(I,i)) <> 0)
    338    {
    339         ret=0;
    340    }
    341 return(ret);
     321  int n,ret;
     322  def r0 = basering;
     323  n = nvars(r0)-1;
     324  string s = "ring r1 = ",charstr(r0),",x(0..n),dp;";
     325  execute(s);
     326  ideal I,i;
     327  i = fetch(r0,i);
     328  attrib(i,"isSB",1);
     329  I=quotient(select(i,n+1),x(n));
     330  I=I*maxideal(1);
     331  ret=1;
     332  if (size(reduce(I,i)) <> 0)
     333  {
     334    ret=0;
     335  }
     336  return(ret);
    342337}
    343338
     
    345340////////////////////////////////////////////////////////////////////////////////////
    346341proc nsatiety (ideal i)
    347 "
    348 USAGE:   nsatiety (i); i ideal,
     342"USAGE:   nsatiety (i); i ideal,
    349343RETURN:  an integer, the satiety of i.
    350344         (returns -1 if i is not homogeneous)
     
    356350{
    357351//--------------------------- initialisation ---------------------------------
    358    int e,ii,jj,h,d,time,lastv,nl,ret;
    359    intmat ran;
    360    def r0 = basering;
    361    int n = nvars(r0)-1;
    362    string s = "ring r1 = ",charstr(r0),",x(0..n),dp;";
    363    execute(s);
    364    ideal i,sbi,I,K,chcoord,m,L;
    365    poly P;
    366    map phi;
    367    i = fetch(r0,i);
    368    time=rtimer;
    369    system("--ticks-per-sec",100);
    370    sbi=std(i);
     352  int e,ii,jj,h,d,time,lastv,nl,ret;
     353  intmat ran;
     354  def r0 = basering;
     355  int n = nvars(r0)-1;
     356  string s = "ring r1 = ",charstr(r0),",x(0..n),dp;";
     357  execute(s);
     358  ideal i,sbi,I,K,chcoord,m,L;
     359  poly P;
     360  map phi;
     361  i = fetch(r0,i);
     362  time=rtimer;
     363  system("--ticks-per-sec",100);
     364  sbi=std(i);
    371365//----- Check ideal homogeneous
    372    if ( homog(sbi) == 0 )
    373    {
    374        dbprint(2,"The ideal is not homogeneous, and time for this test is: " + string(rtimer-time) + "/100sec.");
    375         return ();
    376    }
    377    I=simplify(lead(sbi),1);
    378    attrib(I,"isSB",1);
    379    K=select(I,n+1);
    380    if (size(K) == 0)
    381    {
    382         dbprint(2,"sat(i)=0 and the time of this computation: " + string(rtimer-time) + "/100sec.");
    383         return();
    384    }
    385    if (Test(I) == 1 )
    386    {
    387         dbprint(2,"sat(i)=" + string(maxdeg1(K)) + " and the time of this computation: " + string(rtimer-time) + "/100sec.");
    388         return();
    389    }
    390    while ( nl < 5 )
    391    {
    392      nl=nl+1;   
    393      chcoord=select1(maxideal(1),1,(n));
    394      ran=random(100,1,n);
    395      ran=intmat(ran,1,n+1);
    396      ran[1,n+1]=1;
    397      m=select1(maxideal(1),1,(n+1));
    398      for ( jj = 1; jj<=n+1; jj++ )
    399        {
    400                 P=P+ran[1,jj]*m[jj];
    401        }
    402      chcoord[n+1]=P;
    403      P=0;
    404      phi=r1,chcoord;
    405      L=std(phi(i));
    406      I=simplify(lead(L),1);
    407      attrib(I,"isSB",1);
    408      K=select(I,n+1);
    409      if (size(K) == 0)
    410      {
    411         dbprint(2,"sat(i)=0 and the time of this computation: " + string(rtimer-time) + "/100sec.");
    412         return();
    413      }
    414      if (Test(I) == 1 )
    415      {
    416         dbprint(2,"sat(i)=" + string(maxdeg1(K)) + " and the time of this computation: " + string(rtimer-time) + "/100sec.");
    417         return();
    418      }
    419    }
     366  if ( homog(sbi) == 0 )
     367  {
     368    dbprint(2,"The ideal is not homogeneous, and time for this test is: " + string(rtimer-time) + "/100sec.");
     369    return ();
     370  }
     371  I=simplify(lead(sbi),1);
     372  attrib(I,"isSB",1);
     373  K=select(I,n+1);
     374  if (size(K) == 0)
     375  {
     376    dbprint(2,"sat(i)=0 and the time of this computation: " + string(rtimer-time) + "/100sec.");
     377    return();
     378  }
     379  if (Test(I) == 1 )
     380  {
     381    dbprint(2,"sat(i)=" + string(maxdeg1(K)) + " and the time of this computation: " + string(rtimer-time) + "/100sec.");
     382    return();
     383  }
     384  while ( nl < 5 )
     385  {
     386    nl=nl+1;       
     387    chcoord=select1(maxideal(1),1,(n));
     388    ran=random(100,1,n);
     389    ran=intmat(ran,1,n+1);
     390    ran[1,n+1]=1;
     391    m=select1(maxideal(1),1,(n+1));
     392    for ( jj = 1; jj<=n+1; jj++ )
     393    {
     394      P=P+ran[1,jj]*m[jj];
     395    }
     396    chcoord[n+1]=P;
     397    P=0;
     398    phi=r1,chcoord;
     399    L=std(phi(i));
     400    I=simplify(lead(L),1);
     401    attrib(I,"isSB",1);
     402    K=select(I,n+1);
     403    if (size(K) == 0)
     404    {
     405      dbprint(2,"sat(i)=0 and the time of this computation: " + string(rtimer-time) + "/100sec.");
     406      return();
     407    }
     408    if (Test(I) == 1 )
     409    {
     410      dbprint(2,"sat(i)=" + string(maxdeg1(K)) + " and the time of this computation: " + string(rtimer-time) + "/100sec.");
     411      return();
     412    }
     413  }
    420414}
    421415
     
    423417//////////////////////////////////////////////////////////////////////////////
    424418proc msatiety (ideal i)
    425 "
    426 USAGE:   msatiety (i); i ideal,
     419"USAGE:   msatiety (i); i ideal,
    427420RETURN:  an integer, the satiety of i.
    428421         (returns -1 if i is not homogeneous)
     
    431424         least integer s such that, for all d>=s, the degree d part of the
    432425         ideals i and isat=sat(i,maxideal(1))[1] coincide.
    433 NOTE:    This is a probabilistic procedure, and it computes the initial of the ideal modulo the prime number 2147483647 (the biggest prime less than 2^31).
     426NOTE:    This is a probabilistic procedure, and it computes the initial of the ideal modulo the prime number 2147483647 (the biggest prime less than 2^31).
    434427"
    435428{
    436429//--------------------------- initialisation ---------------------------------
    437        "// WARNING: The characteristic of base field must be zero.
    438 // The procedure is probabilistic and  it computes the 
     430  "// WARNING: The characteristic of base field must be zero.
     431// The procedure is probabilistic and  it computes the
    439432//initial ideals modulo the prime number 2147483647.";
    440    int e,ii,jj,h,d,time,lastv,nl,ret,s1,d1,siz,j,si,u,k,p;
    441    intvec v1;
    442    intmat ran;
    443    def r0 = basering;
    444    int n = nvars(r0)-1;
    445    string s = "ring r1 = ",charstr(r0),",x(0..n),dp;";
    446    execute(s);
    447    ideal i,sbi,I,K,chcoord,m,L,sbi1,lsbi1,id1;
    448    vector V1;
    449    list #,LL,PL,Gb1,VGb1,Gb2,VGb2,Res1,Res2;
    450    poly P;
    451    map phi;
    452    time=rtimer;
    453    system("--ticks-per-sec",100);
    454    i = fetch(r0,i);
     433  int e,ii,jj,h,d,time,lastv,nl,ret,s1,d1,siz,j,si,u,k,p;
     434  intvec v1;
     435  intmat ran;
     436  def r0 = basering;
     437  int n = nvars(r0)-1;
     438  string s = "ring r1 = ",charstr(r0),",x(0..n),dp;";
     439  execute(s);
     440  ideal i,sbi,I,K,chcoord,m,L,sbi1,lsbi1,id1;
     441  vector V1;
     442  list #,LL,PL,Gb1,VGb1,Gb2,VGb2,Res1,Res2;
     443  poly P;
     444  map phi;
     445  time=rtimer;
     446  system("--ticks-per-sec",100);
     447  i = fetch(r0,i);
    455448//----- Check ideal homogeneous
    456    if ( homog(i) == 0 )
    457    {
    458        "// WARNING: The ideal is not homogeneous.";
    459        dbprint(2,"Time for this test is: " + string(rtimer-time) + "/100sec.");
    460         return ();
    461    }
    462    option(redSB);
    463    p=2147483647;
    464    list r2=ringlist(r1);
    465    r2[1]=p;
    466    def oro=ring(r2);
    467    setring oro;
    468    ideal sbi=fetch(r1,i);
    469    sbi=std(sbi);
    470    setring r1;
    471    sbi=fetch(oro,sbi);
    472    kill oro;
    473    I=simplify(lead(sbi),1);
    474    attrib(I,"isSB",1);
    475    K=select(I,n+1);
    476    if (size(K) == 0)
    477    {
    478         dbprint(2,"msat(i)=0 and the time of this computation: " + string(rtimer-time) + "/100sec.");
    479         return();
    480    }
    481    if (Test(I) == 1 )
    482    {
    483         dbprint(2,"msat(i)=" + string(maxdeg1(K)) + " and the time of this computation: " + string(rtimer-time) + "/100sec.");
    484         return();
    485    }
    486    while ( nl < 30 )
    487    {
    488      nl=nl+1;   
    489      chcoord=select1(maxideal(1),1,(n));
    490      ran=random(100,1,n);
    491      ran=intmat(ran,1,n+1);
    492      ran[1,n+1]=1;
    493      m=select1(maxideal(1),1,(n+1));
    494      for ( jj = 1; jj<=n+1; jj++ )
    495        {
    496                 P=P+ran[1,jj]*m[jj];
    497        }
    498      chcoord[n+1]=P;
    499      P=0;
    500      phi=r1,chcoord;
    501      sbi=phi(i);
    502      list r2=ringlist(r1);
    503      r2[1]=p;
    504      def oro=ring(r2);
    505      setring oro;
    506      ideal sbi=fetch(r1,sbi);
    507      sbi=std(sbi);
    508      setring r1;
    509      sbi=fetch(oro,sbi);
    510      kill oro;
    511      lsbi1=lead(sbi);
    512      attrib(lsbi1,"isSB",1);
    513      K=select(lsbi1,n+1);
    514      if (size(K) == 0)
    515      {
    516         dbprint(2,"msat(i)=0 and the time of this computation: " + string(rtimer-time) + "/100sec.");
    517         return();
    518      }
    519      if (Test(lsbi1) == 1 )
    520      {
    521         dbprint(2,"msat(i)=" + string(maxdeg1(K)) + " and the time of this computation: " + string(rtimer-time) + "/100sec.");
    522         return();
    523      }
    524    }
     449  if ( homog(i) == 0 )
     450  {
     451    "// WARNING: The ideal is not homogeneous.";
     452    dbprint(2,"Time for this test is: " + string(rtimer-time) + "/100sec.");
     453    return ();
     454  }
     455  option(redSB);
     456  p=2147483647;
     457  list r2=ringlist(r1);
     458  r2[1]=p;
     459  def oro=ring(r2);
     460  setring oro;
     461  ideal sbi=fetch(r1,i);
     462  sbi=std(sbi);
     463  setring r1;
     464  sbi=fetch(oro,sbi);
     465  kill oro;
     466  I=simplify(lead(sbi),1);
     467  attrib(I,"isSB",1);
     468  K=select(I,n+1);
     469  if (size(K) == 0)
     470  {
     471    dbprint(2,"msat(i)=0 and the time of this computation: " + string(rtimer-time) + "/100sec.");
     472    return();
     473  }
     474  if (Test(I) == 1 )
     475  {
     476    dbprint(2,"msat(i)=" + string(maxdeg1(K)) + " and the time of this computation: " + string(rtimer-time) + "/100sec.");
     477    return();
     478  }
     479  while ( nl < 30 )
     480  {
     481    nl=nl+1;       
     482    chcoord=select1(maxideal(1),1,(n));
     483    ran=random(100,1,n);
     484    ran=intmat(ran,1,n+1);
     485    ran[1,n+1]=1;
     486    m=select1(maxideal(1),1,(n+1));
     487    for ( jj = 1; jj<=n+1; jj++ )
     488    {
     489      P=P+ran[1,jj]*m[jj];
     490    }
     491    chcoord[n+1]=P;
     492    P=0;
     493    phi=r1,chcoord;
     494    sbi=phi(i);
     495    list r2=ringlist(r1);
     496    r2[1]=p;
     497    def oro=ring(r2);
     498    setring oro;
     499    ideal sbi=fetch(r1,sbi);
     500    sbi=std(sbi);
     501    setring r1;
     502    sbi=fetch(oro,sbi);
     503    kill oro;
     504    lsbi1=lead(sbi);
     505    attrib(lsbi1,"isSB",1);
     506    K=select(lsbi1,n+1);
     507    if (size(K) == 0)
     508    {
     509      dbprint(2,"msat(i)=0 and the time of this computation: " + string(rtimer-time) + "/100sec.");
     510      return();
     511    }
     512    if (Test(lsbi1) == 1 )
     513    {
     514      dbprint(2,"msat(i)=" + string(maxdeg1(K)) + " and the time of this computation: " + string(rtimer-time) + "/100sec.");
     515      return();
     516    }
     517  }
    525518}
    526519
     
    528521//
    529522proc reg (ideal i)
    530 "
    531 USAGE:  reg (i); i ideal
    532 RETURN: the Castelnuovo-Mumford regularity of i.
     523"USAGE:  reg (i); i ideal
     524RETURN:  the Castelnuovo-Mumford regularity of i.
    533525         (returns -1 if i is not homogeneous)
    534526ASSUME:  i is a homogeneous ideal.
     
    536528{
    537529//--------------------------- initialisation ---------------------------------
    538    int e,ii,jj,H,h,d,time,nl;
    539    def r0 = basering;
    540    int n = nvars(r0)-1;
    541    string s = "ring r1 = ",charstr(r0),",x(0..n),dp;";
    542    execute(s);
    543    ideal i,sbi,I,J,K,L;
    544    list #;
    545    poly P;
    546    map phi;
    547    i = fetch(r0,i);
    548    time=rtimer;
    549    system("--ticks-per-sec",100);
    550    sbi=std(i);
     530  int e,ii,jj,H,h,d,time,nl;
     531  def r0 = basering;
     532  int n = nvars(r0)-1;
     533  string s = "ring r1 = ",charstr(r0),",x(0..n),dp;";
     534  execute(s);
     535  ideal i,sbi,I,J,K,L;
     536  list #;
     537  poly P;
     538  map phi;
     539  i = fetch(r0,i);
     540  time=rtimer;
     541  system("--ticks-per-sec",100);
     542  sbi=std(i);
    551543//----- Check ideal homogeneous
    552    if ( homog(sbi) == 0 )
    553    {
    554        "// The ideal is not homogeneous!";
    555        return (-1);
    556    }
    557    I=simplify(lead(sbi),1);
    558    attrib(I,"isSB",1);
    559    d=dim(I);
    560    if (char(r1) > 0 and d == 0)
    561    {
    562         def r2=changechar("0",r1);
    563         setring r2;
    564         ideal sbi,I,i,K,T;
    565         map phi;
    566         I = fetch(r1,I);
    567         i=I;
    568         attrib(I,"isSB",1);
    569    }
    570    else
    571    {
    572         def r2=changechar(charstr(r1),r1);
    573         setring r2;
    574         ideal sbi,I,i,K,T,ic,Ic;
    575         map phi;
    576         I = imap(r1,I);
    577         Ic=I;
    578         attrib(I,"isSB",1);
    579         i = imap(r1,i);
    580         ic=i;
    581    }
    582    K=select(I,n+1);
    583    if (size(K) == 0)
    584    {
    585         h=0;
    586    }
    587    else
    588    {
    589         if (Test(I) == 1)
    590         {
    591                 h=maxdeg1(K);
    592         }
    593         else
    594         {       
    595                 while ( nl < 30 )
    596                 {
    597                         nl=nl+1;
    598                         phi=r2,randomLast(100);
    599                         T=phi(i);
    600                         I=simplify(lead(std(T)),1);
    601                         attrib(I,"isSB",1);
    602                         K=select(I,n+1);
    603                         if (size(K) == 0)
    604                         {
    605                                 h=0;break
    606                         }
    607                         if (Test(I) == 1 )
    608                         {
    609                                 h=maxdeg1(K);break;
    610                         }
    611                 }
    612                 i=T;
    613         }
    614    }
    615    for ( ii = n; ii>=n-d+1; ii-- )
    616    {
    617         i=subst(i,x(ii),0);
    618         s = "ring mr = ",charstr(r1),",x(0..ii-1),dp;";
    619         execute(s);
    620         ideal i,sbi,I,J,K,L,T;
    621         poly P;
    622         map phi;
    623         i=imap(r2,i);
    624         I=simplify(lead(std(i)),1);
    625         attrib(I,"isSB",1);
    626         K=select(I,ii);
    627         if (size(K) == 0)
    628         {
    629                 H=0;
    630         }
    631         else
    632         {
    633                 if (Test(I) == 1)
    634                 {
    635                         H=maxdeg1(K);
    636                 }
    637                 else
    638                 {
    639                         while ( nl < 30 )
    640                         {
    641                                 nl=nl+1;       
    642                                 phi=mr,randomLast(100);
    643                                 T=phi(i);
    644                                 I=simplify(lead(std(T)),1);
    645                                 attrib(I,"isSB",1);
    646                                 K=select(I,ii);
    647                                 if (size(K) == 0)
    648                                 {
    649                                         H=0;break;
    650                                 }
    651                                 if (Test(I) == 1 )
    652                                 {
    653                                         H=maxdeg1(K);break;
    654                                 }
    655                         }
    656                         setring r2;
    657                         i=imap(mr,T);
    658                         kill mr;
    659                 }
    660         }
    661         if (H > h)
    662         {
    663                 h=H;
    664         }
    665    }
    666    if (nl < 30)
    667    {   
    668         dbprint(2,"reg(i)=" + string(h) + " and the time of this computation: " + string(rtimer-time) + " sec./100");
    669         return();
    670    }
    671    else
    672    {
    673         I=Ic;
    674         attrib(I,"isSB",1);
    675         i=ic;
    676         K=subst(select(I,n+1),x(n),1);
    677         K=K*maxideal(maxdeg1(I));
    678         if (size(reduce(K,I)) <> 0)
    679         {
    680                 nl=0;
    681                 while ( nl < 30 )
    682                 {
    683                         nl=nl+1;
    684                         phi=r1,randomLast(100);
    685                         sbi=phi(i);
    686                         I=simplify(lead(std(sbi)),1);
    687                         attrib(I,"isSB",1);
    688                         K=subst(select(I,n+1),x(n),1);
    689                         K=K*maxideal(maxdeg1(I));
    690                         if (size(reduce(K,I)) == 0)
    691                         {
    692                                 break;
    693                         }
    694                 }
    695         }       
    696         h=maxdeg1(simplify(reduce(quotient(I,maxideal(1)),I),2))+1;
    697         for ( ii = n; ii> n-d+1; ii-- )
    698         {
    699                 sbi=subst(sbi,x(ii),0);
    700                 s = "ring mr = ",charstr(r0),",x(0..ii-1),dp;";
    701                 execute(s);
    702                 ideal sbi,I,L,K,T;
    703                 map phi;
    704                 sbi=imap(r1,sbi);
    705                 I=simplify(lead(std(sbi)),1);
    706                 attrib(I,"isSB",1);
    707                 K=subst(select(I,ii),x(ii-1),1);
    708                 K=K*maxideal(maxdeg1(I));
    709                 if (size(reduce(K,I)) <> 0)
    710                 {
    711                         nl=0;
    712                         while ( nl < 30 )
    713                         {
    714                                 nl=nl+1;
    715                                 L=randomLast(100);
    716                                 phi=mr,L;
    717                                 T=phi(sbi);
    718                                 I=simplify(lead(std(T)),1);
    719                                 attrib(I,"isSB",1);
    720                                 K=subst(select(I,ii),x(ii-1),1);
    721                                 K=K*maxideal(maxdeg1(I));
    722                                 if (size(reduce(K,I)) == 0)
    723                                 {
    724                                         sbi=T;
    725                                         break;
    726                                 }
    727                         }       
    728                 }
    729                 H=maxdeg1(simplify(reduce(quotient(I,maxideal(1)),I),2))+1;
    730                 if (H > h)
    731                 {
    732                         h=H;
    733                 }
    734                 setring r1;
    735                 sbi=fetch(mr,sbi);
    736                 kill mr;
    737         }
    738    sbi=subst(sbi,x(n-d+1),0);
    739    s = "ring mr = ",charstr(r0),",x(0..n-d),dp;";       
    740    execute(s);
    741    ideal sbi,I,L,K,T;
    742    map phi;
    743    sbi=imap(r1,sbi);
    744    I=simplify(lead(std(sbi)),1);
    745    attrib(I,"isSB",1);
    746    H=maxdeg1(simplify(reduce(quotient(I,maxideal(1)),I),2))+1;
    747    if (H > h)
    748    {
    749         h=H;
    750    }
    751    dbprint(2,"reg(i)=" + string(h) + " and the time of this computation: " + string(rtimer-time) + " sec./100");
    752    return();
    753    }
     544  if ( homog(sbi) == 0 )
     545  {
     546    "// The ideal is not homogeneous!";
     547    return (-1);
     548  }
     549  I=simplify(lead(sbi),1);
     550  attrib(I,"isSB",1);
     551  d=dim(I);
     552  if (char(r1) > 0 and d == 0)
     553  {
     554    def r2=changechar("0",r1);
     555    setring r2;
     556    ideal sbi,I,i,K,T;
     557    map phi;
     558    I = fetch(r1,I);
     559    i=I;
     560    attrib(I,"isSB",1);
     561  }
     562  else
     563  {
     564    def r2=changechar(charstr(r1),r1);
     565    setring r2;
     566    ideal sbi,I,i,K,T,ic,Ic;
     567    map phi;
     568    I = imap(r1,I);
     569    Ic=I;
     570    attrib(I,"isSB",1);
     571    i = imap(r1,i);
     572    ic=i;
     573  }
     574  K=select(I,n+1);
     575  if (size(K) == 0)
     576  {
     577    h=0;
     578  }
     579  else
     580  {
     581    if (Test(I) == 1)
     582    {
     583      h=maxdeg1(K);
     584    }
     585    else
     586    {       
     587      while ( nl < 30 )
     588      {
     589        nl=nl+1;
     590        phi=r2,randomLast(100);
     591        T=phi(i);
     592        I=simplify(lead(std(T)),1);
     593        attrib(I,"isSB",1);
     594        K=select(I,n+1);
     595        if (size(K) == 0)
     596        {
     597          h=0;break;
     598        }
     599        if (Test(I) == 1 )
     600        {
     601          h=maxdeg1(K);break;
     602        }
     603      }
     604      i=T;
     605    }
     606  }
     607  for ( ii = n; ii>=n-d+1; ii-- )
     608  {
     609    i=subst(i,x(ii),0);
     610    s = "ring mr = ",charstr(r1),",x(0..ii-1),dp;";       
     611    execute(s);
     612    ideal i,sbi,I,J,K,L,T;
     613    poly P;
     614    map phi;
     615    i=imap(r2,i);
     616    I=simplify(lead(std(i)),1);
     617    attrib(I,"isSB",1);
     618    K=select(I,ii);
     619    if (size(K) == 0)
     620    {
     621      H=0;
     622    }
     623    else
     624    {
     625      if (Test(I) == 1)
     626      {
     627        H=maxdeg1(K);
     628      }
     629      else
     630      {
     631        while ( nl < 30 )
     632        {
     633          nl=nl+1;       
     634          phi=mr,randomLast(100);
     635          T=phi(i);
     636          I=simplify(lead(std(T)),1);
     637          attrib(I,"isSB",1);
     638          K=select(I,ii);
     639          if (size(K) == 0)
     640          {
     641            H=0;break;
     642          }
     643          if (Test(I) == 1 )
     644          {
     645            H=maxdeg1(K);break;
     646          }
     647        }
     648        setring r2;
     649        i=imap(mr,T);
     650        kill mr;
     651      }
     652    }
     653    if (H > h)
     654    {
     655      h=H;
     656    }
     657  }
     658  if (nl < 30)
     659  {       
     660    dbprint(2,"reg(i)=" + string(h) + " and the time of this computation: " + string(rtimer-time) + " sec./100");
     661    return();
     662  }
     663  else
     664  {
     665    I=Ic;
     666    attrib(I,"isSB",1);
     667    i=ic;
     668    K=subst(select(I,n+1),x(n),1);
     669    K=K*maxideal(maxdeg1(I));
     670    if (size(reduce(K,I)) <> 0)
     671    {
     672      nl=0;
     673      while ( nl < 30 )
     674      {
     675        nl=nl+1;
     676        phi=r1,randomLast(100);
     677        sbi=phi(i);
     678        I=simplify(lead(std(sbi)),1);
     679        attrib(I,"isSB",1);
     680        K=subst(select(I,n+1),x(n),1);
     681        K=K*maxideal(maxdeg1(I));
     682        if (size(reduce(K,I)) == 0)
     683        {
     684          break;
     685        }
     686      }
     687    }       
     688    h=maxdeg1(simplify(reduce(quotient(I,maxideal(1)),I),2))+1;
     689    for ( ii = n; ii> n-d+1; ii-- )
     690    {
     691      sbi=subst(sbi,x(ii),0);
     692      s = "ring mr = ",charstr(r0),",x(0..ii-1),dp;";       
     693      execute(s);
     694      ideal sbi,I,L,K,T;
     695      map phi;
     696      sbi=imap(r1,sbi);
     697      I=simplify(lead(std(sbi)),1);
     698      attrib(I,"isSB",1);
     699      K=subst(select(I,ii),x(ii-1),1);
     700      K=K*maxideal(maxdeg1(I));
     701      if (size(reduce(K,I)) <> 0)
     702      {
     703        nl=0;
     704        while ( nl < 30 )
     705        {
     706          nl=nl+1;
     707          L=randomLast(100);
     708          phi=mr,L;
     709          T=phi(sbi);
     710          I=simplify(lead(std(T)),1);
     711          attrib(I,"isSB",1);
     712          K=subst(select(I,ii),x(ii-1),1);
     713          K=K*maxideal(maxdeg1(I));
     714          if (size(reduce(K,I)) == 0)
     715          {
     716            sbi=T;
     717            break;
     718          }
     719        }       
     720      }
     721      H=maxdeg1(simplify(reduce(quotient(I,maxideal(1)),I),2))+1;
     722      if (H > h)
     723      {
     724        h=H;
     725      }
     726      setring r1;
     727      sbi=fetch(mr,sbi);
     728      kill mr;
     729    }
     730    sbi=subst(sbi,x(n-d+1),0);
     731    s = "ring mr = ",charstr(r0),",x(0..n-d),dp;";       
     732    execute(s);
     733    ideal sbi,I,L,K,T;
     734    map phi;
     735    sbi=imap(r1,sbi);
     736    I=simplify(lead(std(sbi)),1);
     737    attrib(I,"isSB",1);
     738    H=maxdeg1(simplify(reduce(quotient(I,maxideal(1)),I),2))+1;
     739    if (H > h)
     740    {
     741      h=H;
     742    }
     743    dbprint(2,"reg(i)=" + string(h) + " and the time of this computation: " + string(rtimer-time) + " sec./100");
     744    return();
     745  }
    754746}
    755747
     
    757749//
    758750proc mreg (ideal i)
    759 "
    760 USAGE:   mreg (i); i ideal
    761 RETURN:  an integer, the Castelnuovo-Mumford regularity of i.
     751"USAGE:  mreg (i); i ideal
     752RETURN:  an integer, the Castelnuovo-Mumford regularity of i.
    762753         (returns -1 if i is not homogeneous)
    763754ASSUME:  i is a homogeneous ideal and the characteristic of base field is zero..
    764 NOTE:    This is a probabilistic procedure, and it computes the initial of the ideal modulo the prime number 2147483647 (the biggest prime less than 2^31).
     755NOTE:    This is a probabilistic procedure, and it computes the initial of the ideal modulo the prime number 2147483647 (the biggest prime less than 2^31).
    765756"
    766757{
    767758//--------------------------- initialisation ---------------------------------
    768        "// WARNING: The characteristic of base field musr be zero.
    769 // This procedure is probabilistic and  it computes the initial 
     759  "// WARNING: The characteristic of base field musr be zero.
     760// This procedure is probabilistic and  it computes the initial
    770761//ideals modulo the prime number 2147483647";
    771    int e,ii,jj,H,h,d,time,p,nl;
    772    def r0 = basering;
    773    int n = nvars(r0)-1;
    774    string s = "ring r1 = ",charstr(r0),",x(0..n),dp;";
    775    execute(s);
    776    ideal i,sbi,I,J,K,L,lsbi1,lsbi2;
    777    list #;
    778    poly P;
    779    map phi;
    780    i = fetch(r0,i);
    781    time=rtimer;
    782    system("--ticks-per-sec",100);
     762  int e,ii,jj,H,h,d,time,p,nl;
     763  def r0 = basering;
     764  int n = nvars(r0)-1;
     765  string s = "ring r1 = ",charstr(r0),",x(0..n),dp;";
     766  execute(s);
     767  ideal i,sbi,I,J,K,L,lsbi1,lsbi2;
     768  list #;
     769  poly P;
     770  map phi;
     771  i = fetch(r0,i);
     772  time=rtimer;
     773  system("--ticks-per-sec",100);
    783774//----- Check ideal homogeneous
    784    if ( homog(i) == 0 )
    785    {
    786        "// The ideal is not homogeneous!";
    787        return (-1);
    788    }
    789    option(redSB);
    790    p=2147483647;
    791    #=ringlist(r1);
    792    #[1]=p;
    793    def oro=ring(#);
    794    setring oro;
    795    ideal sbi,lsbi;
    796    sbi=fetch(r1,i);
    797    lsbi=lead(std(sbi));
    798    setring r1;
    799    lsbi1=fetch(oro,lsbi);
    800    lsbi1=simplify(lsbi1,1);
    801    attrib(lsbi1,"isSB",1);
    802    kill oro;
    803    I=lsbi1;
    804    d=dim(I);
    805    K=select(I,n+1);
    806    if (size(K) == 0)
    807    {
    808         h=0;
    809    }
    810    else
    811    {
    812         if (Test(I) == 1)
    813         {
    814                 h=maxdeg1(K);
    815         }
    816         else
    817         {
    818                 while ( nl < 30 )
    819                 {
    820                         nl=nl+1;       
    821                         phi=r1,randomLast(100);
    822                         sbi=phi(i);
    823                         #=ringlist(r1);
    824                         #[1]=p;
    825                         def oro=ring(#);
    826                         setring oro;
    827                         ideal sbi,lsbi;
    828                         sbi=fetch(r1,sbi);
    829                         lsbi=lead(std(sbi));
    830                         setring r1;
    831                         lsbi1=fetch(oro,lsbi);
    832                         lsbi1=simplify(lsbi1,1);
    833                         attrib(lsbi1,"isSB",1);
    834                         kill oro;
    835                         I=lsbi1;
    836                         K=select(I,n+1);
    837                         if (size(K) == 0)
    838                         {
    839                                 h=0;break
    840                         }
    841                         if (Test(I) == 1 )
    842                         {
    843                                 h=maxdeg1(K);break;
    844                         }
    845                 }
    846                 i=sbi;
    847         }
    848    }
    849    for ( ii = n; ii>=n-d+1; ii-- )
    850    {
    851         i=subst(i,x(ii),0);
    852         s = "ring mr = ","0",",x(0..ii-1),dp;";
    853         execute(s);
    854         ideal i,sbi,I,J,K,L,lsbi1;
    855         poly P;
    856         list #;
    857         map phi;
    858         i=imap(r1,i);
    859         #=ringlist(mr);
    860         #[1]=p;
    861         def oro=ring(#);
    862         setring oro;
    863         ideal sbi,lsbi;
    864         sbi=fetch(mr,i);
    865         lsbi=lead(std(sbi));
    866         setring mr;
    867         lsbi1=fetch(oro,lsbi);
    868         lsbi1=simplify(lsbi1,1);
    869         attrib(lsbi1,"isSB",1);
    870         kill oro;
    871         I=lsbi1;
    872         K=select(I,ii);
    873         if (size(K) == 0)
    874         {
    875                 H=0;
    876         }
    877         else
    878         {
    879                 if (Test(I) == 1)
    880                 {
    881                         H=maxdeg1(K);
    882                 }
    883                 else
    884                 {
    885                         nl=0;
    886                         while ( nl < 30 )
    887                         {
    888                                 nl=nl+1;       
    889                                 phi=mr,randomLast(100);
    890                                 sbi=phi(i);
    891                                 #=ringlist(mr);
    892                                 #[1]=p;
    893                                 def oro=ring(#);
    894                                 setring oro;
    895                                 ideal sbi,lsbi;
    896                                 sbi=fetch(mr,sbi);
    897                                 lsbi=lead(std(sbi));
    898                                 setring mr;
    899                                 lsbi1=fetch(oro,lsbi);
    900                                 lsbi1=simplify(lsbi1,1);
    901                                 kill oro;
    902                                 I=lsbi1;
    903                                 attrib(I,"isSB",1);
    904                                 K=select(I,ii);
    905                                 if (size(K) == 0)
    906                                 {
    907                                         H=0;break;
    908                                 }
    909                                 if (Test(I) == 1 )
    910                                 {
    911                                         H=maxdeg1(K);break;
    912                                 }
    913                         }
    914                         setring r1;
    915                         i=imap(mr,sbi);
    916                         kill mr;
    917                 }
    918         }
    919         if (H > h)
    920         {
    921                 h=H;
    922         }
    923    }
    924 dbprint(2,"mreg(i)=" + string(h) + " and the time of this computation: " + string(rtimer-time) + "sec./100");
    925 return();
    926 }
    927 
    928 
    929 
    930 
    931 
    932 
     775  if ( homog(i) == 0 )
     776  {
     777    "// The ideal is not homogeneous!";
     778    return (-1);
     779  }
     780  option(redSB);
     781  p=2147483647;
     782  #=ringlist(r1);
     783  #[1]=p;
     784  def oro=ring(#);
     785  setring oro;
     786  ideal sbi,lsbi;
     787  sbi=fetch(r1,i);
     788  lsbi=lead(std(sbi));
     789  setring r1;
     790  lsbi1=fetch(oro,lsbi);
     791  lsbi1=simplify(lsbi1,1);
     792  attrib(lsbi1,"isSB",1);
     793  kill oro;
     794  I=lsbi1;
     795  d=dim(I);
     796  K=select(I,n+1);
     797  if (size(K) == 0)
     798  {
     799    h=0;
     800  }
     801  else
     802  {
     803    if (Test(I) == 1)
     804    {
     805      h=maxdeg1(K);
     806    }
     807    else
     808    {
     809      while ( nl < 30 )
     810      {
     811        nl=nl+1;       
     812        phi=r1,randomLast(100);
     813        sbi=phi(i);
     814        #=ringlist(r1);
     815        #[1]=p;
     816        def oro=ring(#);
     817        setring oro;
     818        ideal sbi,lsbi;
     819        sbi=fetch(r1,sbi);
     820        lsbi=lead(std(sbi));
     821        setring r1;
     822        lsbi1=fetch(oro,lsbi);
     823        lsbi1=simplify(lsbi1,1);
     824        attrib(lsbi1,"isSB",1);
     825        kill oro;
     826        I=lsbi1;
     827        K=select(I,n+1);
     828        if (size(K) == 0)
     829        {
     830          h=0;break;
     831        }
     832        if (Test(I) == 1 )
     833        {
     834          h=maxdeg1(K);break;
     835        }
     836      }
     837      i=sbi;
     838    }
     839  }
     840  for ( ii = n; ii>=n-d+1; ii-- )
     841  {
     842    i=subst(i,x(ii),0);
     843    s = "ring mr = ","0",",x(0..ii-1),dp;";       
     844    execute(s);
     845    ideal i,sbi,I,J,K,L,lsbi1;
     846    poly P;
     847    list #;
     848    map phi;
     849    i=imap(r1,i);
     850    #=ringlist(mr);
     851    #[1]=p;
     852    def oro=ring(#);
     853    setring oro;
     854    ideal sbi,lsbi;
     855    sbi=fetch(mr,i);
     856    lsbi=lead(std(sbi));
     857    setring mr;
     858    lsbi1=fetch(oro,lsbi);
     859    lsbi1=simplify(lsbi1,1);
     860    attrib(lsbi1,"isSB",1);
     861    kill oro;
     862    I=lsbi1;
     863    K=select(I,ii);
     864    if (size(K) == 0)
     865    {
     866      H=0;
     867    }
     868    else
     869    {
     870      if (Test(I) == 1)
     871      {
     872        H=maxdeg1(K);
     873      }
     874      else
     875      {
     876        nl=0;
     877        while ( nl < 30 )
     878        {
     879          nl=nl+1;       
     880          phi=mr,randomLast(100);
     881          sbi=phi(i);
     882          #=ringlist(mr);
     883          #[1]=p;
     884          def oro=ring(#);
     885          setring oro;
     886          ideal sbi,lsbi;
     887          sbi=fetch(mr,sbi);
     888          lsbi=lead(std(sbi));
     889          setring mr;
     890          lsbi1=fetch(oro,lsbi);
     891          lsbi1=simplify(lsbi1,1);
     892          kill oro;
     893          I=lsbi1;
     894          attrib(I,"isSB",1);
     895          K=select(I,ii);
     896          if (size(K) == 0)
     897          {
     898            H=0;break;
     899          }
     900          if (Test(I) == 1 )
     901          {
     902            H=maxdeg1(K);break;
     903          }
     904        }
     905        setring r1;
     906        i=imap(mr,sbi);
     907        kill mr;
     908      }
     909    }
     910    if (H > h)
     911    {
     912      h=H;
     913    }
     914  }
     915  dbprint(2,"mreg(i)=" + string(h) + " and the time of this computation: " + string(rtimer-time) + "sec./100");
     916  return();
     917}
     918/*
    933919//////////////////////////////////////////////////////////////
    934920example
     
    1010996ideal i=af+bg+ch+dv+ew-1/2, a2f+b2g+c2h+d2v+e2w-1/3,tdw+agk+ahl+bhm+avn+bvo+cvp+awq+bwu+cws-1/6, a3f+b3g+c3h+d3v+e3w-1/4, tdew+abgk+achl+bchm+advn+bdvo+cdvp+aewq+bewu+cews-1/8, td2w+a2gk+a2hl+b2hm+a2vn+b2vo+c2vp+a2wq+b2wu+c2ws-1/12, ahkm+tawn+tbwo+avko+tcwp+avlp+bvmp+awku+awls+bwms-1/24, a4f+b4g+c4h+d4v+e4w-1/5, tde2w+ab2gk+ac2hl+bc2hm+ad2vn+bd2vo+cd2vp+ae2wq+be2wu+ce2ws-1/10, td2ew+a2bgk+a2chl+b2chm+a2dvn+b2dvo+c2dvp+a2ewq+b2ewu+c2ews-1/15,achkm+taewn+tbewo+advko+tcewp+advlp+bdvmp+aewku+aewls+bewms-1/30,t2d2w+a2gk2+a2hl2+2abhlm+b2hm2+a2vn2+2abvno+b2vo2+2acvnp+2bcvop+c2vp2+2tadwq+a2wq2+2tbdwu+2abwqu+b2wu2+2tcdws+2acwqs+2bcwus+c2ws2-1/20,td3w+a3gk+a3hl+b3hm+a3vn+b3vo+c3vp+a3wq+b3wu+c3ws-1/20,abhkm+tadwn+tbdwo+abvko+tcdwp+acvlp+bcvmp+abwku+acwls+bcwms-1/40,a2hkm+ta2wn+tb2wo+a2vko+tc2wp+a2vlp+b2vmp+a2wku+a2wls+b2wms-1/60,tawko+tawlp+tbwmp+avkmp+awkms-1/20;
    1011997}
    1012 
     998*/
Note: See TracChangeset for help on using the changeset viewer.