Changeset fcc6e7 in git


Ignore:
Timestamp:
Aug 8, 2019, 4:34:26 PM (4 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', '0604212ebb110535022efecad887940825b97c3f')
Children:
b258e2adb78434353acc85388a6c40c626c4b5ee
Parents:
b9047993db2a41c461ef3804d12554bce0d561fb
Message:
format
Location:
Singular/LIB
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/JMBTest.lib

    rb90479 rfcc6e7  
    107107int aJ=deg(f.h);
    108108// minimal degree of polynomials in G
    109 //print(aJ);
    110109list V=list();
    111110V[1]=Terns(G,1);
    … …  
    227226//Compare degrees;
    228227      d=-1;
    229       //print("Per Grado");
    230228     }
    231229  if(deg(P.h)==deg(Q.h))
    … …  
    237235//head=tail
    238236               d=0;
    239                //print("Uguali");
    240237              }
    241238         }
    … …  
    495492       }
    496493   I=M[1..size(M)];
    497 //print("IdealOfV");
    498494  //I=std(I);
    499495  }
    … …  
    538534EXAMPLE:  example NewWeight; shows an example"
    539535{
    540 //multiply and reduce, degree by degree
    541 intvec u=NewWeight(nvars(r)+1);
    542 list L=ringlist(r);
    543 L[2]=insert(L[2],"t",size(L[2]));
    544 //print(L[2]);
    545 list ordlist="a",u;
    546 L[3]=insert(L[3],ordlist,0);
    547 def H=ring(L);
    548 //print(V1);
    549 //print(G1);
    550 list M=list();
    551 jmp p;
    552 list N;
    553 poly q;
    554 poly s;
    555 int i;
    556 int j;
    557 for(i=1; i<=size(G1); i++)
    558    {
    559            N=list();
    560            for(j=1; j<=size(G1[i]); j++)
    561               {
    562                 p=G1[i][j];
    563                 q=p.h;
    564                 s=p.t;
    565                 N[j]=list(q,s);
    566                }
    567            M[i]=N;
    568     }
    569 p.h=poly(0);
    570 p.t=poly(0);
    571 setring H;
    572 list R=list();
    573 list S=list();
    574 //print("anello definito");
    575 def V=imap(r,V1);
    576 //def G=imap(r,G1);
    577 //print(V);
    578 def MM=imap(r,M);
    579 list G=list();
    580 list N=list();
    581 for(i=1; i<=size(MM); i++)
    582    {
    583            for(j=1; j<=size(MM[i]); j++)
    584               {
    585                 p.h=MM[i][j][1];
    586                 p.t=MM[i][j][2];
    587                 N[j]=p;
    588                }
    589            G[i]=N;
    590     }
    591 ideal I=0;
    592 jmp LL;
    593 jmp UU;
    594  for(i=1; i<=size(V);i++)
    595     {
    596        R[i]=list();
    597        S[i]=list();
    598        I=0;
    599        for(j=1;j<=size(V[i]); j++)
    600           {
    601             LL=Multiply(V[i][j],G);
    602             LL.t=reduce(t*LL.t,I);
    603 //I only reduce the tail
    604               LL.t=subst(LL.t,t,1);
    605               S[i]=insert(S[i],LL,size(S[i]));
    606               LL.h=t*LL.h;
    607             R[i]=insert(R[i],LL,size(R[i]));
    608              UU=R[i][j];
    609               I=I+ideal(UU.h+UU.t);
    610               attrib(I,"isSB",1);
    611           }
    612     }
    613 list M=list();
    614 poly q;
    615 poly s;
    616 for(i=1; i<=size(S); i++)
    617    {
    618            N=list();
    619            for(j=1; j<=size(S[i]); j++)
    620               {
    621                 p=S[i][j];
    622                 q=p.h;
    623                 s=p.t;
    624                 N[j]=list(q,s);
    625                }
    626            M[i]=N;
    627     }
    628 p.h=poly(0);
    629 p.t=poly(0);
    630 setring r;
    631 def MM=imap(H,M);
    632 list MMM=list();
    633 for(i=1; i<=size(MM); i++)
    634    {
    635            N=list();
    636            for(j=1; j<=size(MM[i]); j++)
    637               {
    638                 p.h=MM[i][j][1];
    639                 p.t=MM[i][j][2];
    640                 N[j]=p;
    641                }
    642            MMM[i]=N;
    643     }
    644 return(MMM);
    645 }
    646 example
    647 { "EXAMPLE:"; echo = 2;
    648  ring r=0, (x,y,z), rp;
    649 jmp r1;
    650 r1.h=z^3;
    651 r1.t=poly(0);
    652 jmp r2;
    653 r2.h=z^2*y;
    654 r2.t=poly(0);
    655 jmp r3;
    656 r3.h=z*y^2 ;
    657 r3.t=-x^2*y;
    658 jmp r4;
    659 r4.h=y^5;
    660 r4.t=poly(0);
    661 list G2F=list(list(r1,r2,r3),list(r4));
     536  //multiply and reduce, degree by degree
     537  intvec u=NewWeight(nvars(r)+1);
     538  list L=ringlist(r);
     539  L[2]=insert(L[2],"t",size(L[2]));
     540  list ordlist="a",u;
     541  L[3]=insert(L[3],ordlist,0);
     542  def H=ring(L);
     543  list M=list();
     544  jmp p;
     545  list N;
     546  poly q;
     547  poly s;
     548  int i;
     549  int j;
     550  for(i=1; i<=size(G1); i++)
     551  {
     552    N=list();
     553    for(j=1; j<=size(G1[i]); j++)
     554    {
     555      p=G1[i][j];
     556      q=p.h;
     557      s=p.t;
     558      N[j]=list(q,s);
     559    }
     560    M[i]=N;
     561  }
     562  p.h=poly(0);
     563  p.t=poly(0);
     564  setring H;
     565  list R=list();
     566  list S=list();
     567  //print("anello definito");
     568  def V=imap(r,V1);
     569  //def G=imap(r,G1);
     570  //print(V);
     571  def MM=imap(r,M);
     572  list G=list();
     573  list N=list();
     574  for(i=1; i<=size(MM); i++)
     575  {
     576    for(j=1; j<=size(MM[i]); j++)
     577    {
     578      p.h=MM[i][j][1];
     579      p.t=MM[i][j][2];
     580      N[j]=p;
     581    }
     582    G[i]=N;
     583  }
     584  ideal I=0;
     585  jmp LL;
     586  jmp UU;
     587  for(i=1; i<=size(V);i++)
     588  {
     589    R[i]=list();
     590    S[i]=list();
     591    I=0;
     592    for(j=1;j<=size(V[i]); j++)
     593    {
     594      LL=Multiply(V[i][j],G);
     595      LL.t=reduce(t*LL.t,I);
     596      //I only reduce the tail
     597      LL.t=subst(LL.t,t,1);
     598      S[i]=insert(S[i],LL,size(S[i]));
     599      LL.h=t*LL.h;
     600      R[i]=insert(R[i],LL,size(R[i]));
     601      UU=R[i][j];
     602      I=I+ideal(UU.h+UU.t);
     603      attrib(I,"isSB",1);
     604    }
     605  }
     606  list M=list();
     607  poly q;
     608  poly s;
     609  for(i=1; i<=size(S); i++)
     610  {
     611    N=list();
     612    for(j=1; j<=size(S[i]); j++)
     613    {
     614      p=S[i][j];
     615      q=p.h;
     616      s=p.t;
     617      N[j]=list(q,s);
     618    }
     619    M[i]=N;
     620  }
     621  p.h=poly(0);
     622  p.t=poly(0);
     623  setring r;
     624  def MM=imap(H,M);
     625  list MMM=list();
     626  for(i=1; i<=size(MM); i++)
     627  {
     628    N=list();
     629    for(j=1; j<=size(MM[i]); j++)
     630    {
     631      p.h=MM[i][j][1];
     632      p.t=MM[i][j][2];
     633      N[j]=p;
     634    }
     635    MMM[i]=N;
     636  }
     637  return(MMM);
     638}
     639example
     640{ "EXAMPLE:"; echo = 2;
     641 ring r=0, (x,y,z), rp;
     642 jmp r1;
     643 r1.h=z^3;
     644 r1.t=poly(0);
     645 jmp r2;
     646 r2.h=z^2*y;
     647 r2.t=poly(0);
     648 jmp r3;
     649 r3.h=z*y^2 ;
     650 r3.t=-x^2*y;
     651 jmp r4;
     652 r4.h=y^5;
     653 r4.t=poly(0);
     654 list G2F=list(list(r1,r2,r3),list(r4));
    662655 FinalVm(VConst(G2F,6,r) , G2F, r);
    663656}
    … …  
    671664list V=list();
    672665V= VConst(G,c);
    673 //print("VConst");
    674666//V non ordered
    675667list L=list();
    … …  
    719711//L will contain results
    720712poly h=Minimus(variables(A.h));
    721 //print(h);
    722713int l=findvars(h,1)[2][1];
    723714if(l!=nvars(basering))
    724715 {
    725 //print("vero");
    726 //print(l);
    727716  for(int j=l+1;j<=nvars(basering); j++)
    728717   {
    729     //print("entrata");
    730     //print(var(j));
    731718    E=var(j)*A.h/B.h;
    732719//Candidate for * product
    733     //print(E);
    734720    if(E!=0)
    735721      {
    … …  
    789775//Loop on polynomials
    790776                        C=EKCouples(G[i][j], G[k][l]);
    791 //print("coppia");
    792777                        if(C[2]!=0)
    793778                          {
    … …  
    865850True=1/False=0
    866851EXAMPLE:  example TestJMark; shows an example"
    867 {int flag=1;
    868 if(size(G1)==1 && size(G1[1])==1)
    869  {
    870   //Hypersurface
    871   print("Only One Polynomial");
    872   flag=1;
    873  }
    874 else
    875   {
    876    int d=0;
    877    list EK,D=EKPolys(G1);
    878 //print("PolysEK");
    879    //I found EK couples
    880    int massimo=Max(D);
    881    list V1=ConstructorMain(G1,massimo,r);
    882 //print("Costruttore");
    883 //print(V1);
    884    jmp mi=V1[1][1];
    885    int minimo=Min(deg(mi.h));
    886    intvec u=NewWeight(nvars(r)+1);
    887 list L=ringlist(r);
    888 L[2]=insert(L[2],"t",size(L[2]));
    889 //print(L[2]);
    890 list ordlist="a",u;
    891 L[3]=insert(L[3],ordlist,0);
    892 def H=ring(L);
    893 list JJ=list();
    894 jmp pp;
    895 jmp qq;
    896 int i;
    897 int j;
    898 list NN;
    899 for(i=size(V1);i>0;i--)
    900     {
    901      NN=list();
    902      for(j=size(V1[i]);j>0;j--)
    903          {
    904           //print(j);
    905           pp=V1[i][j];
    906           NN[j]=list(pp.h,pp.t);
    907           }
    908 //print(NN);
    909 JJ[i]=NN;
    910 //print(JJ[i]);
    911 //print(i);
    912     }
    913 //print(JJ);
    914 list KK=list();
    915 list UU=list();
    916 //jmp qq;
    917 for(i=size(G1);i>0;i--)
    918     {
    919      for(j=size(G1[i]);j>0;j--)
    920          {
    921           //print(j);
    922           qq=G1[i][j];
    923           UU[j]=list(qq.h,qq.t);
    924           }
    925 //print(UU);
    926 KK[i]=UU;
    927     }
    928 setring H;
    929 //I defined the new ring with the weighted
    930 //variable t
    931 poly p;
    932 //print("anello definito");
    933 def JJJ=imap(r,JJ);
    934 def EK=imap(r,EK);
    935 //print(flag);
    936 //imap(r,D);
    937 list V=list();
    938 jmp fp;
    939 //int i;
    940 //int j;
    941 list N;
    942 for(i=size(JJJ); i>0; i--)
    943    {
    944            N=list();
    945            for(j=size(JJJ[i]); j>0; j--)
    946               {
    947                 fp.h=JJJ[i][j][1];
    948                 fp.t=JJJ[i][j][2];
    949                 N[j]=fp;
    950                }
    951            V[i]=N;
    952             }
    953 //print(V);
    954 def KKJ=imap(r,KK);
    955 list G=list();
    956 list U=list();
    957 for(i=1; i<=size(KKJ); i++)
    958    {
    959            for(j=1; j<=size(KKJ[i]); j++)
    960               {
    961                 fp.h=KKJ[i][j][1];
    962                 fp.t=KKJ[i][j][2];
    963                 U[j]=fp;
    964                }
    965            G[i]=U;
    966     }
    967 // print(V);
    968 //print(G);
    969 //I imported in H everithing I need
    970 poly q;
    971 ideal I;
    972    for(j=1; j<=size(EK);j++)
     852{
     853  int flag=1;
     854  if(size(G1)==1 && size(G1[1])==1)
     855  {
     856    //Hypersurface
     857    print("Only One Polynomial");
     858    flag=1;
     859  }
     860  else
     861  {
     862    int d=0;
     863    list EK,D=EKPolys(G1);
     864    //I found EK couples
     865    int massimo=Max(D);
     866    list V1=ConstructorMain(G1,massimo,r);
     867    jmp mi=V1[1][1];
     868    int minimo=Min(deg(mi.h));
     869    intvec u=NewWeight(nvars(r)+1);
     870    list L=ringlist(r);
     871    L[2]=insert(L[2],"t",size(L[2]));
     872    list ordlist="a",u;
     873    L[3]=insert(L[3],ordlist,0);
     874    def H=ring(L);
     875    list JJ=list();
     876    jmp pp;
     877    jmp qq;
     878    int i;
     879    int j;
     880    list NN;
     881    for(i=size(V1);i>0;i--)
     882    {
     883      NN=list();
     884      for(j=size(V1[i]);j>0;j--)
    973885      {
    974        d=D[j];
    975        p=EKPolynomials(EK[j],G);
    976        //print("arrivo");
    977        I=IdealOfV(V[d-minimo+1]);
    978 attrib(I,"isSB",1);
    979 //print(I);
    980 q=reduce(t*p,I);
    981 //print(I[1]);
    982 //print(t*p);
    983 q=subst(q,t,1);
    984 //I reduce all the EK polynomials
    985 //       q=RiduzPoly(V[d-minimo+1], p);
    986        if(q!=0)
    987          {
    988 //check whether reduction is 0
    989           print("NOT A BASIS");
    990          flag=0;
    991           break;
    992          }
    993      }
    994   }
    995 //print(flag);
    996 setring r;
    997 //typeof(flag);
    998 return(flag);
    999 }
    1000 example
    1001 { "EXAMPLE:"; echo = 2;
    1002  ring r=0, (x,y,z), rp;
    1003 jmp r1;
    1004 r1.h=z^3;
    1005 r1.t=poly(0);
    1006 jmp r2;
    1007 r2.h=z^2*y;
    1008 r2.t=poly(0);
    1009 jmp r3;
    1010 r3.h=z*y^2 ;
    1011 r3.t=-x^2*y;
    1012 jmp r4;
    1013 r4.h=y^5;
    1014 r4.t=poly(0);
    1015 list G2F=list(list(r1,r2,r3),list(r4));
    1016 TestJMark(G2F,r);
    1017 }
     886        pp=V1[i][j];
     887        NN[j]=list(pp.h,pp.t);
     888      }
     889      JJ[i]=NN;
     890    }
     891    list KK=list();
     892    list UU=list();
     893    //jmp qq;
     894    for(i=size(G1);i>0;i--)
     895    {
     896      for(j=size(G1[i]);j>0;j--)
     897      {
     898        qq=G1[i][j];
     899        UU[j]=list(qq.h,qq.t);
     900      }
     901      KK[i]=UU;
     902    }
     903    setring H;
     904    //I defined the new ring with the weighted
     905    //variable t
     906    poly p;
     907    //print("anello definito");
     908    def JJJ=imap(r,JJ);
     909    def EK=imap(r,EK);
     910    list V=list();
     911    jmp fp;
     912    //int i;
     913    //int j;
     914    list N;
     915    for(i=size(JJJ); i>0; i--)
     916    {
     917      N=list();
     918      for(j=size(JJJ[i]); j>0; j--)
     919      {
     920        fp.h=JJJ[i][j][1];
     921        fp.t=JJJ[i][j][2];
     922        N[j]=fp;
     923      }
     924      V[i]=N;
     925    }
     926    def KKJ=imap(r,KK);
     927    list G=list();
     928    list U=list();
     929    for(i=1; i<=size(KKJ); i++)
     930    {
     931      for(j=1; j<=size(KKJ[i]); j++)
     932      {
     933        fp.h=KKJ[i][j][1];
     934        fp.t=KKJ[i][j][2];
     935        U[j]=fp;
     936      }
     937      G[i]=U;
     938    }
     939    //I imported in H everithing I need
     940    poly q;
     941    ideal I;
     942    for(j=1; j<=size(EK);j++)
     943    {
     944      d=D[j];
     945      p=EKPolynomials(EK[j],G);
     946      I=IdealOfV(V[d-minimo+1]);
     947      attrib(I,"isSB",1);
     948      q=reduce(t*p,I);
     949      q=subst(q,t,1);
     950      //I reduce all the EK polynomials
     951      //       q=RiduzPoly(V[d-minimo+1], p);
     952      if(q!=0)
     953      {
     954        //check whether reduction is 0
     955        print("NOT A BASIS");
     956        flag=0;
     957        break;
     958      }
     959    }
     960  }
     961  setring r;
     962  //typeof(flag);
     963  return(flag);
     964}
     965example
     966{ "EXAMPLE:"; echo = 2;
     967 ring r=0, (x,y,z), rp;
     968 jmp r1;
     969 r1.h=z^3;
     970 r1.t=poly(0);
     971 jmp r2;
     972 r2.h=z^2*y;
     973 r2.t=poly(0);
     974 jmp r3;
     975 r3.h=z*y^2 ;
     976 r3.t=-x^2*y;
     977 jmp r4;
     978 r4.h=y^5;
     979 r4.t=poly(0);
     980 list G2F=list(list(r1,r2,r3),list(r4));
     981 TestJMark(G2F,r);
     982}

  • Singular/LIB/JMSConst.lib

    rb90479 rfcc6e7  
    176176int minimo=deg(m.h);
    177177int massimo=deg(M.h);
    178 //print(minimo);
    179 //print(massimo);
    180178int i=2;
    181179jmp qi;
    182180while(i<=size(Q))
    183181     {
    184        //print("entro nel ciclo");
    185        //print(i);
    186182       qi=Q[i][1];
    187183       if(deg(qi.h)!=minimo+1)
    188184         {
    189           //print("qui riempire");
    190           //print(i);
    191185          Q=insert(Q,list(),i-1);//Insert empty list for all intermediate degree between the minimum and the maximum, not having polynomials.
    192           //print(Q);
    193186         }
    194187       minimo=minimo+1;
    195188       i=i+1;
    196        //print("ora ho");
    197        //print(minimo);
    198        //print(i);
    199189     }
    200190return(Q);
    … …  
    250240          Q[i][j]=pp;
    251241          s=s+M[2];
    252           //print(s);
    253242        }
    254243    }
    … …  
    324313int aJ=deg(f.h);
    325314// minimal degree of polynomials in G
    326 //print(aJ);
    327315list V=list();
    328316V[1]=Terns(G,1);
    … …  
    353341             {
    354342                   p=G[V[m-1][j][2]][V[m-1][j][3]];
    355                   //print(p.h);
    356                   //print(p.t);
    357                   //print(var(i));
    358                   //print(Minimus(V[m-1][j][1]*p.h));
    359343               if(var(i)<=Minimus(variables(V[m-1][j][1]*p.h)))
    360344                  {
    361345//Can I multiply by the current variable?
    362                     //print("minoremin");
    363                     //print("fin qui ci sono");
    364                      //print(V[m-1][j][1]);
    365346                     OO=list(var(i)*V[m-1][j][1],V[m-1][j][2],V[m-1][j][3]);
    366347                    V[m]=insert(V[m], OO ,size(V[m]));
    … …  
    754735EXAMPLE:  example FinalVm; shows an example"
    755736{
    756 //multiply and reduce, degree by degree
    757 intvec u=NewWeight(nvars(r)+1);
    758 list L=ringlist(r);
    759 L[2]=insert(L[2],"t",size(L[2]));
    760 //print(L[2]);
    761 list ordlist="a",u;
    762 L[3]=insert(L[3],ordlist,0);
    763 def H=ring(L);
    764 //print(V1);
    765 //print(G1);
    766 list M=list();
    767 jmp p;
    768 list N;
    769 poly q;
    770 poly s;
    771 int i;
    772 int j;
    773 for(i=1; i<=size(G1); i++)
    774    {
    775            N=list();
    776            for(j=1; j<=size(G1[i]); j++)
    777               {
    778                 p=G1[i][j];
    779                 q=p.h;
    780                 s=p.t;
    781                 N[j]=list(q,s);
    782                }
    783            M[i]=N;
    784     }
    785 //print("M is");
    786 //print(M);
    787 p.h=poly(0);
    788 p.t=poly(0);
    789 setring H;
    790 list R=list();
    791 list S=list();
    792 //print("anello definito");
    793 list V=imap(r,V1);
    794 //def G=imap(r,G1);
    795 //print(V);
    796 list MM=imap(r,M);
    797 list G=list();
    798 list N=list();
    799 for(i=1; i<=size(MM); i++)
    800    {
    801            for(j=1; j<=size(MM[i]); j++)
    802               {
    803                 p.h=MM[i][j][1];
    804                 p.t=MM[i][j][2];
    805                 N[j]=p;
    806                }
    807            G[i]=N;
    808     }
    809 ideal I=0;
    810 jmp LL;
    811 jmp UU;
    812 //print("pronta x ridurre");
    813  for(i=1; i<=size(V);i++)
    814     {
    815 //print("sono a V di");
    816 //print(i);
    817        R[i]=list();
    818        S[i]=list();
    819        I=0;
    820               attrib(I,"isSB",1);
    821        for(j=1;j<=size(V[i]); j++)
    822           {
    823 //print(j);
    824 //print("esimo elem");
    825             LL=MultiplyJmP(V[i][j],G);
    826               LL.t=reduce(t*LL.t,I);
    827 //I only reduce the tail
    828 //print(LL.t);
    829               LL.t=subst(LL.t,t,1);
    830               S[i]=insert(S[i],LL,size(S[i]));
    831               LL.h=t*LL.h;
    832             R[i]=insert(R[i],LL,size(R[i]));
    833              UU=R[i][j];
    834               I=I+ideal(UU.h+UU.t);
    835               attrib(I,"isSB",1);
    836           }
    837     }
    838 //print("ho ridotto");
    839 list M=list();
    840 poly q;
    841 poly s;
    842 for(i=1; i<=size(S); i++)
    843    {
    844            N=list();
    845            for(j=1; j<=size(S[i]); j++)
    846               {
    847                 p=S[i][j];
    848                 q=p.h;
    849                 s=p.t;
    850                 N[j]=list(q,s);
    851                }
    852            M[i]=N;
    853     }
    854 p.h=poly(0);
    855 p.t=poly(0);
    856 setring r;
    857 def MM=imap(H,M);
    858 list MMM=list();
    859 for(i=1; i<=size(MM); i++)
    860    {
    861            N=list();
    862            for(j=1; j<=size(MM[i]); j++)
    863               {
    864                 p.h=MM[i][j][1];
    865                 p.t=MM[i][j][2];
    866                 N[j]=p;
    867                }
    868            MMM[i]=N;
    869     }
    870 return(MMM);
     737  //multiply and reduce, degree by degree
     738  intvec u=NewWeight(nvars(r)+1);
     739  list L=ringlist(r);
     740  L[2]=insert(L[2],"t",size(L[2]));
     741  list ordlist="a",u;
     742  L[3]=insert(L[3],ordlist,0);
     743  def H=ring(L);
     744  list M=list();
     745  jmp p;
     746  list N;
     747  poly q;
     748  poly s;
     749  int i;
     750  int j;
     751  for(i=1; i<=size(G1); i++)
     752  {
     753    N=list();
     754    for(j=1; j<=size(G1[i]); j++)
     755    {
     756      p=G1[i][j];
     757      q=p.h;
     758      s=p.t;
     759      N[j]=list(q,s);
     760    }
     761    M[i]=N;
     762  }
     763  p.h=poly(0);
     764  p.t=poly(0);
     765  setring H;
     766  list R=list();
     767  list S=list();
     768  //print("anello definito");
     769  list V=imap(r,V1);
     770  list MM=imap(r,M);
     771  list G=list();
     772  list N=list();
     773  for(i=1; i<=size(MM); i++)
     774  {
     775    for(j=1; j<=size(MM[i]); j++)
     776    {
     777      p.h=MM[i][j][1];
     778      p.t=MM[i][j][2];
     779      N[j]=p;
     780    }
     781    G[i]=N;
     782  }
     783  ideal I=0;
     784  jmp LL;
     785  jmp UU;
     786  //print("pronta x ridurre");
     787  for(i=1; i<=size(V);i++)
     788  {
     789    //print("sono a V di");
     790    //print(i);
     791    R[i]=list();
     792    S[i]=list();
     793    I=0;
     794    attrib(I,"isSB",1);
     795    for(j=1;j<=size(V[i]); j++)
     796    {
     797      //print(j);
     798      //print("esimo elem");
     799      LL=MultiplyJmP(V[i][j],G);
     800      LL.t=reduce(t*LL.t,I);
     801      //I only reduce the tail
     802      //print(LL.t);
     803      LL.t=subst(LL.t,t,1);
     804      S[i]=insert(S[i],LL,size(S[i]));
     805      LL.h=t*LL.h;
     806      R[i]=insert(R[i],LL,size(R[i]));
     807      UU=R[i][j];
     808      I=I+ideal(UU.h+UU.t);
     809      attrib(I,"isSB",1);
     810    }
     811  }
     812  //print("ho ridotto");
     813  list M=list();
     814  poly q;
     815  poly s;
     816  for(i=1; i<=size(S); i++)
     817  {
     818    N=list();
     819    for(j=1; j<=size(S[i]); j++)
     820    {
     821      p=S[i][j];
     822      q=p.h;
     823      s=p.t;
     824      N[j]=list(q,s);
     825    }
     826    M[i]=N;
     827  }
     828  p.h=poly(0);
     829  p.t=poly(0);
     830  setring r;
     831  def MM=imap(H,M);
     832  list MMM=list();
     833  for(i=1; i<=size(MM); i++)
     834  {
     835    N=list();
     836    for(j=1; j<=size(MM[i]); j++)
     837    {
     838      p.h=MM[i][j][1];
     839      p.t=MM[i][j][2];
     840      N[j]=p;
     841    }
     842    MMM[i]=N;
     843  }
     844  return(MMM);
    871845}
    872846example
    873847{ "EXAMPLE:"; echo = 2;
    874848 ring r=0, (x,y,z), rp;
    875 jmp r1;
    876 r1.h=z^3;
    877 r1.t=poly(0);
    878 jmp r2;
    879 r2.h=z^2*y;
    880 r2.t=poly(0);
    881 jmp r3;
    882 r3.h=z*y^2 ;
    883 r3.t=-x^2*y;
    884 jmp r4;
    885 r4.h=y^5;
    886 r4.t=poly(0);
    887 list G2F=list(list(r1,r2,r3),list(r4));
     849 jmp r1;
     850 r1.h=z^3;
     851 r1.t=poly(0);
     852 jmp r2;
     853 r2.h=z^2*y;
     854 r2.t=poly(0);
     855 jmp r3;
     856 r3.h=z*y^2 ;
     857 r3.t=-x^2*y;
     858 jmp r4;
     859 r4.h=y^5;
     860 r4.t=poly(0);
     861 list G2F=list(list(r1,r2,r3),list(r4));
    888862 FinalVm(VConst(G2F,6,r) , G2F, r);
    889863}
    … …  
    10931067EXAMPLE:  example SchemeEq; shows an example"
    10941068{
    1095 list Jms=list();
    1096 //ideal I;
    1097 list M=list();
    1098 jmp mini;
    1099 mini=W[1][1];
    1100 int minimo=deg(mini.h);
    1101 //multiply variables
    1102 poly pd=poly(1);
    1103 for(int i=1;i<=nvars(r);i++)
    1104 {pd=pd*var(i);}
    1105 //CHANGE RING
    1106 intvec u=NewWeight(nvars(r)+1);
    1107 list L=ringlist(r);
    1108 L[2]=insert(L[2],"t",size(L[2]));
    1109 //print(L[2]);
    1110 list ordlist="a",u;
    1111 L[3]=insert(L[3],ordlist,0);
    1112 def H=ring(L);
    1113 //list
    1114 M=list();
    1115 jmp pu;
    1116 list N;
    1117 poly q;
    1118 poly s;
    1119 i=0;
    1120 int j;
    1121 for(i=1; i<=size(Q); i++)
    1122    {
    1123            N=list();
    1124            for(j=1; j<=size(Q[i]); j++)
    1125               {
    1126                 pu=Q[i][j];
    1127                 q=pu.h;
    1128                 s=pu.t;
    1129                 N[j]=list(q,s);
    1130                }
    1131            M[i]=N;
    1132     }
    1133 list O;
    1134 pu.h=poly(0);
    1135 pu.t=poly(0);
    1136 for(i=1; i<=size(W); i++)
    1137    {
    1138            N=list();
    1139            for(j=1; j<=size(W[i]); j++)
    1140               {
    1141                 pu=W[i][j];
    1142                 q=pu.h;
    1143                 s=pu.t;
    1144                 N[j]=list(q,s);
    1145                }
    1146            O[i]=N;
    1147     }
    1148 pu.h=poly(0);
    1149 pu.t=poly(0);
    1150 setring H;
    1151 list R=list();
    1152 list S=list();
    1153 //print("anello definito");
    1154 def EK=imap(r,EK);
    1155 def MM=imap(r,M);
    1156 def OO=imap(r,O);
    1157 def pd=imap(r,pd);
    1158 list G=list();
    1159 list N=list();
    1160 for(i=1; i<=size(MM); i++)
    1161    {
    1162            for(j=1; j<=size(MM[i]); j++)
    1163               {
    1164                 pu.h=MM[i][j][1];
    1165                 pu.t=MM[i][j][2];
    1166                 N[j]=pu;
    1167                }
    1168            G[i]=N;
    1169     }
    1170 list V;
    1171 for(i=1; i<=size(OO); i++)
    1172    {
    1173            for(j=1; j<=size(OO[i]); j++)
    1174               {
    1175                 pu.h=OO[i][j][1];
    1176                 pu.t=OO[i][j][2];
    1177                 N[j]=pu;
    1178                }
    1179            V[i]=N;
    1180     }
    1181 //print(V);
    1182 //print(G);
    1183 matrix C;
    1184 list COEFF;
    1185 poly p=0;
    1186 poly q=0;
    1187 ideal I;
    1188 list M;
    1189 i=0;
    1190 jmp g;
    1191 int k;
    1192 for(j=1; j<=size(EK);j++)
     1069  list Jms=list();
     1070  //ideal I;
     1071  list M=list();
     1072  jmp mini;
     1073  mini=W[1][1];
     1074  int minimo=deg(mini.h);
     1075  //multiply variables
     1076  poly pd=poly(1);
     1077  for(int i=1;i<=nvars(r);i++)
     1078  { pd=pd*var(i);}
     1079  //CHANGE RING
     1080  intvec u=NewWeight(nvars(r)+1);
     1081  list L=ringlist(r);
     1082  L[2]=insert(L[2],"t",size(L[2]));
     1083  //print(L[2]);
     1084  list ordlist="a",u;
     1085  L[3]=insert(L[3],ordlist,0);
     1086  def H=ring(L);
     1087  //list
     1088  M=list();
     1089  jmp pu;
     1090  list N;
     1091  poly q;
     1092  poly s;
     1093  i=0;
     1094  int j;
     1095  for(i=1; i<=size(Q); i++)
     1096  {
     1097    N=list();
     1098    for(j=1; j<=size(Q[i]); j++)
     1099    {
     1100      pu=Q[i][j];
     1101      q=pu.h;
     1102      s=pu.t;
     1103      N[j]=list(q,s);
     1104    }
     1105    M[i]=N;
     1106  }
     1107  list O;
     1108  pu.h=poly(0);
     1109  pu.t=poly(0);
     1110  for(i=1; i<=size(W); i++)
     1111  {
     1112    N=list();
     1113    for(j=1; j<=size(W[i]); j++)
     1114    {
     1115      pu=W[i][j];
     1116      q=pu.h;
     1117      s=pu.t;
     1118      N[j]=list(q,s);
     1119    }
     1120    O[i]=N;
     1121  }
     1122  pu.h=poly(0);
     1123  pu.t=poly(0);
     1124  setring H;
     1125  list R=list();
     1126  list S=list();
     1127  //print("anello definito");
     1128  def EK=imap(r,EK);
     1129  def MM=imap(r,M);
     1130  def OO=imap(r,O);
     1131  def pd=imap(r,pd);
     1132  list G=list();
     1133  list N=list();
     1134  for(i=1; i<=size(MM); i++)
     1135  {
     1136    for(j=1; j<=size(MM[i]); j++)
     1137    {
     1138      pu.h=MM[i][j][1];
     1139      pu.t=MM[i][j][2];
     1140      N[j]=pu;
     1141    }
     1142    G[i]=N;
     1143  }
     1144  list V;
     1145  for(i=1; i<=size(OO); i++)
     1146  {
     1147    for(j=1; j<=size(OO[i]); j++)
     1148    {
     1149      pu.h=OO[i][j][1];
     1150      pu.t=OO[i][j][2];
     1151      N[j]=pu;
     1152    }
     1153    V[i]=N;
     1154  }
     1155  //print(V);
     1156  //print(G);
     1157  matrix C;
     1158  list COEFF;
     1159  poly p=0;
     1160  poly q=0;
     1161  ideal I;
     1162  list M;
     1163  i=0;
     1164  jmp g;
     1165  int k;
     1166  for(j=1; j<=size(EK);j++)
     1167  {
     1168    //print("arrivo");
     1169    //print(j);
     1170    p=MultEKPolys(EK[j],G);
     1171    //ideal
     1172    I=0;
     1173    if (size(V[D[j]-minimo+1])!=0)
     1174    {
     1175      M=list();
     1176      //  jmp g;
     1177      for(i=1; i<= size(V[D[j]-minimo+1]); i++)
    11931178      {
    1194        //print("arrivo");
    1195        //print(j);
    1196        p=MultEKPolys(EK[j],G);
    1197        //ideal
    1198         I=0;
    1199        if (size(V[D[j]-minimo+1])!=0)
    1200            {
    1201             M=list();
    1202           //  jmp g;
    1203        for(i=1; i<= size(V[D[j]-minimo+1]); i++)
    1204            {
    1205             g=V[D[j]-minimo+1][i];
    1206             g.h=(g.h)*t;
    1207             M[i]=g.h+g.t;
    1208           }
     1179        g=V[D[j]-minimo+1][i];
     1180        g.h=(g.h)*t;
     1181        M[i]=g.h+g.t;
     1182      }
    12091183      I=M[1..size(M)];
    1210      attrib(I,"isSB",1);
    1211 //print(I);
    1212   }
    1213 //print(I);
    1214 q=reduce(t*p,I);
    1215 q=subst(q,t,1);
    1216        C=coef(q,pd);
    1217        COEFF=C[2,1..ncols(C)];
    1218        for(k=1;k<=size(COEFF);k++)
    1219           {
    1220             if(COEFF[k]!=0)
    1221            { Jms=insert(Jms,COEFF[k],size(Jms));}
    1222           }
    1223       }
    1224 setring r;
    1225 def Jms=imap(H,Jms);
    1226 return(Jms);
     1184      attrib(I,"isSB",1);
     1185      //print(I);
     1186    }
     1187    //print(I);
     1188    q=reduce(t*p,I);
     1189    q=subst(q,t,1);
     1190    C=coef(q,pd);
     1191    COEFF=C[2,1..ncols(C)];
     1192    for(k=1;k<=size(COEFF);k++)
     1193    {
     1194      if(COEFF[k]!=0)
     1195      { Jms=insert(Jms,COEFF[k],size(Jms));}
     1196    }
     1197  }
     1198  setring r;
     1199  def Jms=imap(H,Jms);
     1200  return(Jms);
    12271201}
    12281202example
    … …  
    12301204 ring r=0, (x,y,z),rp;
    12311205 ideal Borid=y^2*z,y*z^2,z^3,y^5;
    1232 attrib(Borid,"isSB",1);
    1233     list B=ArrangeBorel(Borid);
    1234     list NumN;
    1235     list N;
    1236     int i;
    1237     int d;
    1238     for(i=1;i<=size(B);i++)
    1239        {
    1240         d=deg(B[i][1]);
    1241         N[i]=kbase(Borid,d);
    1242         NumN[i]=size(N[i]);
    1243        }
    1244 int qc=NumNewVar(B, NumN);
    1245 //Now I must define the NEW RING,
    1246 //putting the c parameters inside.
    1247 list L=ringlist(r);
    1248 list L2;
    1249 L2[1]=L[1];
    1250 L2[2]=list();
    1251 for(i=qc;i>=1;i--)
    1252     {
    1253      L2[2][i]="c("+string(i)+")";
    1254     }
    1255 L2[3]=list(list("rp",qc));
    1256 L2[4]=L[4];
    1257 L[1]=L2;
    1258 if(defined(K)){kill K;}
    1259 def K=ring(L);
    1260 export K;
    1261 setring(K);
    1262 def Borid=imap(r,Borid);
    1263 def N=imap(r,N);
    1264 def B=imap(r,B);
    1265 //NumN contains only scalars so I do not imap it
    1266 int j;
    1267 list Q;
    1268 int s;
    1269 list M;
    1270 jmp pp;
    1271 for(i=1;i<=size(B);i++)
    1272     {
    1273       Q[i]=list();
    1274      for(j=1;j<=size(B[i]);j++)
    1275         {
    1276           M=NewTails(N[i],s);
    1277           pp.h=B[i][j];
    1278           pp.t=M[1];
    1279           Q[i][j]=pp;
    1280           s=s+M[2];
    1281           //print(s);
    1282         }
    1283     }
    1284 list P=ArrangeTails(Q);
    1285 list EK,D= EKPolynomials(P);
    1286      int massimo=Max(D);
    1287 //list V=VConst(P, massimo);
    1288 //pause();
    1289 list V=VmConstructor(P,massimo,r);
    1290 list W=FinalVm(V,P,K);
    1291 //print("I V ridotti in ordine sono");
    1292 //print(W);
    1293 list Jms=SchemeEq(W,EK,D,P,K);
    1294 Jms;}
     1206 attrib(Borid,"isSB",1);
     1207 list B=ArrangeBorel(Borid);
     1208 list NumN;
     1209 list N;
     1210 int i;
     1211 int d;
     1212 for(i=1;i<=size(B);i++)
     1213 {
     1214   d=deg(B[i][1]);
     1215   N[i]=kbase(Borid,d);
     1216   NumN[i]=size(N[i]);
     1217 }
     1218 int qc=NumNewVar(B, NumN);
     1219 //Now I must define the NEW RING,
     1220 //putting the c parameters inside.
     1221 list L=ringlist(r);
     1222 list L2;
     1223 L2[1]=L[1];
     1224 L2[2]=list();
     1225 for(i=qc;i>=1;i--)
     1226 {
     1227   L2[2][i]="c("+string(i)+")";
     1228 }
     1229 L2[3]=list(list("rp",qc));
     1230 L2[4]=L[4];
     1231 L[1]=L2;
     1232 if(defined(K)){kill K;}
     1233 def K=ring(L);
     1234 export K;
     1235 setring(K);
     1236 def Borid=imap(r,Borid);
     1237 def N=imap(r,N);
     1238 def B=imap(r,B);
     1239 //NumN contains only scalars so I do not imap it
     1240 int j;
     1241 list Q;
     1242 int s;
     1243 list M;
     1244 jmp pp;
     1245 for(i=1;i<=size(B);i++)
     1246 {
     1247   Q[i]=list();
     1248   for(j=1;j<=size(B[i]);j++)
     1249   {
     1250     M=NewTails(N[i],s);
     1251     pp.h=B[i][j];
     1252     pp.t=M[1];
     1253     Q[i][j]=pp;
     1254     s=s+M[2];
     1255     //print(s);
     1256   }
     1257 }
     1258 list P=ArrangeTails(Q);
     1259 list EK,D= EKPolynomials(P);
     1260 int massimo=Max(D);
     1261 //list V=VConst(P, massimo);
     1262 //pause();
     1263 list V=VmConstructor(P,massimo,r);
     1264 list W=FinalVm(V,P,K);
     1265 //print("I V ridotti in ordine sono");
     1266 //print(W);
     1267 list Jms=SchemeEq(W,EK,D,P,K);
     1268 Jms;
     1269}
    12951270
    12961271//////////////////////////////////////////////////////////////////////
    … …  
    13031278EXAMPLE:  example JMarkedScheme; shows an example"
    13041279{
    1305 list Jms;
    1306 if(BorelCheck(Borid,r))
    1307   {
    1308    if(size(Borid)==1)
    1309      { Jms=list();}
    1310   else{
    1311     //print("Input is OK");
    1312     attrib(Borid,"isSB",1);
    1313     list B=ArrangeBorel(Borid);
    1314     list NumN;
    1315     list N;
    1316     int i;
    1317     int d;
    1318     for(i=1;i<=size(B);i++)
    1319        {
     1280  list Jms;
     1281  if(BorelCheck(Borid,r))
     1282  {
     1283    if(size(Borid)==1) { Jms=list();}
     1284    else
     1285    {
     1286      //print("Input is OK");
     1287      attrib(Borid,"isSB",1);
     1288      list B=ArrangeBorel(Borid);
     1289      list NumN;
     1290      list N;
     1291      int i;
     1292      int d;
     1293      for(i=1;i<=size(B);i++)
     1294      {
    13201295        d=deg(B[i][1]);
    13211296        N[i]=kbase(Borid,d);
    13221297        NumN[i]=size(N[i]);
    1323        }
    1324 int qc=NumNewVar(B, NumN);
    1325 if(qc==0)
    1326 {Jms=list(0);}
    1327 else
    1328  {
    1329 //Now I must define the NEW RING,
    1330 //putting the c parameters inside.
    1331 list L=ringlist(r);
    1332 list L2;
    1333 L2[1]=L[1];
    1334 L2[2]=list();
    1335 for(i=qc;i>=1;i--)
    1336     {
    1337      L2[2][i]="c("+string(i)+")";
    1338     }
    1339 L2[3]=list(list("rp",qc));
    1340 L2[4]=L[4];
    1341 L[1]=L2;
    1342 if(defined(K)){kill K;}
    1343 def K=ring(L);
    1344 export K;
    1345 setring(K);
    1346 def Borid=imap(r,Borid);
    1347 def N=imap(r,N);
    1348 def B=imap(r,B);
    1349 //NumN contains only scalars so I do not imap it
    1350 int j;
    1351 list Q;
    1352 int s;
    1353 list M;
    1354 jmp pp;
    1355 for(i=1;i<=size(B);i++)
    1356     {
    1357       Q[i]=list();
    1358      for(j=1;j<=size(B[i]);j++)
     1298      }
     1299      int qc=NumNewVar(B, NumN);
     1300      if(qc==0) {Jms=list(0);}
     1301      else
     1302      {
     1303        //Now I must define the NEW RING,
     1304        //putting the c parameters inside.
     1305        list L=ringlist(r);
     1306        list L2;
     1307        L2[1]=L[1];
     1308        L2[2]=list();
     1309        for(i=qc;i>=1;i--)
    13591310        {
    1360           M=NewTails(N[i],s);
    1361           pp.h=B[i][j];
    1362           pp.t=M[1];
    1363           Q[i][j]=pp;
    1364           s=s+M[2];
    1365           //print(s);
     1311          L2[2][i]="c("+string(i)+")";
    13661312        }
    1367     }
    1368 list P=ArrangeTails(Q);
    1369 list EK,D= EKPolynomials(P);
    1370      int massimo=Max(D);
    1371 //list V=VConst(P, massimo);
    1372 //pause();
    1373 list V=VmConstructor(P,massimo,r);
    1374 list W=FinalVm(V,P,K);
    1375 //print("I V ridotti in ordine sono");
    1376 //print(W);
    1377 //list
    1378 Jms=SchemeEq(W,EK,D,P,K);
    1379 keepring K;}
    1380 }
    1381   }
    1382 else
    1383    {
     1313        L2[3]=list(list("rp",qc));
     1314        L2[4]=L[4];
     1315        L[1]=L2;
     1316        if(defined(K)){kill K;}
     1317        def K=ring(L);
     1318        export K;
     1319        setring(K);
     1320        def Borid=imap(r,Borid);
     1321        def N=imap(r,N);
     1322        def B=imap(r,B);
     1323        //NumN contains only scalars so I do not imap it
     1324        int j;
     1325        list Q;
     1326        int s;
     1327        list M;
     1328        jmp pp;
     1329        for(i=1;i<=size(B);i++)
     1330        {
     1331          Q[i]=list();
     1332          for(j=1;j<=size(B[i]);j++)
     1333          {
     1334            M=NewTails(N[i],s);
     1335            pp.h=B[i][j];
     1336            pp.t=M[1];
     1337            Q[i][j]=pp;
     1338            s=s+M[2];
     1339            //print(s);
     1340          }
     1341        }
     1342        list P=ArrangeTails(Q);
     1343        list EK,D= EKPolynomials(P);
     1344        int massimo=Max(D);
     1345        //list V=VConst(P, massimo);
     1346        //pause();
     1347        list V=VmConstructor(P,massimo,r);
     1348        list W=FinalVm(V,P,K);
     1349        //print("I V ridotti in ordine sono");
     1350        //print(W);
     1351        //list
     1352        Jms=SchemeEq(W,EK,D,P,K);
     1353        keepring K;
     1354      }
     1355    }
     1356  }
     1357  else
     1358  {
    13841359    print("WRONG IDEAL IN INPUT");
    13851360    print("It is NOT BOREL");
    1386    }
    1387 return(Jms);
     1361  }
     1362  return(Jms);
    13881363}
    13891364example
    … …  
    13911366 ring r=0, (x,y,z),rp;
    13921367 ideal Borid=y^2*z,y*z^2,z^3,y^5;
    1393 JMarkedScheme(Borid,r);
    1394 }
    1395 ////////////////////////////////////////////////////////////////////
     1368 JMarkedScheme(Borid,r);
     1369}
     1370////////////////////////////////////////////////////////////////////
Note: See TracChangeset for help on using the changeset viewer.