Changeset 8bb77b in git


Ignore:
Timestamp:
Dec 22, 2000, 3:57:44 PM (23 years ago)
Author:
Gert-Martin Greuel <greuel@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
a23294c03b4cae79224ffe24e90efc7e57c01fbc
Parents:
8942a5b3190ffdb5622125ddc7c005c0b1b725d2
Message:
* GMG: Kosmetik


git-svn-id: file:///usr/local/Singular/svn/trunk@4983 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular/LIB
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/rinvar.lib

    r8942a5 r8bb77b  
    1 ///////////////////////////////////////////////////////////////////////////////
    2 version="Id: rinvar.lib,v 1.0 2000/12/10 17:32:15 Singular Exp $";
     1// Last change 10.12.2000 (TB)
     2///////////////////////////////////////////////////////////////////////////////
     3version="$Id: rinvar.lib,v 1.5 2000-12-22 14:43:04 greuel Exp $";
    34category="Invariant theory";
    45info="
    5 LIBRARY:  rinvar.lib      PROCEDURES FOR INVARIANT RINGS OF REDUCTIVE GROUPS
    6 
    7 AUTHOR:   Thomas Bayer,    email: tbayer@in.tum.de
     6LIBRARY:  rinvar.lib      Invariant Rings of Reductive Groups
     7AUTHOR:   Thomas Bayer,   tbayer@in.tum.de
     8          http://wwwmayr.informatik.tu-muenchen.de/personen/bayert/
     9          Current Adress: Institut fuer Informatik, TU Muenchen
     10OVERVIEW:
     11 Implementation based on Derksen's algorithm. Written in the frame of the
     12 diploma thesis (advisor: Prof. Gert-Martin Greuel) 'Computations of moduli
     13 spaces of semiquasihomogenous singularities and an implementation in Singular'
    814
    915PROCEDURES:
    10  HilbertSeries(I, w)    Hilbert series of the ideal I w.r.t. weight w
    11  HilbertWeights(I, w)    weighted degrees of the generators of I
    12  ImageVariety(I, F)    ideal of the image variety F(variety(I))
    13  ImageGroup(G, F)    ideal of G w.r.t. the induced representation
    14  InvariantRing(G, Gaction)  generators of the invariant ring of G
    15  InvariantQ(f, G, Gaction)  decide if f is invariant w.r.t. G
    16  LinearizeAction(G, Gaction)  linearization of the action 'Gaction' of G
    17  LinearActionQ(action,s,t)    decide if action is linear in var(s..nvars)
    18  LinearCombinationQ(base, f)  decide if f is in the linear hull of 'base'
    19  MinimalDecomposition(f,s,t)  minimal decomposition of f (like coef)
    20  NullCone(G, act)    ideal of the nullcone of the action 'act' of G
    21  ReynoldsImage(RO,f)    image of f under the Reynolds operator 'RO'
    22  ReynoldsOperator(G, Gaction)  Reynolds operator of the group G
    23  SimplifyIdeal(I[,m,s])    simplify the ideal I (try to reduce variables)
    24  TransferIdeal(R,name,nA)  transfer the ideal 'name' from R to basering
     16 HilbertSeries(I, w);           Hilbert series of the ideal I w.r.t. weight w
     17 HilbertWeights(I, w);          weighted degrees of the generators of I
     18 ImageVariety(I, F);            ideal of the image variety F(variety(I))
     19 ImageGroup(G, F);              ideal of G w.r.t. the induced representation
     20 InvariantRing(G, Gaction);     generators of the invariant ring of G
     21 InvariantQ(f, G, Gaction);     decide if f is invariant w.r.t. G
     22 LinearizeAction(G, Gaction);   linearization of the action 'Gaction' of G
     23 LinearActionQ(action,s,t);     decide if action is linear in var(s..nvars)
     24 LinearCombinationQ(base, f);   decide if f is in the linear hull of 'base'
     25 MinimalDecomposition(f,s,t);   minimal decomposition of f (like coef)
     26 NullCone(G, act);              ideal of the nullcone of the action 'act' of G
     27 ReynoldsImage(RO,f);           image of f under the Reynolds operator 'RO'
     28 ReynoldsOperator(G, Gaction);  Reynolds operator of the group G
     29 SimplifyIdeal(I[,m,s]);        simplify the ideal I (try to reduce variables)
     30 TransferIdeal(R,name,nA);      transfer the ideal 'name' from R to basering
     31
     32SEE ALSO: qhmoduli.lib, zeroset.lib
    2533";
    26 
    27 // NOTE: This library has been written in the frame of the diploma thesis
    28 // 'Computing moduli spaces of semiquasihomogeneous singularites and an
    29 //  implementation in Singular', Arbeitsgruppe Algebraische Geometrie,
    30 // Fachbereich Mathematik, University Kaiserslautern,
    31 // Advisor: Prof. Gert-Martin Greuel
    32 
    3334
    3435LIB "presolve.lib";
    … …  
    4041proc EquationsOfEmbedding(ideal embedding, int nrs)
    4142"USAGE:   EquationsOfEmbedding(embedding, s); ideal embedding; int s;
    42 PURPOSE: compute the ideal of the variety parameterized by 'embedding' by
     43PUROPSE: compute the ideal of the variety parameterized by 'embedding' by
    4344         implicitation and change the variables to the old ones.
    4445RETURN:  ideal
    … …  
    7071proc ImageGroup(ideal Grp, ideal Gaction)
    7172"USAGE:   ImageGroup(G, action); ideal G, action;
    72 PURPOSE: compute the ideal of the image of G in GL(m,K) induced by the linear
     73PUROPSE: compute the ideal of the image of G in GL(m,K) induced by the linear
    7374         action 'action', where G is an algebraic group and 'action' defines
    7475         an action of G on K^m (size(action) = m).
    … …  
    8485         variables s(1)...s(r). The action 'action' is given by polynomials
    8586         f_1,...,f_m in basering, s.t. on the ring level we have
    86   K[t_1,...,t_m] --> K[s_1,...,s_r,t_1,...,t_m]/G
    87     t_i    --> f_i(s_1,...,s_r,t_1,...,t_m)
    88 
     87         K[t_1,...,t_m] --> K[s_1,...,s_r,t_1,...,t_m]/G
     88         t_i   -->  f_i(s_1,...,s_r,t_1,...,t_m)
    8989EXAMPLE: example ImageGroup; shows an example
    9090"
    … …  
    199199proc HilbertWeights(ideal I, wt)
    200200"USAGE:   HilbertWeights(I, w); ideal I, intvec wt
    201 PURPOSE: compute the weights of the "slack" varaibles needed for the
     201PUROPSE: compute the weights of the "slack" varaibles needed for the
    202202         computation of the algebraic relations of the generators of 'I' s.t.
    203203         the Hilbert driven 'std' can be used.
    … …  
    218218proc HilbertSeries(ideal I, wt)
    219219"USAGE:   HilbertSeries(I, w); ideal I, intvec wt
    220 PURPOSE: compute the polynomial p of the Hilbert Series,represented by p/q, of
     220PUROPSE: compute the polynomial p of the Hilbert Series,represented by p/q, of
    221221         the ring K[t_1,...,t_m,y_1,...,y_r]/I1 where 'w' are the weights of
    222222         the variables, computed, e.g., by 'HilbertWeights', 'I1' is of the
    … …  
    240240  return(hs1);
    241241}
     242///////////////////////////////////////////////////////////////////////////////
    242243
    243244proc HilbertSeries1(wt)
    244245"USAGE:   HilbertSeries1(wt); ideal I, intvec wt
    245 PURPOSE: compute the polynomial p of the Hilbert Series represented by p/q of
     246PUROPSE: compute the polynomial p of the Hilbert Series represented by p/q of
    246247         the ring K[t_1,...,t_m,y_1,...,y_r]/I where I is a complete inter-
    247248         section and the generator I[i] has degree wt[i]
    248249RETURN:  poly
    249 EXAMPLE:
    250250"
    251251{
    … …  
    273273proc ImageVariety(ideal I, F, list #)
    274274"USAGE:   ImageVariety(ideal I, F [, w]);ideal I; F is a list/ideal, intvec w.
    275 PURPOSE: compute the Zariski closure of the image of the variety of I under
     275PUROPSE: compute the Zariski closure of the image of the variety of I under
    276276         the morphism F.
    277277NOTE:    if 'I' and 'F' are quasihomogenous w.r.t. 'w' then the Hilbert-driven
    … …  
    359359proc LinearizeAction(ideal Grp, Gaction, int nrs)
    360360"USAGE:   LinearizeAction(G,action,r); ideal G, action; int r
    361 PURPOSE: linearize the group action 'action' and find an equivariant
    362          embedding of K^m where m = size(action).
     361PUROPSE: linearize the group action 'action' and find an equivariant embedding
     362         of K^m where m = size(action).
    363363ASSUME:  G contains only variables var(1..r) (r = nrs)
    364364basering = 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'
     365RETURN:  polynomial ring contianing the ideals 'actionid', 'embedid', 'groupid'
    366366         - 'actionid' is the ideal defining the linearized action of G
    367          - 'embedid' is a parameterization of an equivariant embedding
     367         - 'embedid' is a parameterization of an equivariant embedding (closed)
    368368         - 'groupid' is the ideal of G in the new ring
    369369NOTE:    set printlevel > 0 to see a trace
    … …  
    504504proc LinearActionQ(Gaction, int nrs)
    505505"USAGE:   LinearActionQ(action,nrs,nrt); ideal action, int nrs
    506 PURPOSE: check if the action defined by 'action' is linear wrt. the variables
     506PUROPSE: check if the action defined by 'action' is linear w.r.t. the variables
    507507         var(nrs + 1...nvars(basering)).
    508508RETURN:  0 action not linear
    … …  
    519519  loop = 1;
    520520  i = 1;
    521   while(loop){
     521  while(loop)
     522  {
    522523    if(deg(Gaction[i], wt) > 1) { loop = 0; }
    523     else {
     524    else
     525    {
    524526      i++;
    525527      if(i > ncols(Gaction)) { loop = 0;}
    … …  
    540542proc LinearCombinationQ(ideal I, poly f)
    541543"USAGE:   LinearCombination(I, f); ideal I, poly f
    542 PURPOSE: test if f can be written as a linear combination of the gens. of I
    543 RETURN:  0 'f' is not a linear combination
    544          1 'f' is a linear combination
     544PUROPSE: test if f can be written as a linear combination of the generators of I.
     545RETURN:  0 f is not a linear combination
     546         1 f is a linear combination
    545547"
    546548{
    … …  
    558560  loop = 1;
    559561  i = 1;
    560   while(loop) {        // look for a linear relation containing Y(nr)
    561     if(deg(imageid[i]) == 1) {
     562  while(loop)
     563  { // look for a linear relation containing Y(nr)
     564    if(deg(imageid[i]) == 1)
     565    {
    562566      coMx = coef(imageid[i], var(sizeJ));
    563       if(coMx[1,1] == var(sizeJ)) {
     567      if(coMx[1,1] == var(sizeJ))
     568      {
    564569        relation = imageid[i];
    565570        loop = 0;
    566571      }
    567572    }
    568     else {
     573    else
     574    {
    569575      i++;
    570576      if(i > ncols(imageid)) { loop = 0;}
    … …  
    578584proc InvariantRing(ideal G, ideal action, list #)
    579585"USAGE:   InvariantRing(G, Gact [, opt]); ideal G, Gact; int opt
    580 PURPOSE: compute generators of the invariant ring of G wrt. the action 'Gact'
     586PUROPSE: compute generators of the invariant ring of G w.r.t. the action 'Gact'
    581587ASSUME:  G is a finite group and 'Gact' is a linear action.
    582588RETURN:  polynomial ring over a simple extension of the groundfield of the
    … …  
    585591         - 'invars' contains the algebra-generators of the invariant ring
    586592         - 'groupid' is the ideal of G in the new ring
    587          - 'newA' if the minpoly changes this is the new representation of
    588            the algebraic number, otherwise it is set to 'a'.
     593         - 'newA' if the minpoly changes this is the new representation of the
     594           algebraic number, otherwise it is set to 'a'.
    589595NOTE:    the delivered ring might have a different minimal polynomial
    590596EXAMPLE: example InvariantRing; shows an example
    … …  
    636642        export(RORN);
    637643        ideal groupid = std(id);
    638                                 kill(id);
    639644        attrib(groupid, "isSB", 1);
    640645        ideal action = actionid;
    … …  
    701706proc InvariantQ(poly f, ideal G, action)
    702707"USAGE:   InvariantQ(f, G, action); poly f; ideal G, action
    703 PURPOSE: check if the polynomial f is invariant w.r.t. G where G acts via
     708PUROPSE: check if the polynomial f is invariant w.r.t. G where G acts via
    704709         'action' on K^m.
    705710ASSUME:  basering = K[s_1,...,s_m,t_1,...,t_m] where K = Q of K = Q(a) and
    … …  
    726731proc MinimalDecomposition(poly f, int nrs, int nrt)
    727732"USAGE:   MinimalDecomposition(f,a,b); poly f; int a, b.
    728 PURPOSE: decompose f as a sum M[1,1]*M[2,1] + ... + M[1,r]*M[2,r] where M[1,i]
    729          contains only s(1..a), M[2,i] contains only t(1...b) st. r is minimal
    730 ASSUME:  f polynomial in K[s(1..a),t(1..b)],K = Q or K = Q(a) and minpoly != 0
     733PUROPSE: decompose f as a sum M[1,1]*M[2,1] + ... + M[1,r]*M[2,r] where M[1,i]
     734         contains only s(1..a), M[2,i] contains only t(1...b) s.t. r is minimal
     735ASSUME:  f polynomial in K[s(1..a),t(1..b)], K = Q or K = Q(a) and minpoly != 0
    731736RETURN:  2 x r matrix M s.t.  f = M[1,1]*M[2,1] + ... + M[1,r]*M[2,r]
    732737EXAMPLE: example MinimalDecomposition;
    … …  
    822827proc NullCone(ideal G, action)
    823828"USAGE:   NullCone(G, action); ideal G, action
    824 PURPOSE: compute the ideal of the nullcone of the linear action of G on K^n,
     829PUROPSE: compute the ideal of the nullcone of the linear action of G on K^n,
    825830         given by 'action', by means of Deksen's algorithm
    826831ASSUME:  basering = K[s(1..r),t(1..n)], K = Q or K = Q(a) and minpoly != 0,
    … …  
    828833         'action' is a linear group action of G on K^n (n = ncols(action))
    829834RETURN:  ideal of the nullcone of G.
    830 NOTE:    the generators of the nullcone are homogenous, but ig. not invariant
     835NOTE:    the generators of the nullcone are homogenous, but i.g. not invariant
    831836EXAMPLE: example NullCone; shows an example
    832837"
    … …  
    897902proc ReynoldsOperator(ideal Grp, ideal Gaction, list #)
    898903"USAGE:   ReynoldsOperator(G, action [, opt); ideal G, action; int opt
    899 PURPOSE: compute the Reynolds operator of the group G which act via 'action'
     904PUROPSE: compute the Reynolds operator of the group G which act via 'action'
    900905RETURN:  polynomial ring R over a simple extension of the groundfield of the
    901906         basering (the extension might be trivial), containing a list
    … …  
    908913           basering does not contain a parameter then 'newA' = 'a'.
    909914ASSUME:  basering = K[s(1..r),t(1..n)], K = Q or K = Q(a') and minpoly != 0,
    910          G is the ideal of a finite group in K[s(1..r)],'action' is a linear
     915         G is the ideal of a finite group in K[s(1..r)], 'action' is a linear
    911916         group action of G
    912917EXAMPLE: example ReynoldsOperator; shows an example
    … …  
    956961proc ReynoldsImage(list reynoldsOp, poly f)
    957962"USAGE:   ReynoldsImage(RO, f); list RO, poly f
    958 PURPOSE: compute the Reynolds image of the polynomial f where RO represents
     963PUROPSE: compute the Reynolds image of the polynomial f where RO represents
    959964         the Reynolds operator
    960965RETURN:  poly
    … …  
    975980static proc SimplifyCoefficientMatrix(matrix coefMatrix)
    976981"USAGE:   SimplifyCoefficientMatrix(M); M matrix coming from coef(...)
    977 PURPOSE: simplify the matrix, i.e. find linear dependencies among the columns
     982PUROPSE: simplify the matrix, i.e. find linear dependencies among the columns
    978983RETURN:  matrix M, f = M[1,1]*M[2,1] + ... + M[1,n]*M[2,n]
    979984"
    … …  
    10101015
    10111016proc SimplifyIdeal(ideal I, list #)
    1012 "USAGE:   SimplifyIdeal(I [,m, name]); ideal I; int m, string name
     1017"USAGE:   SimplifyIdeal(I [,m, name]); ideal I; int m, string name"
    10131018PURPOSE: simplify ideal I to the ideal I', do not change the names of the
    10141019         first m variables, new ideal I' might contain less variables.
    … …  
    10161021RETURN: list
    10171022  _[1] ideal I'
    1018   _[2] ideal representing a map phi to a ring with probably less
    1019              varsiables s.t. phi(I) = I'
     1023  _[2] ideal representing a map phi to a ring with probably less vars. s.t.
     1024       phi(I) = I'
    10201025  _[3] list of variables
    10211026  _[4] list from 'elimpart'
    1022 NOTE:
    10231027"
    10241028{
    … …  
    10321036  mapId = sList[5];
    10331037
    1034   if(size(#) > 0) {
     1038  if(size(#) > 0)
     1039  {
    10351040    m = #[1];
    10361041    nameCMD = #[2];
    … …  
    10381043  else { m = 0;} // nvars(basering);
    10391044  k = 0;
    1040   for(i = 1; i <= nvars(basering); i++) {
    1041     if(sList[4][i] != 0) {
     1045  for(i = 1; i <= nvars(basering); i++)
     1046  {
     1047    if(sList[4][i] != 0)
     1048    {
    10421049      k++;
    10431050      if(k <= m) { mId[i] = sList[4][i]; }
    … …  
    10541061}
    10551062
    1056 ////////////////////////////////////////////////////////////////////////////////
     1063///////////////////////////////////////////////////////////////////////////////
    10571064
    10581065static proc TransferIdeal(R, string name, poly newA)
    10591066" USAGE:  TransferIdeal(R, name, newA); ring R, string name, poly newA
    1060 PURPOSE: Maps an ideal with name 'name' in R to the basering, s.t. all
     1067PUROPSE: Maps an ideal with name 'name' in R to the basering, s.t. all
    10611068         variables are fixed but par(1) is replaced by 'newA'.
    10621069RETURN:  ideal
    1063 NOTE:    this is used to transfor ideals if the minimal polynomial has changed
     1070NOTE:    this is used to transfor an ideal if the minimal polynomial has changed
    10641071"
    10651072{
    … …  
    10811088{
    10821089  poly f = 1;
    1083 
    1084   for(int i = 1; i <= size(index); i++) {
     1090  for(int i = 1; i <= size(index); i++)
     1091  {
    10851092    f = f * var(index[i]);
    10861093  }

  • Singular/LIB/sing.lib

    r8942a5 r8bb77b  
    1 // $Id: sing.lib,v 1.21 2000-12-19 15:05:34 anne Exp $
     1// $Id: sing.lib,v 1.22 2000-12-22 14:45:41 greuel Exp $
    22//(GMG/BM, last modified 26.06.96)
    33///////////////////////////////////////////////////////////////////////////////
    4 
    5 version="$Id: sing.lib,v 1.21 2000-12-19 15:05:34 anne Exp $";
     4version="$Id: sing.lib,v 1.22 2000-12-22 14:45:41 greuel Exp $";
    65category="Singularities";
    76info="
    8 LIBRARY:  sing.lib      PROCEDURES FOR SINGULARITIES
     7LIBRARY:  sing.lib      Invariants of Singularities
    98AUTHORS:  Gert-Martin Greuel, email: greuel@mathematik.uni-kl.de
    109          Bernd Martin, email: martin@math.tu-cottbus.de

  • Singular/LIB/solve.lib

    r8942a5 r8bb77b  
    11///////////////////////////////////////////////////////////////////////////////
    2 
    3 version="$Id: solve.lib,v 1.17 2000-12-19 15:05:35 anne Exp $";
     2version="$Id: solve.lib,v 1.18 2000-12-22 14:48:14 greuel Exp $";
    43category="Symbolic-numerical solving";
    54info="
    6 LIBRARY: solve.lib     PROCEDURES TO SOLVE POLYNOMIAL SYSTEMS
     5LIBRARY: solve.lib     Complex Solving of Polynomial Systems
    76AUTHOR:  Moritz Wenk,  email: wenk@mathematik.uni-kl.de
    87
    98PROCEDURES:
    10 ures_solve(i,..);      find all roots of 0-dimensional ideal i with resultants
    11 mp_res_mat(i,..);      multipolynomial resultant matrix of ideal i
    12 laguerre_solve(p,..);  find all roots of univariate polynom p
    13 interpolate(i,j,d);    interpolate poly from evaluation points i and results j
    14 
     9ures_solve(i,..);       find all roots of 0-dimensional ideal i with resultants
     10mp_res_mat(i,..);       multipolynomial resultant matrix of ideal i
     11laguerre_solve(p,..);   find all roots of univariate polynom p
     12interpolate(i,j,d);     interpolate poly from evaluation points i and results j
    1513fglm_solve(i,p,...);    find roots of 0-dim. ideal using FGLM and lex_solve
    1614triangL_solve(l,p,...); find roots using triangular system (Lazard)
    1715triangLf_solve(l,p,..); find roots using triangular sys. (factorizing Lazard)
    1816triangM_solve(l,p,...); find roots of given triangular system (Moeller)
    19 
    20 lex_solve(i,p,...);    find roots of reduced lexicographic standard basis
    21 triang_solve(l,p,...); find roots of given triangular system
    22 
    23 pcheck(i,l,...);       checks if elements (numbers) of l are roots of ideal i
     17lex_solve(i,p,...);     find roots of reduced lexicographic standard basis
     18triang_solve(l,p,...);  find roots of given triangular system
     19pcheck(i,l,...);        checks if elements (numbers) of l are roots of ideal i
    2420";
    2521
    26 LIB "triang.lib"; // needed for triang*_solve
     22LIB "triang.lib";    // needed for triang*_solve
    2723
    2824///////////////////////////////////////////////////////////////////////////////

  • Singular/LIB/spcurve.lib

    r8942a5 r8bb77b  
    1 // $Id: spcurve.lib,v 1.12 2000-12-19 15:05:36 anne Exp $
    21// (anne, last modified 31.5.99)
    32/////////////////////////////////////////////////////////////////////////////
    4 
    5 version="$Id: spcurve.lib,v 1.12 2000-12-19 15:05:36 anne Exp $";
     3version="$Id: spcurve.lib,v 1.13 2000-12-22 14:49:25 greuel Exp $";
    64category="Singularities";
    75info="
    8 LIBRARY: spcurve.lib    PROCEDURES FOR CM CODIMENSION 2 SINGULARITIES
     6LIBRARY: spcurve.lib    Deformations and Invariants of CM-codim 2 Singularities
    97AUTHOR:  Anne Fruehbis-Krueger, anne@mathematik.uni-kl.de
    108last modified: 31.5.99

  • Singular/LIB/spectrum.lib

    r8942a5 r8bb77b  
    1 // $Id: spectrum.lib,v 1.8 2000-12-19 15:05:37 anne Exp $
    21///////////////////////////////////////////////////////////////////////////////
    3 
    4 version="$Id: spectrum.lib,v 1.8 2000-12-19 15:05:37 anne Exp $";
     2version="$Id: spectrum.lib,v 1.9 2000-12-22 14:51:06 greuel Exp $";
    53category="Singularities";
    64info="
    7 LIBRARY:  spectrum.lib   PROCEDURES FOR COMPUTING SINGULARITY SPECTRA
     5LIBRARY:  spectrum.lib  Singularity Spectrum for Nondegenerate Singularities
     6AUTHOR:   S. Endrass
    87
    98PROCEDURES:
    10  spectrum(poly[,1]);    spectrum of a isolated singularity (with/without tests)
    11  semic(s1,s2[,1]);      tests if s2 is semicontinous for s1 using
    12                         half open intervalls
    13                         (and open intervalls for a 3rd paramater 1)
    14  semicqh(s1,s2[,1]);    tests if s2 is semicontinous for s1 using
    15                         open and half open intervalls
     9 spectrum(poly[,1]);    spectrum of a nondegenerate isolated singularity
     10 semic(s1,s2[,1]);      tests if s2 is semicontinous for s1 (open intervall)
     11 semicqh(s1,s2[,1]);    semicontinuity test with open and half open intervalls
    1612 spadd(s1,s2);          sum of two spectra s1 and s2
    1713 spmul(s,k);            multiplies the spectrum s with the int k
    … …  
    2319proc spectrum (poly f, list #)
    2420"USAGE:  spectrum(f[,1]);  f polynomial
     21ASSUME:  f has nondegenerate principal part
    2522         computes the spectrum of f
    2623         if a second argument 1 is given,

  • Singular/LIB/standard.lib

    r8942a5 r8bb77b  
    1 // $Id: standard.lib,v 1.51 2000-12-19 18:31:47 obachman Exp $
    21//////////////////////////////////////////////////////////////////////////////
    3 
    4 version="$Id: standard.lib,v 1.51 2000-12-19 18:31:47 obachman Exp $";
     2version="$Id: standard.lib,v 1.52 2000-12-22 14:52:32 greuel Exp $";
    53category="Miscellaneous";
    64info="
    7 LIBRARY: standard.lib   PROCEDURES WHICH ARE ALWAYS LOADED AT START-UP
     5LIBRARY: standard.lib   Procedures which are always loaded at Start-up
    86
    97PROCEDURES:
    … …  
    1311 quot(any,any[,n])      quotient using heuristically chosen method
    1412 res(ideal/module,[i])  free resolution of ideal or module
    15  sprintf(fmt,...)     returns fomatted string
    16  fprintf(link,fmt,..) writes formatted string to link
    17  printf(fmt,...)      displays formatted string
     13 sprintf(fmt,...)       returns fomatted string
     14 fprintf(link,fmt,..)   writes formatted string to link
     15 printf(fmt,...)        displays formatted string
    1816";
    1917

  • Singular/LIB/stratify.lib

    r8942a5 r8bb77b  
    1 // $Id: stratify.lib,v 1.4 2000-12-20 16:49:37 Singular Exp $
    21// (anne, last modified 23.5.00)
    32/////////////////////////////////////////////////////////////////////////////
    4 // LIBRARY HEADER
    5 /////////////////////////////////////////////////////////////////////////////
    6 
    7 version="$Id: stratify.lib,v 1.4 2000-12-20 16:49:37 Singular Exp $";
     3version="$Id: stratify.lib,v 1.5 2000-12-22 14:53:34 greuel Exp $";
    84category="Invariant theory";
    95info="
    10 LIBRARY: stratify.lib     ALGORITHMIC STRATIFICATION BY THE
    11                           Greuel-Pfister ALGORITHM
    12 AUTHOR:  Anne Fruehbis-Krueger, anne@mathematik.uni-kl.de
    13 
    14 PROCEDURES:
    15   prepMat(M,wr,ws,step);  list of submatrices corresp. to the given filtration
     6LIBRARY: stratify.lib   Algorithmic Stratification for Unipotent Group-Actions
     7AUTHOR:  Anne Fruehbis-Krueger, anne@mathematik.uni-kl.de
     8last modified: 12.12.2000
     9
     10Procedures:
     11  prepMat(M,wr,ws,step);  list of submatrices corresp. to given filtration
    1612  stratify(M,wr,ws,step); algorithmic stratifcation (main procedure)
    1713";

  • Singular/LIB/surf.lib

    r8942a5 r8bb77b  
    1 // $Id: surf.lib,v 1.14 2000-12-20 11:15:50 obachman Exp $
    2 //
    3 // author : Hans Schoenemann
    4 //
    51///////////////////////////////////////////////////////////////////////////////
    6 version="$Id: surf.lib,v 1.14 2000-12-20 11:15:50 obachman Exp $";
     2version="$Id: surf.lib,v 1.15 2000-12-22 14:54:43 greuel Exp $";
    73category="Visualization";
    84info="
    9 LIBRARY: surf.lib    PROCEDURES FOR GRAPHICS WITH SURF
    10 
    11 AUTHOR: surf is written by Stefan Endrass
     5LIBRARY: surf.lib    Procedures for Graphics with Surf
     6AUTHOR: Hans Schoenemann,
     7        the program surf is written by Stefan Endrass
    128
    139NOTE:
    14 @texinfo
    15 To use this library requires the program @code{surf} to be installed.
    16 @code{surf} is only available for Linux PCs and Sun workstations.
    17 You can download @code{surf} either from
    18  @uref{http://sourceforge.net/projects/surf}
    19  or from @uref{ftp://www.mathematik.uni-kl.de/pub/Math/Singular/utils/}.
    20 @end texinfo
     10 @texinfo
     11 To use this library requires the program @code{surf} to be installed.
     12 @code{surf} is only available for Linux PCs and Sun workstations.
     13 You can download @code{surf} either from
     14  @uref{http://sourceforge.net/projects/surf}
     15  or from @uref{ftp://www.mathematik.uni-kl.de/pub/Math/Singular/utils/}.
     16 @end texinfo
    2117
    2218PROCEDURES:
    … …  
    4642RETURN: nothing
    4743NOTE: requires the external program 'surf' to be installed
    48       @*If the (string) variable extra_surf_opts is defined, the the value of
    49       this
    5044EXAMPLE: example plot; shows an example
    5145"

  • Singular/LIB/template.lib

    r8942a5 r8bb77b  
    11////////////////////////////////////////////////////////////////////
    22// version string automatically expanded by CVS
    3 version="$Id: template.lib,v 1.8 2000-12-19 18:31:48 obachman Exp $";
     3
     4version="$Id: template.lib,v 1.9 2000-12-22 14:55:56 greuel Exp $";
     5category="Miscellaneous";
    46// summary description of the library
    5 category="Miscellaneous";
    67info="
    7 LIBRARY:   template.lib  A TEMPLATE FOR A SINGULAR LIBRARY
    8 
     8LIBRARY:   template.lib  A Template for a Singular Library
    99AUTHOR:    Olaf Bachmann, email: obachman@mathematik.uni-kl.de
    1010
    … …  
    2121////////////////////////////////////////////////////////////////////
    2222proc mdouble(int i)
    23 "USAGE:  mdouble(i); i int
    24 RETURN:  int: i+i
    25 NOTE:    Help string is in pure ASCII
    26          this line starts on a new line since previous line is short
    27          mdouble(i): no new line
     23"USAGE:    mdouble(i); i int
     24RETURN:   int: i+i
     25NOTE:     Help string is in pure ASCII
     26          this line starts on a new line since previous line is short
     27          mdouble(i): no new line
    2828SEE ALSO: msum, mtripple, Typesetting of help strings
    2929KEYWORDS: procedure, ASCII help
    30 EXAMPLE: example mdouble; shows an example"
     30EXAMPLE:  example mdouble; shows an example"
    3131{
    3232  return (i + i);

  • Singular/LIB/toric.lib

    r8942a5 r8bb77b  
    1 // version="$Id: toric.lib,v 1.8 2000-12-19 14:41:45 anne Exp $";
    2 
    31///////////////////////////////////////////////////////////////////////////////
     2version="$Id: toric.lib,v 1.9 2000-12-22 14:57:44 greuel Exp $";
    43category="Commutative Algebra";
    54info="
    6 LIBRARY: toric.lib                COMPUTING TORIC IDEALS
    7 
     5LIBRARY: toric.lib   Standard Basis of Toric Ideals
    86AUTHOR:  Christine Theis, email: ctheis@math.uni-sb.de
    97
    108PROCEDURES:
    11 
    12 toric_ideal(intmat A, string alg [,intvec prsv]);        computes the toric ideal of A
    13 
    14 toric_std(ideal I);        computes the standard basis of I using a specialized Buchberger algorithm
     9toric_ideal(A,..);   computes the toric ideal of A
     10toric_std(ideal I);  standard basis of I by a specialized Buchberger algorithm
    1511";
    1612
    1713///////////////////////////////////////////////////////////////////////////////
    18 
    19 
    2014
    2115static proc toric_ideal_1(intmat A, string alg)
    … …  
    351345  return(I);
    352346}
    353 
    354 
     347///////////////////////////////////////////////////////////////////////////////
    355348
    356349static proc toric_ideal_2(intmat A, string alg, intvec prsv)
    … …  
    668661  return(I);
    669662}
    670 
    671 
     663///////////////////////////////////////////////////////////////////////////////
    672664
    673665proc toric_ideal
    674 "USAGE:    toric_ideal(A,alg);      A intmat, alg string
    675            toric_ideal(A,alg,prsv); A intmat, alg string, prsv intvec
    676 RETURN:   ideal: standard basis of the toric ideal of A
    677 NOTE:     These procedures return the standard basis of the toric ideal of A with respect to the term ordering in the actual basering. Not all term orderings are supported: The usual global term orderings may be used, but no block orderings combining them.
    678 
    679 One may call the procedure with several different algorithms:
    680 
    681 - the algorithm of Conti/Traverso using elimination (ect),
    682 
    683 - the algorithm of Pottier (pt),
    684 
    685 - an algorithm of Bigatti/La Scala/Robbiano (blr),
    686 
    687 - the algorithm of Hosten/Sturmfels (hs),
    688 
    689 - the algorithm of DiBiase/Urbanke (du).
    690 
    691 The argument `alg' should be the abbreviation for an algorithm as above: ect, pt, blr, hs or du.
    692 
    693 If `alg' is chosen to be `blr' or `hs', the algorithm needs a vector with positive coefficcients in the row space of A. If no row of A contains only positive entries, one has to use the second version of toric_ideal which takes such a vector as its third argument.
    694 
    695 For the mathematical background, see
    696 @texinfo
    697 @ref{Toric ideals and integer programming}.
    698 @end texinfo
     666"USAGE: toric_ideal(A,alg);      A intmat, alg string
     667        toric_ideal(A,alg,prsv); A intmat, alg string, prsv intvec
     668RETURN: ideal: standard basis of the toric ideal of A
     669NOTE:   These procedures return the standard basis of the toric ideal of A
     670        with respect to the term ordering in the actual basering. Not all
     671        term orderings are supported: The usual global term orderings may be
     672        used, but no block orderings combining them.
     673        One may call the procedure with several different algorithms:
     674        - the algorithm of Conti/Traverso using elimination (ect),
     675        - the algorithm of Pottier (pt),
     676        - an algorithm of Bigatti/La Scala/Robbiano (blr),
     677        - the algorithm of Hosten/Sturmfels (hs),
     678        - the algorithm of DiBiase/Urbanke (du).
     679       The argument `alg' should be the abbreviation for an algorithm as
     680       above: ect, pt, blr, hs or du.
     681
     682      If `alg' is chosen to be `blr' or `hs', the algorithm needs a vector
     683      with positive coefficcients in the row space of A.
     684      If no row of A contains only positive entries, one has to use the
     685      second version of toric_ideal which takes such a vector as its third
     686      argument.
     687      For the mathematical background, see
     688  @texinfo
     689  @ref{Toric ideals and integer programming}.
     690  @end texinfo
    699691EXAMPLE:  example toric_ideal; shows an example
    700692SEE ALSO: toric_std, toric_lib, intprog_lib, Toric ideals
    … …  
    735727
    736728}
    737 
    738 
     729///////////////////////////////////////////////////////////////////////////////
    739730
    740731proc toric_std(ideal I)
    741732"USAGE:   toric_std(I);      I ideal
    742733RETURN:   ideal: standard basis of I
    743 NOTE:     This procedure computes the standard basis of I using a specialized Buchberger algorithm. The generating system by which I is given has to consist of binomials of the form x^u-x^v. There is no real check if I is toric. If I is generated by binomials of the above form, but not toric, toric_std computes an ideal `between' I and its saturation with respect to all variables.
    744 For the mathematical background, see
    745 @texinfo
    746 @ref{Toric ideals and integer programming}.
    747 @end texinfo
     734NOTE:     This procedure computes the standard basis of I using a specialized
     735          Buchberger algorithm. The generating system by which I is given has
     736          to consist of binomials of the form x^u-x^v. There is no real check
     737          if I is toric. If I is generated by binomials of the above form,
     738          but not toric, toric_std computes an ideal `between' I and its
     739          saturation with respect to all variables.
     740          For the mathematical background, see
     741   @texinfo
     742   @ref{Toric ideals and integer programming}.
     743   @end texinfo
    748744EXAMPLE:  example toric_std; shows an example
    749745SEE ALSO: toric_ideal, toric_lib, intprog_lib, Toric ideals
    … …  
    10771073  return(J);
    10781074}
    1079 
    1080 
    10811075
    10821076example
    … …  
    11101104sat(H,xyz);
    11111105}
     1106///////////////////////////////////////////////////////////////////////////////
Note: See TracChangeset for help on using the changeset viewer.