Changeset 6fe3a0 in git for Singular/LIB/rinvar.lib


Ignore:
Timestamp:
Apr 25, 2005, 12:13:07 PM (19 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
3329dd9bcf2662f9666579abea56c33dfcb530ac
Parents:
8604751c5a5f572004bf8d35d4307e485b728435
Message:
*hannes/lossen: new libs, new tests


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/rinvar.lib

    r860475 r6fe3a0  
    11// Last change 10.12.2000 (TB)
    22///////////////////////////////////////////////////////////////////////////////
    3 version="$Id: rinvar.lib,v 1.8 2002-02-19 12:30:16 Singular Exp $";
     3version="$Id: rinvar.lib,v 1.9 2005-04-25 10:13:07 Singular Exp $";
    44category="Invariant theory";
    55info="
    … …  
    9797
    9898  dbPrt = printlevel-voice+2;
    99   dbprint(dbPrt, "Image Group of " + string(Grp) + ", action =  " + string(Gaction));
     99  dbprint(dbPrt, "Image Group of " + string(Grp) + ", action =  "
     100                                   + string(Gaction));
    100101  def RIGB = basering;
    101102  mPoly = minpoly;
    … …  
    104105
    105106  // compute the representation of G induced by Gaction, i.e., a matrix
    106   // of size(Gaction) x size(Gaction) and polynomials in s(1),...,s(r) as entries
     107  // of size(Gaction) x size(Gaction) and polynomials in s(1),...,s(r) as
     108  // entries
    107109  // the matrix is represented as the list 'matrixEntries' where
    108110  // the entries which are always 0 are omittet.
    … …  
    127129
    128130  order = "(dp(" + string(nvars(basering)) + "), dp);";
    129   ringSTR1 = "ring RIGR = (" + charstr(basering) + "), (" + varstr(basering) + ", z(1.." + string(newVars) + "))," + order;
     131  ringSTR1 = "ring RIGR = (" + charstr(basering) + "), (" + varstr(basering)
     132                             + ", z(1.." + string(newVars) + "))," + order;
    130133  execute(ringSTR1);
    131134  minpoly = number(imap(RIGB, mPoly));
    … …  
    138141  // and compute the new action of the image on K^m
    139142
    140   for(i = 1; i <= size(mEntries); i++) { I1[i] = var(i + nvars(RIGB)) - mEntries[i]; }
     143  for(i=1;i<=size(mEntries);i++){ I1[i] = var(i + nvars(RIGB))-mEntries[i]; }
    141144  I1 = std(I1);
    142145
    … …  
    151154  // Gn (contians only z(1..newVars)) to this ring
    152155
    153   ringSTR2 = "ring RIGS = (" + charstr(basering) + "), (s(1.." + string(newVars) + "), t(1.." + string(nrt) + ")), lp;";
     156  ringSTR2 = "ring RIGS = (" + charstr(basering) + "), (s(1.."
     157                     + string(newVars) + "), t(1.." + string(nrt) + ")), lp;";
    154158  execute(ringSTR2);
    155159  minpoly = number(imap(RIGB, mPoly));
    … …  
    159163  // construct the map F : RIGB -> RIGS
    160164
    161   for(i = 1; i <= nvars(RIGB) - nrt; i++) { mapIdeal[i] = 0;}      // s(i) -> 0
     165  for(i=1;i<=nvars(RIGB)-nrt;i++) { mapIdeal[i] = 0;}            // s(i)-> 0
    162166  offset = nvars(RIGB) - nrt;
    163   for(i = 1; i <= nrt; i++) { mapIdeal[i + offset] = var(newVars + i);}    // t(i) -> t(i)
     167  for(i=1;i<=nrt;i++) { mapIdeal[i+offset] = var(newVars + i);}  // t(i)->t(i)
    164168  offset = offset + nrt;
    165   for(i = 1; i <= newVars; i++) { mapIdeal[i + offset] = var(i);}      // z(i) -> s(i)
     169  for(i=1;i<=newVars;i++) { mapIdeal[i + offset] = var(i);}      // z(i)->s(i)
    166170
    167171  // map Gn and newGaction to RIGS
    … …  
    170174  groupid = F(Gn);
    171175  actionid = F(newGaction);
    172   export(groupid);
    173   export(actionid);
    174   dbprint(dbPrt, "
     176  export groupid, actionid;
     177  dbprint(dbPrt+1, "
    175178// 'ImageGroup' created a new ring.
    176 // To see the ring, type (if the name of the ring is R):
     179// To see the ring, type (if the name 'R' was assigned to the return value):
    177180     show(R);
    178 // To access the ideal of the image-group Gn of the group G w.r.t. 'action'
    179 // and the new action of Gn, type
    180      def R = ImageGroup(G, action); setring R;  groupid; actionid;
    181 // 'groupid' is the ideal defining the image of the group G w.r.t. 'action'
    182 // and 'actionid' is the new action of 'groupid'.
     181// To access the ideal of the image of the input group and to access the new
     182// action of the group, type
     183     setring R;  groupid; actionid;
    183184");
     185  setring RIGB;
    184186  return(RIGS);
    185187}
    … …  
    334336  ideal imageid = imap(RAR1, J2);
    335337  export(imageid);
    336      dbprint(dbPrt, "
     338     dbprint(dbPrt+1, "
    337339// 'ImageVariety' created a new ring.
    338 // To see the ring, type (if the name of the ring is R):
     340// To see the ring, type (if the name 'R' was assigned to the return value):
    339341     show(R);
    340 // To access the ideal of the image F(X), where F is a map and X is a variety
    341 // with ideal I,type
    342      def R = ImageVariety(I, F); setring R;  imageid;
    343 // 'imageid' is the ideal of the Zariski closure of F(X).
     342// To access the ideal of the image variety, type
     343     setring R;  imageid;
    344344");
     345  setring RARB;
    345346  return(RAR2);
    346347}
    … …  
    363364ASSUME:  G contains only variables var(1..r) (r = nrs)
    364365basering = K[s(1..r),t(1..m)], K = Q or K = Q(a) and minpoly != 0.
    365 RETURN:  polynomial ring contianing the ideals 'actionid', 'embedid', 'groupid'
     366RETURN:  polynomial ring containing the ideals 'actionid', 'embedid', 'groupid'
    366367         - 'actionid' is the ideal defining the linearized action of G
    367368         - 'embedid' is a parameterization of an equivariant embedding (closed)
    … …  
    371372"
    372373{
     374  def altring = basering;
    373375  int i, j, k, ok, loop, nrt, sizeOfDecomp, dbPrt;
    374376  intvec wt;
    … …  
    404406
    405407    // compute the minimal decomposition of action[i]
    406     // action[i] = decompMx[1,1]*decompMx[2,1] + ... + decompMx[1,k]*decompMx[2,k]
     408    // action[i]=decompMx[1,1]*decompMx[2,1]+ ... +decompMx[1,k]*decompMx[2,k]
    407409    // decompMx[1,j] contains variables var(1)...var(nrs)
    408410    // decompMx[2,j] contains variables var(nrs + 1)...var(nvars(basering))
    409411
    410     dbprint(dbPrt, "  " + string(action[i]) + " is not linear, a minimal decomposition is :");
     412    dbprint(dbPrt, "  " + string(action[i])
     413                   + " is not linear, a minimal decomposition is :");
    411414    decompMx = MinimalDecomposition(action[i], nrs, nrt);
    412415    sizeOfDecomp = ncols(decompMx);
    413416    dbprint(dbPrt, decompMx);
    414417
    415     for(j = 1; j <= sizeOfDecomp; j++) {   // check if decompMx[2,j] is a linear combination of basis elements
     418    for(j = 1; j <= sizeOfDecomp; j++) {   
     419      // check if decompMx[2,j] is a linear combination of basis elements
    416420      actCoeff = decompMx[2, j];
    417421      ok = LinearCombinationQ(basis, actCoeff, nrt + nrs);
    … …  
    420424        // nonlinear element, compute new component of the action
    421425
    422         dbprint(dbPrt, "  the polynomial " + string(actCoeff) + " is not a linear combination of the elements of basis");
     426        dbprint(dbPrt, "  the polynomial " + string(actCoeff)
     427                   + " is not a linear combination of the elements of basis");
    423428        nrt++;
    424         str = charstr(basering) + ", (" + varstr(basering) + ",t(" + string(nrt) + ")),";
     429        str = charstr(basering) + ", (" + varstr(basering)
     430                   + ",t(" + string(nrt) + ")),";
    425431        if(defined(RLAB)) { kill(RLAB);}
    426432        def RLAB = basering;
    … …  
    451457        dbprint(dbPrt, "  extend basering by " + string(var(nrs + nrt)));
    452458        dbprint(dbPrt, "  new basis = " + string(basis));
    453         dbprint(dbPrt, "  action of G on new basis element = " + string(actCoeff));
    454         dbprint(dbPrt, "  decomp : " + string(decompMx[2, j]) + " -> " + string(var(nrs + nrt)));
     459        dbprint(dbPrt, "  action of G on new basis element = "
     460                    + string(actCoeff));
     461        dbprint(dbPrt, "  decomp : " + string(decompMx[2, j]) + " -> "
     462                    + string(var(nrs + nrt)));
    455463      } // end if
    456464      else {
    457         dbprint(dbPrt, "  the polynomial " + string(actCoeff) + " is a linear combination of the elements of basis");
     465        dbprint(dbPrt, "  the polynomial " + string(actCoeff)
     466                    + " is a linear combination of the elements of basis");
    458467      }
    459468    } // end for
    … …  
    464473    else {loop = 0;}
    465474  } // end while
    466   if(defined(actionid)) { kill(actionid); }
     475  if(defined(actionid)) { kill actionid; }
    467476  ideal actionid, embedid, groupid;
    468477  actionid = action;
    469478  embedid = basis;
    470479  groupid = G;
    471   export(actionid);
    472   export(embedid);
    473   export(groupid);
    474 dbprint(dbPrt, "
     480  export actionid, embedid, groupid;
     481dbprint(dbPrt+1, "
    475482// 'LinearizeAction' created a new ring.
    476 // To see the ring, type (if the name of the ring is R):
     483// To see the ring, type (if the name 'R' was assigned to the return value):
    477484     show(R);
    478 // To access the new action and the equivariant embedding, where G and 'action'
    479 // are the original group and group-action contained in K[s(1..ns)] and
    480 // K[s(1..ns),t(1..nt)] respectively, type
    481      def R = LinearizeAction(G, action, ns, nt); setring R; actionid; embedid; groupid
    482 // 'actionid' is the ideal of the linearized action, 'embedid' is the ideal
    483 // defining the equivariant embedding and 'grouid' is the ideal G.
     485// To access the new action and the equivariant embedding, type
     486     setring R; actionid; embedid; groupid
    484487");
     488  setring altring;
    485489  return(RLAR);
    486490}
    … …  
    503507
    504508proc LinearActionQ(Gaction, int nrs)
    505 "USAGE:   LinearActionQ(action,nrs,nrt); ideal action, int nrs
     509"USAGE:   LinearActionQ(action,nrs); ideal action, int nrs
    506510PURPOSE: check if the action defined by 'action' is linear w.r.t. the variables
    507511         var(nrs + 1...nvars(basering)).
    … …  
    533537{"EXAMPLE:";  echo = 2;
    534538  ring R   = 0,(s(1..5), t(1..3)),dp;
    535   ideal G =  s(3)-s(4), s(2)-s(5), s(4)*s(5), s(1)^2*s(4)+s(1)^2*s(5)-1, s(1)^2*s(5)^2-s(5), s(4)^4-s(5)^4+s(1)^2, s(1)^4+s(4)^3-s(5)^3, s(5)^5-s(1)^2*s(5);
    536   ideal Gaction = -s(4)*t(1)+s(5)*t(1), -s(4)^2*t(2)+2*s(4)^2*t(3)^2+s(5)^2*t(2), s(4)*t(3)+s(5)*t(3);
    537   LinearActionQ(Gaction, 5, 3);
     539  ideal G =  s(3)-s(4), s(2)-s(5), s(4)*s(5), s(1)^2*s(4)+s(1)^2*s(5)-1,
     540             s(1)^2*s(5)^2-s(5), s(4)^4-s(5)^4+s(1)^2, s(1)^4+s(4)^3-s(5)^3,
     541             s(5)^5-s(1)^2*s(5);
     542  ideal Gaction = -s(4)*t(1)+s(5)*t(1),
     543                  -s(4)^2*t(2)+2*s(4)^2*t(3)^2+s(5)^2*t(2),
     544                   s(4)*t(3)+s(5)*t(3);
     545  LinearActionQ(Gaction, 5);
     546  LinearActionQ(Gaction, 8);
    538547}
    539548
    … …  
    586595PURPOSE: compute generators of the invariant ring of G w.r.t. the action 'Gact'
    587596ASSUME:  G is a finite group and 'Gact' is a linear action.
    588 RETURN:  polynomial ring over a simple extension of the groundfield of the
    589          basering (the extension might be trivial), containing the ideals
    590          'invars' and 'groupid' and the poly 'newA'
    591          - 'invars' contains the algebra-generators of the invariant ring
     597RETURN:  ring R; this ring comes with the ideals 'invars' and 'groupid' and
     598         with the poly 'newA':
     599         - 'invars' contains the algebra generators of the invariant ring
    592600         - 'groupid' is the ideal of G in the new ring
    593          - 'newA' if the minpoly changes this is the new representation of the
    594            algebraic number, otherwise it is set to 'a'.
    595 NOTE:    the delivered ring might have a different minimal polynomial
     601         - 'newA' is the new representation of the primitive root of the
     602           minimal polynomial of the ring which was active when calling the
     603           procedure (if the minpoly did not change, 'newA' is set to 'a').
     604NOTE:    the minimal polynomial of the output ring depends on some random
     605         choices
    596606EXAMPLE: example InvariantRing; shows an example
    597607"
    … …  
    613623  // compute the nullcone of G by means of Derksen's algorithm
    614624
    615   invarsGens = NullCone(groupid, action);    // compute the nullcone of the linear action
     625  invarsGens = NullCone(groupid, action);  // compute nullcone of linear action
    616626  dbprint(dbPrt, " generators of zero-fibre ideal are " + string(invarsGens));
    617627
    618628  // make all generators of the nullcone invariant
    619629  // if necessary, compute the Reynolds Operator, i.e., find all elements
    620   // of the variety defined by G. It might be necessary to extend the groundfield.
     630  // of the variety defined by G. It might be necessary to extend the
     631  // ground field.
    621632
    622633  def IRB = basering;
    … …  
    624635  def RIRR = basering;
    625636  setring RIRR;
    626   export(RIRR);
    627   export(invarsGens);
     637//  export(RIRR);
     638//  export(invarsGens);
    628639  noReynolds = 1;
    629640  dbprint(dbPrt, " nullcone is generated by " + string(size(invarsGens)));
    630641   dbprint(dbPrt, " degrees = " + string(maxdeg(invarsGens)));
    631642  for(i = 1; i <= ncols(invarsGens); i++){
    632     ok =  InvariantQ(invarsGens[i], groupid, action);
    633     if(ok) { dbprint(dbPrt, string(i) + ": poly " + string(invarsGens[i]) + " is invariant");}
     643    ok = InvariantQ(invarsGens[i], groupid, action);
     644    if(ok) { dbprint(dbPrt, string(i) + ": poly " + string(invarsGens[i])
     645                                      + " is invariant");}
    634646    else {
    635647      if(noReynolds) {
    636648
    637649        // compute the Reynolds operator and change the ring !
    638 
     650        noReynolds = 0;
    639651        def RORN = ReynoldsOperator(groupid, action, primaryDec);
    640         noReynolds = 0;
    641652        setring RORN;
    642         export(RORN);
    643653        ideal groupid = std(id);
    644654        attrib(groupid, "isSB", 1);
    645655        ideal action = actionid;
    646         ideal invarsGens = TransferIdeal(RIRR, "invarsGens", newA);
    647         export(invarsGens);
    648         kill(RIRR);
     656//        ideal invarsGens = TransferIdeal(RIRR, "invarsGens", newA);
     657//        export(invarsGens);
     658// lossen: ersetzt durch
     659        setring RIRR;
     660        string parName, minPoly;
     661        if(npars(basering) == 0) {
     662          parName = "a";
     663          minPoly = "0";
     664        }
     665        else {
     666          parName = parstr(basering);
     667          minPoly = string(minpoly);
     668        }
     669        execute("ring RA1=0,(" + varstr(basering) + "," + parName + "), lp;");
     670        if (minPoly!="0") { execute("ideal mpoly = std(" + minPoly + ");"); }
     671        ideal I = imap(RIRR,invarsGens);
     672        setring RORN;
     673        map Phi = RA1, maxideal(1);
     674        Phi[nvars(RORN) + 1] = newA;
     675        ideal invarsGens = Phi(I);
     676        kill Phi,RA1,RIRR;
     677// end of ersetzt durch     
    649678
    650679      }
    651       dbprint(dbPrt, string(i) + ": poly " + string(invarsGens[i]) + " is NOT invariant");
     680      dbprint(dbPrt, string(i) + ": poly " + string(invarsGens[i])
     681                               + " is NOT invariant");
    652682      invarsGens[i] = ReynoldsImage(ROelements, invarsGens[i]);
    653683      dbprint(dbPrt, " --> " + string(invarsGens[i]));
    … …  
    656686  for(i = 1; i <= ncols(invarsGens); i++){
    657687    ok =  InvariantQ(invarsGens[i], groupid, action);
    658     if(ok) { dbprint(dbPrt, string(i) + ": poly " + string(invarsGens[i]) + " is invariant"); }
     688    if(ok) { dbprint(dbPrt, string(i) + ": poly " + string(invarsGens[i])
     689                                      + " is invariant"); }
    659690    else { print(string(i) + ": Fatal Error with Reynolds ");}
    660691  }
    661   kill(IRB);
    662692  if(noReynolds == 0) {
    663693    def RIRS = RORN;
    664     setring(RIRS);
    665     kill(RORN);export(groupid);
     694    setring RIRS;
     695    kill RORN;
     696    export groupid;
    666697  }
    667698  else {
    668699    def RIRS = RIRR;
    669     kill(RIRR);
    670     setring(RIRS);
    671                 export(groupid);
     700    kill RIRR;
     701    setring RIRS;
     702    export groupid;
    672703  }
    673704  ideal invars = invarsGens;
    674   kill(invarsGens);
    675   export(invars);
    676   // export(groupid);
    677 dbprint(dbPrt, "
     705  kill invarsGens;
     706  if (defined(ROelements)) { kill ROelements,actionid,zeroset,id; }
     707  export invars;
     708  dbprint(dbPrt+1, "
    678709// 'InvariantRing' created a new ring.
    679 // To see the ring, type (if the name of the ring is R):
     710// To see the ring, type (if the name 'R' was assigned to the return value):
    680711     show(R);
    681 // To access the generators of the invariant ring of G w.r.t. the linear
    682 // group-action 'action' of G, where G is contained in K[s(1..ns)] and
    683 // 'action' in K[s(1..ns),t(1..nt)], type
    684      def R = InvariantRing(G, action); setring R; invars;
    685 // 'invars' contains generator of the invariant ring.
    686 // Note that G is containd in R as the ideal 'groupid', to see it, type
     712// To access the generators of the invariant ring type
     713     setring R; invars;
     714// Note that the input group G is stored in R as the ideal 'groupid'; to
     715// see it, type
    687716    groupid;
    688717// Note that 'InvariantRing' might change the minimal polynomial
    689718// The representation of the algebraic number is given by 'newA'
    690719");
     720  setring IRB;
    691721  return(RIRS);
    692722}
    … …  
    715745         1 if f is invariant
    716746NOTE:    G need not be finite
    717 EXAMPLE: example InvariantQ; shows an example
    718 "
    719 {
     747"
     748{
     749  def altring=basering;
    720750  map F;
    721 
    722751  if(deg(f) == 0) { return(1); }
    723752  for(int i = 1; i <= size(action); i++) {
    … …  
    850879  order = "(dp(" + string(nvars(basering) - nt) + "), dp);";
    851880  vars = "(s(1.." + string(nvars(basering) - nt);
    852   vars = vars + "), t(1.." + string(nt) + "), Y(1.." + string(nt) + "))," + order;
    853   ringSTR = "ring RNCR = (" + charstr(basering) +  "),"  + vars; // ring for the computation
     881  vars = vars +"),t(1.."+string(nt) + "), Y(1.." + string(nt) + "))," + order;
     882  ringSTR = "ring RNCR = (" + charstr(basering) +  "),"  + vars;
     883  // ring for the computation
    854884
    855885  minPoly = minpoly;
    856886  offset =  size(G) + nt;
    857887  execute(ringSTR);
    858   minpoly = number(imap(RNCB, minPoly));
     888  def aaa=imap(RNCB, minPoly);
     889  if (aaa!=0) { minpoly = number(aaa); }
    859890  ideal action, G, I, J, N, generators;
    860891  map F;
    … …  
    880911
    881912  // substitute
    882 
    883913  for(i = 1; i <= nvars(basering); i = i + 1) { F[i] = 0; }
    884914  for(i = groupVars + 1; i <= offset; i = i + 1) { F[i] = var(i); }
    885915
    886916  generators = mstd(F(N))[2];
    887         setring(RNCB);
     917  setring RNCB;
    888918  return(fetch(RNCR, generators));
    889919}
    … …  
    901931
    902932proc ReynoldsOperator(ideal Grp, ideal Gaction, list #)
    903 "USAGE:   ReynoldsOperator(G, action [, opt); ideal G, action; int opt
     933"USAGE:   ReynoldsOperator(G, action [, opt]); ideal G, action; int opt
    904934PURPOSE: compute the Reynolds operator of the group G which act via 'action'
    905935RETURN:  polynomial ring R over a simple extension of the groundfield of the
    … …  
    907937         'ROelements', the ideals 'id', 'actionid' and the polynomial 'newA'.
    908938         R = K(a)[s(1..r),t(1..n)].
    909          - 'ROelements'  is a list of ideal, each ideal represents a
     939         - 'ROelements'  is a list of ideals, each ideal represents a
    910940           substitution map F : R -> R according to the zero-set of G
    911941         - 'id' is the ideal of G in the new ring
    … …  
    915945         G is the ideal of a finite group in K[s(1..r)], 'action' is a linear
    916946         group action of G
    917 EXAMPLE: example ReynoldsOperator; shows an example
    918 "
    919 {
     947"
     948{
     949  def ROBR = basering;
    920950  int i, j, n, ns, primaryDec;
    921951  ideal G1 = Grp;
    … …  
    925955  if(size(#) > 0) { primaryDec = #[1]; }
    926956  else { primaryDec = 0; }
     957  kill #;
    927958
    928959  n = nvars(basering);
    … …  
    930961  for(i = ns + 1; i <= n; i++) { G1 = G1, var(i);}
    931962
    932   def ROBR = basering;
    933   export(Grp);
    934   export(Gaction);
    935   def RORN = ZeroSet(G1, primaryDec);
    936   setring RORN;
    937   id = TransferIdeal(ROBR, "Grp", newA);  // defined in ZeroSet ...
    938   ideal actionid = TransferIdeal(ROBR, "Gaction", newA);
     963  def RORR = ZeroSet(G1, primaryDec);
     964//  setring RORR;
     965//  id = TransferIdeal(ROBR, "Grp", newA);  // defined in ZeroSet ...
     966//  ideal actionid = TransferIdeal(ROBR, "Gaction", newA);
     967// lossen: ersetzt durch
     968  setring ROBR;
     969  string parName, minPoly;
     970  if(npars(basering) == 0) {
     971    parName = "a";
     972    minPoly = "0";
     973  }
     974  else {
     975    parName = parstr(basering);
     976    minPoly = string(minpoly);
     977  }
     978  execute("ring RA1=0,(" + varstr(basering) + "," + parName + "), lp;");
     979  if (minPoly!="0") { execute("ideal mpoly = std(" + minPoly + ");"); }
     980  ideal Grp = imap(ROBR,Grp);
     981  ideal Gaction = imap(ROBR,Gaction);
     982  setring RORR;
     983  map Phi = RA1, maxideal(1);
     984  Phi[nvars(RORR) + 1] = newA;
     985  ideal id = Phi(Grp);
     986  ideal actionid = Phi(Gaction);
     987  kill parName,minPoly,Phi,RA1;
     988// end of ersetzt durch   
    939989  list ROelements;
    940990  ideal Rf;
    … …  
    944994  for(i = 1; i <= size(zeroset); i++) {
    945995    groupElem = zeroset[i];    // element of G
    946     for(j = ns + 1; j <= n; j++) { groupElem[j] = var(j); } // do not change t's
     996    for(j = ns + 1; j<=n; j++) { groupElem[j] = var(j); } //do not change t's
    947997    for(j = 1; j <= n - ns; j++) {
    948998      h1 = actionid[j];
    … …  
    9521002    ROelements[i] = Rf;
    9531003  }
    954   export(actionid);
    955   export(ROelements);
    956   return(RORN);
     1004  export actionid, ROelements;
     1005  setring ROBR;
     1006  return(RORR);
    9571007}
    9581008
    … …  
    9661016"
    9671017{
     1018  def RIBR=basering;
    9681019  map F;
    9691020  poly h = 0;
    9701021
    9711022  for(int i = 1; i <= size(reynoldsOp); i++) {
    972     F = basering, reynoldsOp[i];
     1023    F = RIBR, reynoldsOp[i];
    9731024    h = h + F(f);
    9741025  }
    … …  
    10631114///////////////////////////////////////////////////////////////////////////////
    10641115
    1065 static proc TransferIdeal(R, string name, poly newA)
    1066 " USAGE:  TransferIdeal(R, name, newA); ring R, string name, poly newA
    1067 PURPOSE: Maps an ideal with name 'name' in R to the basering, s.t. all
    1068          variables are fixed but par(1) is replaced by 'newA'.
    1069 RETURN:  ideal
    1070 NOTE:    this is used to transfor an ideal if the minimal polynomial has changed
    1071 "
    1072 {
    1073   def RAB = basering;
    1074   def RA1 = TransferRing(R);
    1075 
    1076   setring RA1;
    1077   execute("ideal I = imap(R, " + name + ");");
    1078   setring RAB;
    1079   map F = RA1, maxideal(1);
    1080   F[nvars(RAB) + 1] = newA;
    1081   return(F(I));
    1082 }
    1083 
    1084 ///////////////////////////////////////////////////////////////////////////////
    1085 
    10861116static proc RingVarProduct(index)
    10871117// list of indices
Note: See TracChangeset for help on using the changeset viewer.