Changeset 2abb041 in git

Timestamp:

Feb 24, 2007, 4:08:04 PM (16 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')

Children:

bd7468e27c17b2493beec0180f366c438528745d

Parents:

b863e9dd32456f975a36c9963618660981b3bdb9

Message:

*hannes: fixed doc.


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

File:

• Singular/LIB/finvar.lib (modified) (54 diffs)

Singular/LIB/finvar.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: finvar.lib,v 1.64 2007-02-21 13:39:21 king Exp $"
+version="$Id: finvar.lib,v 1.65 2007-02-24 15:08:04 Singular Exp $"
 category="Invariant theory";
 info="
@@ -4769 +4769 @@
                 { ISSort[i-1] = ideal(B[j]);
                 }
-                if (v) 
-                { "    We found", irrcounter,"of", NrIS ,"irr. sec. inv. in degree ",i-1; 
+                if (v)
+                { "    We found", irrcounter,"of", NrIS ,"irr. sec. inv. in degree ",i-1;
                 }
                 Reductor = ideal(helpP);
@@ -4788 +4788 @@
         else  // use fast algorithm
         { B=sort_of_invariant_basis(sP_Reductor,REY,i-1,int(dimmat[i,1])*6);
-                                       // B contains 
+                                       // B contains
                                        // images of kbase(sP,i-1) under the
                                        // Reynolds operator that are linearly
@@ -4825 +4825 @@
                 { ISSort[i-1] = ideal(B[j]);
                 }
-                if (v) 
-                { "    We found", irrcounter,"of", NrIS,"irr. sec. inv. in degree ",i-1; 
+                if (v)
+                { "    We found", irrcounter,"of", NrIS,"irr. sec. inv. in degree ",i-1;
                 }
                 Reductor = ideal(helpP);
@@ -4900 +4900 @@
 @*          \"PP\": if this string occurs as (optional) parameter, then in
                all degrees power products of irr. sec. inv. will be computed.
-RETURN:   Irreducible homogeneous secondary invariants of the invariant ring 
+RETURN:   Irreducible homogeneous secondary invariants of the invariant ring
           (type <matrix>)
 ASSUME:   We are in the non-modular case, i.e., the characteristic of the basering
@@ -4915 +4915 @@
           independent modulo the primary invariants using Groebner basis techniques
           (see paper \"Fast Computation of Secondary Invariants\" by S. King).
-          The size of this set can be read off from the Molien series. Here, only 
-          irreducible secondary invariants are explicitly computed, which saves time and 
+          The size of this set can be read off from the Molien series. Here, only
+          irreducible secondary invariants are explicitly computed, which saves time and
           memory.
 @*        Moreover, if no irr. sec. inv. in degree d-1 have been found and unless the last
-          optional paramter \"PP\" is used, a Groebner basis of primary invariants and 
-          irreducible secondary invariants up to degree d-2 is computed, which allows to 
-          detect irr. sec. inv. in degree d without computing power products. 
+          optional paramter \"PP\" is used, a Groebner basis of primary invariants and
+          irreducible secondary invariants up to degree d-2 is computed, which allows to
+          detect irr. sec. inv. in degree d without computing power products.
 @*        There are three internal parameters \"pieces\", \"MonStep\" and \"IrrSwitch\".
           The default values of the parameters should be fine in most cases. However,
@@ -4937 +4937 @@
                      // If this parameter is small, the memory consumption will decrease.
   int IrrSwitch = 7; // Up to degree #IrrSwitch#-1, or if there are few monomials in kbase(sP,i-1),
-                     // we use a method for generating irreducible secondaries that tends to 
-                     // produce a smaller output (which is good for subsequent computations). 
-                     // However, this method needs to much memory in high degrees, and so we 
+                     // we use a method for generating irreducible secondaries that tends to
+                     // produce a smaller output (which is good for subsequent computations).
+                     // However, this method needs to much memory in high degrees, and so we
                      // use a sparser method from degree #IrrSwitch# upwards.
   def br=basering;
@@ -5010 +5010 @@
                                        // of a certain degree -
   m=nrows(dimmat);                     // m-1 is the highest degree
-  if (v) 
+  if (v)
   { "There are";
     for (j=1;j<=m;j++)
@@ -5069 +5069 @@
   { if ((LastNewIS == i-3) and (UsePP==0))  // We guess that all irreducibles have been found!
     { if (v) {"Computing Groebner basis for primaries and previously found irreducibles...";}
-      TotalReductor = groebner(sP+IS); 
-      TotalSet = 1; 
+      TotalReductor = groebner(sP+IS);
+      TotalSet = 1;
     }
     if (int(dimmat[i,1])<>0)           // when it is == 0 we need to find no
@@ -5156 +5156 @@
                     attrib(RedSSort[i-1][k],"size",saveAttr);
                     if (v)
-                    { 
+                    {
                       "    We found reducible sec. inv. number "+string(counter);
                     }
@@ -5187 +5187 @@
       }
     } // if TotalSet==0
-    else 
+    else
     { if (v) {"  We don't compute Power Products!"; }
 // Instead of computing Power Products, we can compute a Groebner basis of the ideal
@@ -5193 +5193 @@
 // polynomial of degree i-1 belongs to this ideal if and only if it belongs to the sub-algebra
 // generated by primary and irreducible secondary invariants up to degree i-2.
-// Hence, if we find an invariant outside this ideal, it is an irreducible secondary 
+// Hence, if we find an invariant outside this ideal, it is an irreducible secondary
 // invariant of degree i-1.
 }
@@ -5231 +5231 @@
 // Compare the comments on the computation of reducible sec. inv.!
               while (j < ii) // we will break the loop if counter==int(dimmat[i,1])
-              { if ((j mod MonStep) == 0) 
+              { if ((j mod MonStep) == 0)
                 { if ((j+MonStep) <= ii)
                   { ideal tmp = normalize(evaluate_reynolds(REY,ideal(mon[j+1..j+MonStep])));
@@ -5260 +5260 @@
                     kill tmp;
                   }
-                } 
+                }
                 j++;
                 helpP = Indicator[j];
@@ -5303 +5303 @@
             { B=sort_of_invariant_basis(TotalReductor,REY,i-1,int(dimmat[i,1])*6);
             }
-                                       // B is a linearly independent set of reynolds  
+                                       // B is a linearly independent set of reynolds
                                        // images of monomials that do not occur
                                        // as leading monomials of the ideal spanned
-                                       // by primary and previously found irreducible 
+                                       // by primary and previously found irreducible
                                        // secondary invariants.
             if (TotalSet==0 && ncols(B)+counter==int(dimmat[i,1])) // then we can take all of B
@@ -5323 +5323 @@
             else
             { irrcounter=0;
-              j=0;                         // j goes through all of B 
+              j=0;                         // j goes through all of B
 // Compare the comments on the computation of reducible sec. inv.!
               ReducedCandidates = reduce(B,sP);
@@ -5960 +5960 @@
                 { ISSort[i-1] = ideal(B[j]);
                 }
-                if (v) 
-                { "    We found", irrcounter,"of", NrIS ,"irr. sec. inv. in degree ",i-1; 
+                if (v)
+                { "    We found", irrcounter,"of", NrIS ,"irr. sec. inv. in degree ",i-1;
                 }
                 Reductor = ideal(helpP);
@@ -6016 +6016 @@
                 { ISSort[i-1] = ideal(B[j]);
                 }
-                if (v) 
-                { "    We found", irrcounter,"of", NrIS ,"irr. sec. inv. in degree ",i-1; 
+                if (v)
+                { "    We found", irrcounter,"of", NrIS ,"irr. sec. inv. in degree ",i-1;
                 }
                 Reductor = ideal(helpP);
@@ -6099 +6099 @@
           hence the number of secondary invariants is the product of the degrees of
           primary invariants divided by the group order.
-          <secondary_and_irreducible_no_molien> should usually be faster and of more useful
+          <secondary_and_irreducibles_no_molien> should usually be faster and of more useful
           functionality.
-SEE ALSO: secondary_and_irreducible_no_molien
+SEE ALSO: secondary_and_irreducibles_no_molien
 EXAMPLE:  example secondary_no_molien; shows an example
 "
@@ -6759 +6759 @@
 THEORY:  Irred. secondary invariants are calculated by finding a basis (in terms of
          monomials) of the basering modulo primary and previously found secondary
-         invariants, mapping those to invariants with the Reynolds operator. Among 
-         these images we pick a maximal subset that is linearly independent modulo 
-         the primary and previously found secondary invariants, using Groebner basis 
+         invariants, mapping those to invariants with the Reynolds operator. Among
+         these images we pick a maximal subset that is linearly independent modulo
+         the primary and previously found secondary invariants, using Groebner basis
          techniques.
 EXAMPLE: example irred_secondary_no_molien; shows an example
@@ -6815 +6815 @@
     return();
   }
-  if (ncols(REY)<>n) 
+  if (ncols(REY)<>n)
   { "ERROR:   The second parameter ought to be the Reynolds operator.";
     return();
@@ -6838 +6838 @@
   degBound = 0;
   int d,block, counter, totalcount, monsize,i,j, fin,hlp;
-  poly helpP,lmp; 
+  poly helpP,lmp;
   block = 1;
   ideal mon, MON, Inv, IS,RedInv, NewIS, NewReductor;
@@ -6844 +6844 @@
   ideal sP = slimgb(ideal(P));
   int Max = vdim(sP);
-  if (Max<0) 
+  if (Max<0)
   { "ERROR:   The second parameter ought to be the Reynolds operator.";
     return();
@@ -6864 +6864 @@
         block=0; // Loops through the monomials
         while (block<monsize)
-        { if ((block mod MonStep) == 0) 
+        { if ((block mod MonStep) == 0)
           { if ((block+MonStep) <= monsize)
             { ideal tmp = normalize(evaluate_reynolds(REY,ideal(mon[block+1..block+MonStep])));
@@ -6879 +6879 @@
               kill tmp;
             }
-          } 
+          }
           block++;
           helpP = RedInv[block];
@@ -6891 +6891 @@
             NewIS[NewIScounter] = helpP;
             mon[block]=0;
-            Inv[block]=0; 
+            Inv[block]=0;
             RedInv[block]=0;
             NewReductor[1]=helpP;
@@ -6904 +6904 @@
           { degBound = 0;
             sIS = groebner(sIS);
-            fin=1;  
+            fin=1;
           }
         }
         else
         { degBound = d+1;
-          sIS = groebner(sIS+NewIS);  
+          sIS = groebner(sIS+NewIS);
           degBound = 0;
           fin = 0;
@@ -6915 +6915 @@
       }
       attrib(sIS,"isSB",1);
-    } // if degree d is not excluded by deg_vec 
+    } // if degree d is not excluded by deg_vec
     else
     { if (size(deg_vec)==l)
@@ -7963 +7963 @@
 ASSUME:   mon contains at least the minimal monomial in each orbit sum of degree d
           under the permutation group given by Per.
-RETURN:   an <ideal> whose generators are the orbit sums of degree d under the permutation 
+RETURN:   an <ideal> whose generators are the orbit sums of degree d under the permutation
           group given by Per.
 SEE ALSO: invariant_algebra_perm
@@ -7969 +7969 @@
 EXAMPLE: example orbit_sums; shows an example
 "
-{ 
+{
 //----------------- checking input ------------------
   mon=simplify(mon,2); // remove 0
@@ -7975 +7975 @@
   { "ERROR: Monomials in the first parameter must be of the same degree.";
     return();
-  } 
+  }
   int k,k2;
   for (k=1;k<=ncols(mon);k++)
@@ -7989 +7989 @@
       return();
     }
-    if ((ncols(M[k2])!=nvars(basering))     
+    if ((ncols(M[k2])!=nvars(basering))
      or (ncols(M[k2])!=ncols(simplify(M[k2],6)))
      or (M[k2][1]==0))
@@ -8029 +8029 @@
     { if ( mon[k]!=0)
       { if (tmpI[k] < mon[k])
-        { 
+        {
           mon[k]=0;
         }
         else
         { if (tmpI[k]>mon[k])
-          { 
+          {
             mon=NF(mon,std(tmpI[k]));
           }
@@ -8052 +8052 @@
   poly tmp;
   int GenOK, j,i;
-  poly OrbitS=mon[1];  
+  poly OrbitS=mon[1];
   mon[1]=0;
   int countOrbits;
@@ -8073 +8073 @@
         newL[k] = simplify(NF(newL[k],L[k]),2);
         attrib(newL[k],"isSB",1);
-        if (newL[k][1] != 0)  // i.e., the Orbit is not complete under all generators yet 
-        { GenOK=-1;    
+        if (newL[k][1] != 0)  // i.e., the Orbit is not complete under all generators yet
+        { GenOK=-1;
           L[k] = L[k],newL[k];
           attrib(L[k],"isSB",1);
@@ -8099 +8099 @@
     if (GenOK == 0)  // i.e., all orbits are complete, so we can break the iteration
     { break;
-    } 
+    }
   } // iterate
   degBound = dgb;
@@ -8112 +8112 @@
          orb;
 }
- 
+
 ///////////////////////////////////////////////////////////////////////////////
 
 proc invariant_algebra_perm (list #)
 "USAGE:    invariant_algebra_perm(GEN[,v]);
-@*        GEN: a list of generators of a permutation group. It is given in disjoint cycle 
-          form, where trivial cycles can be omitted; e.g., the generator (1,2)(3,4)(5) is 
+@*        GEN: a list of generators of a permutation group. It is given in disjoint cycle
+          form, where trivial cycles can be omitted; e.g., the generator (1,2)(3,4)(5) is
           given by <list(list(1,2),list(3,4))>.
 @*        v: an optional <int>
@@ -8124 +8124 @@
           by GEN, type <matrix>
 ASSUME:   We are in the non-modular case, i.e., the characteristic of the basering
-          does not divide the group order. Note that the function does not verify whether 
+          does not divide the group order. Note that the function does not verify whether
           the assumption holds or not
 DISPLAY:  Information on the progress of computations if v does not equal 0
@@ -8134 +8134 @@
 EXAMPLE:  example invariant_algebra_perm; shows an example
 "
-{ 
+{
 //----------------- checking input and setting verbose mode ------------------
   if (size(#)==0)
@@ -8192 +8192 @@
       NextCand, sGoffset, fin,MaxD,LastGDeg;
   ideal OrbSums, RedSums, NewReductor;
-  poly helpP,lmp; 
+  poly helpP,lmp;
 
 
@@ -8216 +8216 @@
   while ((fin==0) or (d<=MaxD))
   { if (v)
-    { "Searching generators in degree",d; 
+    { "Searching generators in degree",d;
     }
     counter = 0; // counts generators in degree d
@@ -8223 +8223 @@
     sGoffset=ncols(sG);
     OrbSize = ncols(OrbSums);
-    if (v) 
+    if (v)
     { "  We have "+string(OrbSize)+" orbit sums of degree "+string(d);
     }
 // loop through orbit_sum, and select generators among them
-    for (i=1;i<=OrbSize;i++)  
+    for (i=1;i<=OrbSize;i++)
     { helpP = RedSums[i];
       if (helpP<>0)
       { counter++; // found new inv. algebra generator!
         totalcount++;
-        if (v) 
+        if (v)
         { "    We found generator number "+string(totalcount)+
-          " in degree "+string(d); 
+          " in degree "+string(d);
         }
         G[totalcount] = OrbSums[i];
@@ -8256 +8256 @@
     { degBound=0;
       if (v) {"Presumably all generators have been found";}
-      sG = groebner(sG); 
+      sG = groebner(sG);
       fin = 0;
     }
@@ -8268 +8268 @@
     if ((fin==0) and (dim(sG)==0))
     { MaxD = maxdeg1(kbase(sG));
-      if (v) 
+      if (v)
       { if (MaxD>=d) {"We found the degree bound",MaxD; }
         else {"We found the degree bound",d-1;}
@@ -8277 +8277 @@
       }
       fin = 1;
-    } // computing degree bound  
+    } // computing degree bound
   } // for increasing degrees
   kill sG;
@@ -8295 +8295 @@
 proc invariant_algebra_reynolds (matrix REY, list #)
 "USAGE:    invariant_algebra_reynolds(REY[,v]);
-@*        REY: a gxn <matrix> representing the Reynolds operator of a finite matrix group, 
+@*        REY: a gxn <matrix> representing the Reynolds operator of a finite matrix group,
                where g ist the group order and n is the number of variables of the basering;
 @*        v: an optional <int>
@@ -8305 +8305 @@
 DISPLAY:  Information on the progress of computations if v does not equal 0
 THEORY:   We do an incremental search in increasing degree d. Generators of the invariant
-          ring are found among the Reynolds images of monomials of degree d. The generators are 
+          ring are found among the Reynolds images of monomials of degree d. The generators are
           chosen by Groebner basis techniques.
 SEE ALSO: invariant_algebra_perm
@@ -8318 +8318 @@
   int block, counter, totalcount, monsize,i,j,
       sGoffset, fin,MaxD,LastGDeg;
-  poly helpP,lmp; 
+  poly helpP,lmp;
   block = 1;
   ideal mon, MON, Inv, G;  // G will contain homog. alg.generators
@@ -8339 +8339 @@
       block=0; // Loops through the monomials
       while (block<monsize)
-      { if ((block mod MonStep) == 0) 
+      { if ((block mod MonStep) == 0)
         { if ((block+MonStep) <= monsize)
           { ideal tmp = normalize(evaluate_reynolds(REY,ideal(mon[block+1..block+MonStep])));
@@ -8354 +8354 @@
             kill tmp;
           }
-        } 
+        }
         block++;
         helpP = RedInv[block];
@@ -8367 +8367 @@
           NewG[NewGcounter] = helpP;
           mon[block]=0;
-          Inv[block]=0; 
+          Inv[block]=0;
           RedInv[block]=0;
           NewReductor[1]=helpP;
@@ -8387 +8387 @@
     { degBound=0;
       if (v) {"Presumably all generators have been found";}
-      sG = groebner(sG); 
+      sG = groebner(sG);
       fin = 0;
     }
@@ -8399 +8399 @@
     if ((fin==0) and (dim(sG)==0))
     { MaxD = maxdeg1(kbase(sG));
-      if (v) 
+      if (v)
       { if (MaxD>=d) {"We found the degree bound",MaxD; }
         else {"We found the degree bound",d-1;}
@@ -8408 +8408 @@
       }
       fin = 1;
-    } // computing degree bound  
+    } // computing degree bound
   } // for increasing degrees
   kill sG;