Changeset 337001 in git


Ignore:
Timestamp:
Aug 15, 2019, 1:43:56 PM (5 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', '5b153614cbc72bfa198d75b1e9e33dab2645d9fe')
Children:
43d23c46c518748a9f4fa43d4d8d51ff7fe69354
Parents:
5718c92447c4b2fbefa062bd04f7931fa74f74f8
Message:
fix: create_ring -> ringlist (at some places)
File:
1 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/tropical.lib

    r5718c9 r337001  
    338338  // we change to a ring where the variables have names t and x(1),...,x(n)
    339339  def ALTERRING=basering;
     340  list RL=ringlist(ALTERRING);
    340341  if (nvars(basering)==2)
    341342  {
    342     ring BASERING = create_ring(ringlist(ALTERRING)[1], "(t,x(1))", "("+ordstr(ALTERRING)+")", "no_minpoly");
     343    RL[2]=list("t","x(1)");
     344    ring BASERING = ring(RL);
    343345  }
    344346  else
     
    349351      V[ii+1] = "x("+string(ii)+")";
    350352    }
    351     ring BASERING = create_ring(ringlist(ALTERRING)[1], V, "("+ordstr(ALTERRING)+")", "no_minpoly");
     353    RL[2]=V;
     354    ring BASERING = ring(RL);
    352355  }
    353356  map altphi=ALTERRING,maxideal(1);
     
    471474  // for this, unfortunately, t has to be the last variable !!!
    472475  ideal variablen;
     476  list RL=ringlist(basering);
    473477  for (j=2;j<=nvars(basering);j++)
    474478  {
    475479    variablen=variablen+var(j);
    476   }
    477   ring GRUNDRING = create_ring(ringlist(basering)[1], "("+string(variablen)+",t)", "(dp("+string(nvars(basering)-1)+"),lp(1))", "no_minpoly");
     480    RL[2][j-1]=RL[2][j];
     481  }
     482  RL[2][size(RL[2])]="t";
     483  RL[3]=list(list("dp",1:(nvars(basering)-1)),list("lp",1));
     484  ring GRUNDRING = ring(RL);
     485  list RL=ringlist(GRUNDRING);
     486  list VARIABLEN;
    478487  ideal variablen;
    479488  for (j=1;j<=nvars(basering)-1;j++)
    480489  {
    481490    variablen=variablen+var(j);
     491    VARIABLEN[j]=RL[2][j];
    482492  }
    483493  map GRUNDPHI=BASERING,t,variablen;
     
    502512  if (iszerodim==0) // do so only if is_dim_zero is not set
    503513  {
    504     ring QUOTRING = create_ring("("+charstr(basering)+",t)", "("+string(variablen)+")", "dp");
     514    RL=ringlist(basering);
     515    RL[1]=list(RL[1],list("t"),list(list("lp",1)),ideal(0));
     516    RL[2]=VARIABLEN;
     517    RL[3]=list(list("dp",1:size(VARIABLEN)));
     518    ring QUOTRING = ring(RL);
    505519    ideal i=groebner(imap(GRUNDRING,i));
    506520    int dd=dim(i);
     
    578592        // from LIFTRING are present,
    579593        // and where also the variables of CUTDOWNRING live
    580         ring REPLACEMENTRING = create_ring(ringlist(LIFTRING)[1], "("+varstr(CUTDOWNRING)+")", "dp", "no_minpoly");
     594        list RL=ringlist(LIFTRING);
     595        list RL2=ringlist(CUTDOWNRING);
     596        RL[2]=RL2[2];
     597        RL[3]=list(list("dp",1:nvars(CUTDOWNRING)));
     598        ring REPLACEMENTRING = ring(RL);
    581599        list repl=imap(CUTDOWNRING,repl); // get the replacement rules
    582600                                          // from CUTDOWNRING
     
    10741092      poly mp=minpoly;
    10751093      def OLDRING=basering;
    1076       ring NEWRING = create_ring(0, "("+varstr(basering)+","+parstr(basering)+")", "ds");
     1094      list RL=ringlist(OLDRING);
     1095      RL[2]=RL[2]+RL[1][2];
     1096      RL[1]=RL[1][1];
     1097      RL[3]=list(list("ds",1:size(RL[2])));
     1098      ring NEWRING=ring(RL);
    10771099      ideal I=imap(OLDRING,mp),imap(OLDRING,f);
    10781100    }
     
    17221744    {
    17231745      string polynomstring=string(f);
    1724       ring drawring = create_ring("(0,"+parstr(basering)+")", "("+varstr(basering)+")", "dp");
     1746      list RL=ringlist(basering);
     1747      RL[1][1]=0;
     1748      RL[3]=list(list("dp",1:nvars(basering)));
     1749      ring drawring = ring(RL);
    17251750      execute("poly f="+polynomstring+";");
    17261751    }
     
    26422667  // THIS IS NOT DOCUMENTED FOR THE GENERAL USER!!!!
    26432668  def BASERING=basering;
     2669  list RL=ringlist(BASERING);
     2670  list VARIABLEN;
    26442671  int j;
    26452672  if (size(#)>0)
     
    26472674    // we first have to move the variable t to the front again
    26482675    ideal variablen=var(nvars(basering));
     2676    VARIABLEN[1]=RL[2][nvars(basering)];
    26492677    for (j=1;j<nvars(basering);j++)
    26502678    {
    26512679      variablen=variablen+var(j);
     2680      VARIABLEN[j+1]=RL[2][j];
    26522681    }
    26532682  }
     
    26552684  {
    26562685    ideal variablen=maxideal(1);
     2686    VARIABLEN=RL[2];
    26572687  }
    26582688  // we want to homogenise the ideal i ....
    2659   ring HOMOGRING = create_ring(ringlist(basering)[1], "(@s,"+string(variablen)+")", "dp", "no_minpoly");
     2689  RL=ringlist(basering);
     2690  RL[2]=list("@s")+RL[2];
     2691  RL[3]=list(list("dp",1:size(RL[2])));
     2692  ring HOMOGRING = ring(RL);
    26602693  ideal i=homog(std(imap(BASERING,i)),@s);
    26612694  // ... and compute a standard basis with
     
    26722705  }
    26732706  intmat O=weightVectorToOrderMatrix(whomog);
    2674   ring WEIGHTRING = create_ring(ringlist(basering)[1], "("+varstr(basering)+")", "(M("+string(O)+"))", "no_minpoly");
     2707  list RL=ringlist(basering);
     2708  RL[3]=list(list("M",O));
     2709  ring WEIGHTRING = ring(RL);
    26752710  // map i to the new ring and compute a GB of i, then dehomogenise i,
    26762711  // so that we can be sure, that the
     
    26792714  // compute the w-initial ideal with the help of the procedure tInitialForm;
    26802715  setring BASERING;
    2681   ring COMPINIRING = create_ring(ringlist(basering)[1], "("+string(variablen)+")", "dp", "no_minpoly");
     2716  RL[2]=VARIABLEN;
     2717  RL[3]=list(list("dp",1:size(VARIABLEN)));
     2718  ring COMPINIRING = ring(RL);
    26822719  ideal i=imap(WEIGHTRING,i);
    26832720  ideal ini;
     
    27162753  def BASERING=basering;
    27172754  intmat O=weightVectorToOrderMatrix(w);
    2718   ring INITIALRING = create_ring(ringlist(BASERING)[1], "("+varstr(basering)+")", "M("+string(O)+")", "no_minpoly");
     2755  list RL=ringlist(basering);
     2756  RL[3]=list(list("M",O));
     2757  ring INITIALRING = ring(RL);
    27192758  poly f=imap(BASERING,f);
    27202759  int GRAD=deg(f);
     
    27892828  def BASERING=basering;
    27902829  intmat O=weightVectorToOrderMatrix(w);
    2791   ring INITIALRING = create_ring(ringlist(BASERING)[1], "("+varstr(basering)+")", "M("+string(O)+")", "no_minpoly");
     2830  list RL=ringlist(BASERING);
     2831  RL[3]=list(list("M",O));
     2832  ring INITIALRING = ring(RL);
    27922833  ideal i=imap(BASERING,i);
    27932834  i=std(i);
     
    34983539{
    34993540  def BASERING=basering;
    3500   ring RADRING = create_ring(ringlist(basering)[1], "(@T,"+varstr(basering)+")", "(dp(1),"+ordstr(basering)+")", "no_minpoly");
     3541  list RL=ringlist(BASERING);
     3542  RL[2]=list("@T")+RL[2];
     3543  RL[3]=list(list("dp",1:1))+RL[3];
     3544  ring RADRING = ring(RL);
    35013545  ideal I=ideal(imap(BASERING,i))+ideal(1-@T*imap(BASERING,f));
    35023546  if (reduce(1,std(I))==0)
     
    40124056  list erglini;
    40134057  list ergl;
     4058  list VARIABLEN;
     4059  list RL=ringlist(BASERING);
    40144060  for (j1=1;j1<=nvars(basering)-1;j1++)
    40154061  {
     
    40184064    product=product*var(j1); // make product of all variables
    40194065                             // (needed for the initial-monomial-check later
    4020   }
    4021   ring QUOTRING = create_ring("("+charstr(basering)+",t)", "("+string(variablen)+")", "dp");
     4066    VARIABLEN[j1]=RL[2][j1];
     4067  }
     4068  RL[1]=list(RL[1],list("t"),list(list("lp",1:1)),ideal(0));
     4069  RL[2]=VARIABLEN;
     4070  RL[3]=list(list("dp",1:size(VARIABLEN)));
     4071  ring QUOTRING = ring(RL);
    40224072  setring BASERING;
    40234073  // change to quotring where we want to compute the primary decomposition of i
     
    42064256        variablen=0;
    42074257        j2=0;
     4258        VARIABLEN=list();
    42084259        for(j1=1;j1<=nvars(basering)-1;j1++)
    42094260        {
     
    42194270            variablen=variablen+var(j1); // read the set of remaining variables
    42204271                                         // (needed to make quotring later)
     4272            VARIABLEN=VARIABLEN+list(RL[2][j1]);
    42214273          }
    42224274        }
    42234275        // return pideal, the initial and the list ergl which tells us
    42244276        // which variables we replaced by which form
    4225         ring BASERINGLESS1 = create_ring(ringlist(BASERING)[1], "("+string(variablen)+",t)", "(dp("+string(ncols(variablen))+"),lp(1))", "no_minpoly");
     4277        RL=ringlist(BASERING);
     4278        RL[2]=VARIABLEN+list("t");
     4279        RL[3]=list(list("dp",1:size(VARIABLEN)),list("lp",1:1));
     4280        ring BASERINGLESS1 = ring(RL);
    42264281        ideal i=imap(BASERING,pideal);
    42274282        ideal ini=imap(BASERING,pini); //ideal ini2=tInitialIdeal(i,wvecp,1);
     
    63136368  def BASERING=basering;
    63146369  string tvar=string(var(nvars(basering)));
     6370  list RL_BASERING=ringlist(BASERING);
     6371  list TVAR=RL_BASERING[2];
    63156372  int j,k,l; // indices
    63166373  // store the weighted degrees of the elements of i in an integer vector
     
    63396396  // collect the true variables x_1,...,x_n plus @a, if it is defined in BASERING
    63406397  ideal variablen;
     6398  list VARIABLEN;
     6399  list RL=ringlist(basering);
    63416400  for (j=1;j<=nvars(basering)-1;j++)
    63426401  {
    63436402    variablen=variablen+var(j);
     6403    VARIABLEN[j]=RL[2][j];
    63446404  }
    63456405  // move to a polynomial ring with global monomial ordering
    63466406  // - the variable t is superflous,
    63476407  // the variable @a is not if it was already present
    6348   ring INITIALRING = create_ring(ringlist(basering)[1], "("+string(variablen)+")", "dp", "no_minpoly");
     6408  RL[2]=VARIABLEN;
     6409  RL[3]=list(list("dp",1:size(VARIABLEN)));
     6410  ring INITIALRING = ring(RL);
    63496411  ideal ini=imap(BASERING,ini);
    63506412  // compute the minimal associated primes of the
     
    63626424  }
    63636425  list extensionringlist; // contains the rings which are to be returned
     6426  list RL;
    63646427  for (j=1;j<=size(maximalideals);j++)
    63656428  {
     
    63686431    // if some of the maximal ideals needs a field extension,
    63696432    // then everything will live in this ring
     6433    RL=ringlist(BASERING);
    63706434    if ((maximalideals[j][1]!=0) and (nvars(BASERING)==anzahlvariablen))
    63716435    {
    63726436      // define the extension ring which contains
    63736437      // the new variable @a, if it is not yet present
    6374       ring EXTENSIONRING = create_ring(ringlist(BASERING)[1], "("+string(imap(BASERING,variablen))+",@a,"+tvar+")", "(dp("+string(anzahlvariablen-1)+"),dp(1),lp(1))", "no_minpoly");
     6438      RL[2]=VARIABLEN+list("@a")+TVAR;
     6439      RL[3]=list(list("dp",1:(anzahlvariablen-1)),list("dp",1:1),list("lp",1:1));
     6440      ring EXTENSIONRING = ring(RL);
    63756441      // phi maps x_i to x_i, @a to @a (if present in the ring),
    63766442      // and the additional variable
     
    63836449    else // @a was already present in the BASERING or no
    63846450    { // field extension is necessary
    6385       ring EXTENSIONRING = create_ring(ringlist(BASERING)[1], "("+varstr(BASERING)+")", "("+ordstr(BASERING)+")", "no_minpoly");
     6451      ring EXTENSIONRING = ring(RL);
    63866452      // phi maps x_i to x_i, @a to @a (if present in the ring),
    63876453      // and the additional variable
Note: See TracChangeset for help on using the changeset viewer.