Changeset 35f23d in git for Singular/LIB/rinvar.lib


Ignore:
Timestamp:
Dec 18, 2000, 2:20:12 PM (23 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'spielwiese', '5b153614cbc72bfa198d75b1e9e33dab2645d9fe')
Children:
bef194c40c7211201f3f9a4d7e603ecf1724d415
Parents:
e702a986aff8bbd94084d372e0fdda3ca1652064
Message:
*hannes?tbayer: lib revisited


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

Legend:

Unmodified
Added
Removed
  • Singular/LIB/rinvar.lib

    re702a98 r35f23d  
    1 // rinvar.lib
    2 // Invariants of reductive groups
    3 //
    4 // Implementation by : Thomas Bayer
    5 // Current Adress:
    6 // Institut fuer Informatik, Technische Universitaet Muenchen
    7 // www:    http://wwwmayr.informatik.tu-muenchen.de/personen/bayert/
    8 // email : bayert@in.tum.de
    9 //
    10 // Last change 10.12.2000
    11 //
    12 // written in the frame of the diploma thesis (advisor: Prof. Gert-Martin Greuel)
    13 // "Computations of moduli spaces of semiquasihomogenous singularities and an
    14 //  implementation in Singular"
    15 // Arbeitsgruppe Algebraische Geometrie, Fachbereich Mathematik,
    16 // Universitaet Kaiserslautern
    17 ///////////////////////////////////////////////////////////////////////////////
    18 
    19 version="$Id: rinvar.lib,v 1.2 2000-12-11 13:15:38 Singular Exp $";
     1///////////////////////////////////////////////////////////////////////////////
     2version="Id: rinvar.lib,v 1.0 2000/12/10 17:32:15 Singular Exp $";
    203info="
    214LIBRARY:  rinvar.lib      PROCEDURES FOR INVARIANT RINGS OF REDUCTIVE GROUPS
     
    4124";
    4225
     26// NOTE: This library has been written in the frame of the diploma thesis
     27// 'Computing moduli spaces of semiquasihomogeneous singularites and an
     28//  implementation in Singular', Arbeitsgruppe Algebraische Geometrie,
     29// Fachbereich Mathematik, University Kaiserslautern,
     30// Advisor: Prof. Gert-Martin Greuel
     31
     32
    4333LIB "presolve.lib";
    4434LIB "elim.lib";
     
    4939proc EquationsOfEmbedding(ideal embedding, int nrs)
    5040"USAGE:   EquationsOfEmbedding(embedding, s); ideal embedding; int s;
    51 PUROPSE: compute the ideal of the variety parameterized by 'embedding' by
     41PURPOSE: compute the ideal of the variety parameterized by 'embedding' by
    5242         implicitation and change the variables to the old ones.
    5343RETURN:  ideal
     
    7969proc ImageGroup(ideal Grp, ideal Gaction)
    8070"USAGE:   ImageGroup(G, action); ideal G, action;
    81 PUROPSE: compute the ideal of the image of G in GL(m,K) induced by the linear
     71PURPOSE: compute the ideal of the image of G in GL(m,K) induced by the linear
    8272         action 'action', where G is an algebraic group and 'action' defines
    8373         an action of G on K^m (size(action) = m).
     
    9585  K[t_1,...,t_m] --> K[s_1,...,s_r,t_1,...,t_m]/G
    9686    t_i    --> f_i(s_1,...,s_r,t_1,...,t_m)
     87
    9788EXAMPLE: example ImageGroup; shows an example
    9889"
     
    207198proc HilbertWeights(ideal I, wt)
    208199"USAGE:   HilbertWeights(I, w); ideal I, intvec wt
    209 PUROPSE: compute the weights of the "slack" varaibles needed for the
     200PURPOSE: compute the weights of the "slack" varaibles needed for the
    210201         computation of the algebraic relations of the generators of 'I' s.t.
    211202         the Hilbert driven 'std' can be used.
     
    226217proc HilbertSeries(ideal I, wt)
    227218"USAGE:   HilbertSeries(I, w); ideal I, intvec wt
    228 PUROPSE: compute the polynomial p of the Hilbert Series,represented by p/q, of
     219PURPOSE: compute the polynomial p of the Hilbert Series,represented by p/q, of
    229220         the ring K[t_1,...,t_m,y_1,...,y_r]/I1 where 'w' are the weights of
    230221         the variables, computed, e.g., by 'HilbertWeights', 'I1' is of the
     
    251242proc HilbertSeries1(wt)
    252243"USAGE:   HilbertSeries1(wt); ideal I, intvec wt
    253 PUROPSE: compute the polynomial p of the Hilbert Series represented by p/q of
     244PURPOSE: compute the polynomial p of the Hilbert Series represented by p/q of
    254245         the ring K[t_1,...,t_m,y_1,...,y_r]/I where I is a complete inter-
    255246         section and the generator I[i] has degree wt[i]
    256247RETURN:  poly
     248EXAMPLE:
    257249"
    258250{
     
    280272proc ImageVariety(ideal I, F, list #)
    281273"USAGE:   ImageVariety(ideal I, F [, w]);ideal I; F is a list/ideal, intvec w.
    282 PUROPSE: compute the Zariski closure of the image of the variety of I under
     274PURPOSE: compute the Zariski closure of the image of the variety of I under
    283275         the morphism F.
    284276NOTE:    if 'I' and 'F' are quasihomogenous w.r.t. 'w' then the Hilbert-driven
     
    366358proc LinearizeAction(ideal Grp, Gaction, int nrs)
    367359"USAGE:   LinearizeAction(G,action,r); ideal G, action; int r
    368 PUROPSE: linearize the group action 'action' and find an equivariant embedding
    369          of K^m where m = size(action).
     360PURPOSE: linearize the group action 'action' and find an equivariant
     361         embedding of K^m where m = size(action).
    370362ASSUME:  G contains only variables var(1..r) (r = nrs)
    371363basering = K[s(1..r),t(1..m)], K = Q or K = Q(a) and minpoly != 0.
    372 RETURN:  polynomial ring contianing the ideals 'actionid', 'embedid', 'groupid'
     364RETURN:  polynomial ring contianing the ideals 'actionid','embedid','groupid'
    373365         - 'actionid' is the ideal defining the linearized action of G
    374          - 'embedid' is a parameterization of an equivariant embedding (closed)
     366         - 'embedid' is a parameterization of an equivariant embedding
    375367         - 'groupid' is the ideal of G in the new ring
    376368NOTE:    set printlevel > 0 to see a trace
     
    511503proc LinearActionQ(Gaction, int nrs)
    512504"USAGE:   LinearActionQ(action,nrs,nrt); ideal action, int nrs
    513 PUROPSE: check if the action defined by 'action' is linear w.r.t. the variables
     505PURPOSE: check if the action defined by 'action' is linear wrt. the variables
    514506         var(nrs + 1...nvars(basering)).
    515507RETURN:  0 action not linear
     
    526518  loop = 1;
    527519  i = 1;
    528   while(loop)
    529   {
     520  while(loop){
    530521    if(deg(Gaction[i], wt) > 1) { loop = 0; }
    531     else
    532     {
     522    else {
    533523      i++;
    534524      if(i > ncols(Gaction)) { loop = 0;}
     
    549539proc LinearCombinationQ(ideal I, poly f)
    550540"USAGE:   LinearCombination(I, f); ideal I, poly f
    551 PUROPSE: test if f can be written as a linear combination of the generators of I.
    552 RETURN:  0 f is not a linear combination
    553          1 f is a linear combination
     541PURPOSE: test if f can be written as a linear combination of the gens. of I
     542RETURN:  0 'f' is not a linear combination
     543         1 'f' is a linear combination
    554544"
    555545{
     
    567557  loop = 1;
    568558  i = 1;
    569   while(loop)
    570   { // look for a linear relation containing Y(nr)
    571     if(deg(imageid[i]) == 1)
    572     {
     559  while(loop) {        // look for a linear relation containing Y(nr)
     560    if(deg(imageid[i]) == 1) {
    573561      coMx = coef(imageid[i], var(sizeJ));
    574       if(coMx[1,1] == var(sizeJ))
    575       {
     562      if(coMx[1,1] == var(sizeJ)) {
    576563        relation = imageid[i];
    577564        loop = 0;
    578565      }
    579566    }
    580     else
    581     {
     567    else {
    582568      i++;
    583569      if(i > ncols(imageid)) { loop = 0;}
     
    591577proc InvariantRing(ideal G, ideal action, list #)
    592578"USAGE:   InvariantRing(G, Gact [, opt]); ideal G, Gact; int opt
    593 PUROPSE: compute generators of the invariant ring of G w.r.t. the action 'Gact'
     579PURPOSE: compute generators of the invariant ring of G wrt. the action 'Gact'
    594580ASSUME:  G is a finite group and 'Gact' is a linear action.
    595581RETURN:  polynomial ring over a simple extension of the groundfield of the
     
    598584         - 'invars' contains the algebra-generators of the invariant ring
    599585         - 'groupid' is the ideal of G in the new ring
    600          - 'newA' if the minpoly changes this is the new representation of the
    601            algebraic number, otherwise it is set to 'a'.
     586         - 'newA' if the minpoly changes this is the new representation of
     587           the algebraic number, otherwise it is set to 'a'.
    602588NOTE:    the delivered ring might have a different minimal polynomial
    603589EXAMPLE: example InvariantRing; shows an example
     
    649635        export(RORN);
    650636        ideal groupid = std(id);
     637                                kill(id);
    651638        attrib(groupid, "isSB", 1);
    652639        ideal action = actionid;
     
    713700proc InvariantQ(poly f, ideal G, action)
    714701"USAGE:   InvariantQ(f, G, action); poly f; ideal G, action
    715 PUROPSE: check if the polynomial f is invariant w.r.t. G where G acts via
     702PURPOSE: check if the polynomial f is invariant w.r.t. G where G acts via
    716703         'action' on K^m.
    717704ASSUME:  basering = K[s_1,...,s_m,t_1,...,t_m] where K = Q of K = Q(a) and
     
    738725proc MinimalDecomposition(poly f, int nrs, int nrt)
    739726"USAGE:   MinimalDecomposition(f,a,b); poly f; int a, b.
    740 PUROPSE: decompose f as a sum M[1,1]*M[2,1] + ... + M[1,r]*M[2,r] where M[1,i]
    741          contains only s(1..a), M[2,i] contains only t(1...b) s.t. r is minimal
    742 ASSUME:  f polynomial in K[s(1..a),t(1..b)], K = Q or K = Q(a) and minpoly != 0
     727PURPOSE: decompose f as a sum M[1,1]*M[2,1] + ... + M[1,r]*M[2,r] where M[1,i]
     728         contains only s(1..a), M[2,i] contains only t(1...b) st. r is minimal
     729ASSUME:  f polynomial in K[s(1..a),t(1..b)],K = Q or K = Q(a) and minpoly != 0
    743730RETURN:  2 x r matrix M s.t.  f = M[1,1]*M[2,1] + ... + M[1,r]*M[2,r]
    744731EXAMPLE: example MinimalDecomposition;
     
    834821proc NullCone(ideal G, action)
    835822"USAGE:   NullCone(G, action); ideal G, action
    836 PUROPSE: compute the ideal of the nullcone of the linear action of G on K^n,
     823PURPOSE: compute the ideal of the nullcone of the linear action of G on K^n,
    837824         given by 'action', by means of Deksen's algorithm
    838825ASSUME:  basering = K[s(1..r),t(1..n)], K = Q or K = Q(a) and minpoly != 0,
     
    840827         'action' is a linear group action of G on K^n (n = ncols(action))
    841828RETURN:  ideal of the nullcone of G.
    842 NOTE:    the generators of the nullcone are homogenous, but i.g. not invariant
     829NOTE:    the generators of the nullcone are homogenous, but ig. not invariant
    843830EXAMPLE: example NullCone; shows an example
    844831"
     
    909896proc ReynoldsOperator(ideal Grp, ideal Gaction, list #)
    910897"USAGE:   ReynoldsOperator(G, action [, opt); ideal G, action; int opt
    911 PUROPSE: compute the Reynolds operator of the group G which act via 'action'
     898PURPOSE: compute the Reynolds operator of the group G which act via 'action'
    912899RETURN:  polynomial ring R over a simple extension of the groundfield of the
    913900         basering (the extension might be trivial), containing a list
     
    920907           basering does not contain a parameter then 'newA' = 'a'.
    921908ASSUME:  basering = K[s(1..r),t(1..n)], K = Q or K = Q(a') and minpoly != 0,
    922          G is the ideal of a finite group in K[s(1..r)], 'action' is a linear
     909         G is the ideal of a finite group in K[s(1..r)],'action' is a linear
    923910         group action of G
    924911EXAMPLE: example ReynoldsOperator; shows an example
     
    968955proc ReynoldsImage(list reynoldsOp, poly f)
    969956"USAGE:   ReynoldsImage(RO, f); list RO, poly f
    970 PUROPSE: compute the Reynolds image of the polynomial f where RO represents
     957PURPOSE: compute the Reynolds image of the polynomial f where RO represents
    971958         the Reynolds operator
    972959RETURN:  poly
     
    987974static proc SimplifyCoefficientMatrix(matrix coefMatrix)
    988975"USAGE:   SimplifyCoefficientMatrix(M); M matrix coming from coef(...)
    989 PUROPSE: simplify the matrix, i.e. find linear dependencies among the columns
     976PURPOSE: simplify the matrix, i.e. find linear dependencies among the columns
    990977RETURN:  matrix M, f = M[1,1]*M[2,1] + ... + M[1,n]*M[2,n]
    991978"
     
    10221009
    10231010proc SimplifyIdeal(ideal I, list #)
    1024 "USAGE:   SimplifyIdeal(I [,m, name]); ideal I; int m, string name"
     1011"USAGE:   SimplifyIdeal(I [,m, name]); ideal I; int m, string name
    10251012PURPOSE: simplify ideal I to the ideal I', do not change the names of the
    10261013         first m variables, new ideal I' might contain less variables.
     
    10281015RETURN: list
    10291016  _[1] ideal I'
    1030   _[2] ideal representing a map phi to a ring with probably less vars. s.t.
    1031        phi(I) = I'
     1017  _[2] ideal representing a map phi to a ring with probably less
     1018             varsiables s.t. phi(I) = I'
    10321019  _[3] list of variables
    10331020  _[4] list from 'elimpart'
     1021NOTE:
    10341022"
    10351023{
     
    10431031  mapId = sList[5];
    10441032
    1045   if(size(#) > 0)
    1046   {
     1033  if(size(#) > 0) {
    10471034    m = #[1];
    10481035    nameCMD = #[2];
     
    10501037  else { m = 0;} // nvars(basering);
    10511038  k = 0;
    1052   for(i = 1; i <= nvars(basering); i++)
    1053   {
    1054     if(sList[4][i] != 0)
    1055     {
     1039  for(i = 1; i <= nvars(basering); i++) {
     1040    if(sList[4][i] != 0) {
    10561041      k++;
    10571042      if(k <= m) { mId[i] = sList[4][i]; }
     
    10721057static proc TransferIdeal(R, string name, poly newA)
    10731058" USAGE:  TransferIdeal(R, name, newA); ring R, string name, poly newA
    1074 PUROPSE: Maps an ideal with name 'name' in R to the basering, s.t. all
     1059PURPOSE: Maps an ideal with name 'name' in R to the basering, s.t. all
    10751060         variables are fixed but par(1) is replaced by 'newA'.
    10761061RETURN:  ideal
    1077 NOTE:    this is used to transfor an ideal if the minimal polynomial has changed
     1062NOTE:    this is used to transfor ideals if the minimal polynomial has changed
    10781063"
    10791064{
     
    10951080{
    10961081  poly f = 1;
    1097   for(int i = 1; i <= size(index); i++)
    1098   {
     1082
     1083  for(int i = 1; i <= size(index); i++) {
    10991084    f = f * var(index[i]);
    11001085  }
Note: See TracChangeset for help on using the changeset viewer.