Changeset 8942a5 in git


Ignore:
Timestamp:
Dec 22, 2000, 3:33:13 PM (22 years ago)
Author:
Gert-Martin Greuel <greuel@…>
Branches:
(u'spielwiese', '828514cf6e480e4bafc26df99217bf2a1ed1ef45')
Children:
8bb77bfee92151ac9ed599c9d789653dc8a3570c
Parents:
803c5a17d620ffa41d14efaab791dcf17ad1f7a4
Message:
* GMG: Kosmetik


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/homolog.lib

    r803c5a1 r8942a5  
    1 // $Id: homolog.lib,v 1.11 2000-12-19 14:41:42 anne Exp $
    21//(BM/GMG)
    32///////////////////////////////////////////////////////////////////////////////
    4 
    5 version="$Id: homolog.lib,v 1.11 2000-12-19 14:41:42 anne Exp $";
     3version="$Id: homolog.lib,v 1.12 2000-12-22 14:05:48 greuel Exp $";
    64category="Commutative Algebra";
    75info="
    8 LIBRARY:  homolog.lib   PROCEDURES FOR HOMOLOGICAL ALGEBRA
    9 
     6LIBRARY:  homolog.lib   Procedures for Homological Algebra
    107AUTHORS:  Gert-Martin Greuel, email: greuel@mathematik.uni-kl.de,
    118          Bernd Martin, email: martin@math.tu-cottbus.de
    … …  
    9592   kb1 = matrix(ker)*kb1;
    9693   dbprint(p-1,"// kbase of Ext^1(M,M)",
    97                "//  - the columns present the kbase elements in Hom(F(1),F(0))",
    98                "//  - F(*) a free resolution of M",kb1);
     94              "//  - the columns present the kbase elements in Hom(F(1),F(0))",
     95              "//  - F(*) a free resolution of M",kb1);
    9996
    10097//------ compute the liftings of Ext^1 ----------------------------------------
    … …  
    634631    for( ii=1; ii<=s; ii++ )
    635632    { k=v[ii];
    636       if( k<0  )                                    // Ext^k is 0 for negative k
     633      if( k<0  )                                   // Ext^k is 0 for negative k
    637634      { dbprint(p-1,"// Ext^k=0 for k<0!");
    638635        extMN    = gen(1);
    … …  
    712709  printlevel = p;
    713710}
    714 ////////////////////////////////////////////////////////////////////////////////
     711///////////////////////////////////////////////////////////////////////////////
    715712
    716713proc Hom (module M, module N, list #)
    … …  
    773770        {  for (l=1;l<=ncols(kb);l=l+1)
    774771           {
    775              "// element",l,"of kbase of Hom in Hom(F0,G0) as matrix: F0-->G0:";
     772            "// element",l,"of kbase of Hom in Hom(F0,G0) as matrix: F0-->G0:";
    776773             print(matrix(ideal(kb[l]),nrows(N),nrows(M)));
    777774           }
    778775        }
    779776        else
    780        { dbprint(p-1,"// columns of matrix are kbase of Hom in Hom(F0,G0)",kb); }
     777       {dbprint(p-1,"// columns of matrix are kbase of Hom in Hom(F0,G0)",kb);}
    781778        L=homMN,homMN0,kb; return(L);
    782779     }
    … …  
    808805  printlevel = p;
    809806}
    810 ////////////////////////////////////////////////////////////////////////////////
     807///////////////////////////////////////////////////////////////////////////////
    811808
    812809proc homology (matrix A,matrix B,module M,module N,list #)
    … …  
    817814              ker(B)/im(A) := ker(M'/im(A) --B--> N'/im(BM)+im(BA)).
    818815         If B induces a map M'--B-->N' (i.e BM=0) and if R^k--A-->M'--B-->N' is
    819          a complex (i.e. BA=0) then ker(B)/im(A) is the homology of this complex
     816         a complex (i.e. BA=0) then ker(B)/im(A) is the homology of the complex
    820817RETURN:  module H, a presentation of ker(B)/im(A)
    821818NOTE:    homology returns a free module of rank m if ker(B)=im(A)
    … …  
    878875  print(K);
    879876}
    880 ////////////////////////////////////////////////////////////////////////////////
     877///////////////////////////////////////////////////////////////////////////////
    881878
    882879proc kohom (matrix M, int j)
    … …  
    899896  print(kohom(n,3));
    900897}
    901 /////////////////////////////////////////////////////////////////////////////////
     898///////////////////////////////////////////////////////////////////////////////
    902899
    903900proc kontrahom (matrix M, int j)

  • Singular/LIB/inout.lib

    r803c5a1 r8942a5  
    1 // $Id: inout.lib,v 1.18 2000-12-19 14:37:25 anne Exp $
    21// (GMG/BM, last modified 22.06.96)
    32///////////////////////////////////////////////////////////////////////////////
    4 
    5 version="$Id: inout.lib,v 1.18 2000-12-19 14:37:25 anne Exp $";
     3version="$Id: inout.lib,v 1.19 2000-12-22 14:06:55 greuel Exp $";
    64category="General purpose";
    75info="
    8 LIBRARY:  inout.lib     PROCEDURES FOR MANIPULATING IN- AND OUTPUT
     6LIBRARY:  inout.lib     Printing and Manipulating In- and Output
    97
    108PROCEDURES:

  • Singular/LIB/intprog.lib

    r803c5a1 r8942a5  
    1 version="$Id: intprog.lib,v 1.2 2000-12-19 14:41:42 anne Exp $";
     1///////////////////////////////////////////////////////////////////////////////
     2version="$Id: intprog.lib,v 1.3 2000-12-22 14:08:19 greuel Exp $";
    23category="Commutative Algebra";
     4info="
     5LIBRARY: intprog.lib      Integer Programming with Groebner Basis Methods
     6AUTHOR:  Christine Theis, email: ctheis@math.uni-sb.de
     7
     8PROCEDURES:
     9 solve_IP(..);   procedures for solving Integer Programming  problems
     10";
     11
    312///////////////////////////////////////////////////////////////////////////////
    4 
    5 info="
    6 LIBRARY: intprog.lib      INTEGER PROGRAMMING WITH GROEBNER BASIS METHODS
    7 
    8 AUTHOR:  Christine Theis, email: ctheis@math.uni-sb.de
    9 
    10 PROCEDURES:
    11 
    12 solve_IP(intmat A, [intvec|list] bx, intvec c, string alg [, intvec prsv]);
    13     procedures for solving IP-problems
    14 ";
    15 
    16 ///////////////////////////////////////////////////////////////////////////////
    17 
    18 
    19 
    2013static proc solve_IP_1(intmat A, intvec bx, intvec c, string alg)
    2114{
    … …  
    167160  return(v);
    168161}
    169 
    170 
    171 
     162///////////////////////////////////////////////////////////////////////////////
    172163static proc solve_IP_2(intmat A, list bx, intvec c, string alg)
    173164{
    … …  
    346337  return(l);
    347338}
    348 
    349 
     339///////////////////////////////////////////////////////////////////////////////
    350340
    351341static proc solve_IP_3(intmat A, intvec bx, intvec c, string alg, intvec prsv)
    … …  
    480470  return(v);
    481471}
    482 
    483 
     472///////////////////////////////////////////////////////////////////////////////
    484473
    485474static proc solve_IP_4(intmat A, list bx, intvec c, string alg, intvec prsv)
    … …  
    641630  return(l);
    642631}
    643 
    644 
    645 
    646 
    647 
     632///////////////////////////////////////////////////////////////////////////////
    648633
    649634proc solve_IP
    650 "USAGE:   solve_IP(A,bx,c,alg);       A intmat, bx intvec, c intvec, alg string
    651 
    652           solve_IP(A,bx,c,alg);       A intmat, bx list of intvec, c intvec, alg string
    653 
    654           solve_IP(A,bx,c,alg,prsv);  A intmat, bx intvec, c intvec, alg string, prsv intvec
    655 
    656           solve_IP(A,bx,c,alg,prsv);  A intmat, bx list of intvec, c intvec, alg string, prsv intvec
    657 RETURN:   type of bx: solution of the associated integer programming problem(s) as explained in
    658 @texinfo
    659 @ref{Toric ideals and integer programming}.
    660 @end texinfo
    661 NOTE:     This procedure returns the solution(s) of the given IP-problem(s) or the message `not solvable'.
    662 
    663 One may call the procedure with several different algorithms:
    664 
    665 - the algorithm of Conti/Traverso using elimination (ect),
    666 
    667 - the algorithm of Pottier (pt),
    668 
    669 - an algorithm of Bigatti/La Scala/Robbiano (blr),
    670 
    671 - the algorithm of Hosten/Sturmfels (hs),
    672 
    673 - the algorithm of DiBiase/Urbanke (du).
    674 
    675 The argument `alg' should be the abbreviation for an algorithm as above: ect, pt, blr, hs or du.
    676 
    677 `ct' allows to compute an optimal solution of the IP-problem directly from the right-hand vector b. The same is true for its `positive' variant `pct' which may only be applied if A and b have nonnegative entries. All other algorithms need initial solutions of the IP-problem.
    678 
    679 If `alg' is chosen to be `ct' or `pct', bx is read as the right hand vector b of the system Ax=b. b should then be an intvec of size m where m is the number of rows of A. Furthermore, bx and A should be nonnegative if `pct' is used. If `alg' is chosen to be `ect',`pt',`blr',`hs' or `du', bx is read as an initial solution x of the system Ax=b. bx should then be a nonnegative intvec of size n where n is the number of columns of A.
    680 
    681 If `alg' is chosen to be `blr' or `hs', the algorithm needs a vector with positive coefficients in the row space of A. If no row of A contains only positive entries, one has to use the versions of solve_IP which take such a vector prsv as an argument.
    682 
    683 solve_IP may also be called with a list bx of intvecs instead of a single intvec.
     635"USAGE:  solve_IP(A,bx,c,alg);  A intmat, bx intvec, c intvec, alg string
     636        solve_IP(A,bx,c,alg);  A intmat, bx list of intvec, c intvec,
     637                                 alg string
     638        solve_IP(A,bx,c,alg,prsv);  A intmat, bx intvec, c intvec,
     639                                 alg string, prsv intvec
     640        solve_IP(A,bx,c,alg,prsv);  A intmat, bx list of intvec, c intvec,
     641                                 alg string, prsv intvec
     642RETURN: type of bx: solution of the associated integer programming
     643        problem(s) as explained in
     644   @texinfo
     645   @ref{Toric ideals and integer programming}.
     646   @end texinfo
     647NOTE:   This procedure returns the solution(s) of the given IP-problem(s)
     648        or the message `not solvable'.
     649        One may call the procedure with several different algorithms:
     650        - the algorithm of Conti/Traverso using elimination (ect),
     651        - the algorithm of Pottier (pt),
     652        - an algorithm of Bigatti/La Scala/Robbiano (blr),
     653        - the algorithm of Hosten/Sturmfels (hs),
     654        - the algorithm of DiBiase/Urbanke (du).
     655        The argument `alg' should be the abbreviation for an algorithm as
     656        above: ect, pt, blr, hs or du.
     657
     658        `ct' allows to compute an optimal solution of the IP-problem
     659        directly from the right-hand vector b.
     660        The same is true for its `positive' variant `pct' which may only be
     661        applied if A and b have nonnegative entries.
     662        All other algorithms need initial solutions of the IP-problem.
     663
     664        If `alg' is chosen to be `ct' or `pct', bx is read as the right hand
     665        vector b of the system Ax=b. b should then be an intvec of size m
     666        where m is the number of rows of A.
     667        Furthermore, bx and A should be nonnegative if `pct' is used.
     668        If `alg' is chosen to be `ect',`pt',`blr',`hs' or `du',
     669        bx is read as an initial solution x of the system Ax=b.
     670        bx should then be a nonnegative intvec of size n where n is the
     671        number of columns of A.
     672
     673        If `alg' is chosen to be `blr' or `hs', the algorithm needs a vector
     674        with positive coefficients in the row space of A.
     675        If no row of A contains only positive entries, one has to use the
     676        versions of solve_IP which take such a vector prsv as an argument.
     677
     678        solve_IP may also be called with a list bx of intvecs instead of a
     679        single intvec.
     680SEE ALSO: intprog_lib, toric_lib, Integer programming
    684681EXAMPLE:  example solve_IP; shows an example
    685 SEE ALSO: intprog_lib, toric_lib, Integer programming
    686682"
    687683{
    … …  
    713709
    714710example
    715 {
    716 "EXAMPLE"; echo=2;
    717 
    718 // call with single right-hand vector
    719 intmat A[2][3]=1,1,0,0,1,1;
    720 A;
    721 intvec b1=1,1;
    722 b1;
    723 intvec c=2,2,1;
    724 c;
    725 intvec solution_vector=solve_IP(A,b1,c,"pct");
    726 solution_vector;
    727 
    728 // call with list of right-hand vectors
    729 intvec b2=-1,1;
    730 list l=b1,b2;
    731 l;
    732 list solution_list=solve_IP(A,l,c,"ct");
    733 solution_list;
    734 
    735 // call with single initial solution vector
    736 A=2,1,-1,-1,1,2;
    737 A;
    738 b1=3,4,5;
    739 solution_vector=solve_IP(A,b1,c,"du");
    740 
    741 // call with single initial solution vector
    742 // and algorithm needing a positive row space vector
    743 solution_vector=solve_IP(A,b1,c,"hs");
    744 
    745 // call with single initial solution vector
    746 // and positive row space vector
    747 intvec prsv=1,2,1;
    748 prsv;
    749 solution_vector=solve_IP(A,b1,c,"hs",prsv);
    750 solution_vector;
    751 
    752 // call with list of initial solution vectors
    753 // and positive row space vector
    754 b2=7,8,0;
    755 l=b1,b2;
    756 l;
    757 solution_list=solve_IP(A,l,c,"blr",prsv);
    758 solution_list;
     711{ "EXAMPLE"; echo=2;
     712  // 1. call with single right-hand vector
     713  intmat A[2][3]=1,1,0,0,1,1;
     714  intvec b1=1,1;
     715  intvec c=2,2,1;
     716  intvec solution_vector=solve_IP(A,b1,c,"pct");
     717  solution_vector;"";
     718
     719  // 2. call with list of right-hand vectors
     720  intvec b2=-1,1;
     721  list l=b1,b2;
     722  l;
     723  list solution_list=solve_IP(A,l,c,"ct");
     724  solution_list;"";
     725
     726  // 3. call with single initial solution vector
     727  A=2,1,-1,-1,1,2;
     728  b1=3,4,5;
     729  solve_IP(A,b1,c,"du");"";
     730
     731  // 4. call with single initial solution vector
     732  //    and algorithm needing a positive row space vector
     733  solution_vector=solve_IP(A,b1,c,"hs");"";
     734
     735  // 5. call with single initial solution vector
     736  //     and positive row space vector
     737  intvec prsv=1,2,1;
     738  solution_vector=solve_IP(A,b1,c,"hs",prsv);
     739  solution_vector;"";
     740
     741  // 6. call with list of initial solution vectors
     742  //    and positive row space vector
     743  b2=7,8,0;
     744  l=b1,b2;
     745  l;
     746  solution_list=solve_IP(A,l,c,"blr",prsv);
     747  solution_list;
    759748}

  • Singular/LIB/jordan.lib

    r803c5a1 r8942a5  
    11///////////////////////////////////////////////////////////////////////////////
    2 
    3 version="$Id: jordan.lib,v 1.18 2000-12-19 14:37:25 anne Exp $";
     2version="$Id: jordan.lib,v 1.19 2000-12-22 14:09:44 greuel Exp $";
    43category="Linear Algebra";
    54info="
    6 LIBRARY: jordan.lib  PROCEDURES TO COMPUTE THE JORDAN NORMAL FORM
     5LIBRARY: jordan.lib  Jordan Normal Form of a Matrix with rational Eigenvalues
    76AUTHOR:  Mathias Schulze, email: mschulze@mathematik.uni-kl.de
    87

  • Singular/LIB/latex.lib

    r803c5a1 r8942a5  
    1 // $Id: latex.lib,v 1.12 2000-12-19 15:05:28 anne Exp $
    2 //                        1998/04/17
    3 // author : Christian Gorzel email: gorzelc@math.uni-muenster.de
    4 //
    51///////////////////////////////////////////////////////////////////////////////
    6 
    7 version="$Id: latex.lib,v 1.12 2000-12-19 15:05:28 anne Exp $";
     2version="$Id: latex.lib,v 1.13 2000-12-22 14:11:33 greuel Exp $";
    83category="Visualization";
    94info="
    10 LIBRARY: latex.lib    PROCEDURES FOR TYPESET OF SINGULAROBJECTS IN LATEX2E
    11 
     5LIBRARY: latex.lib    Typesetting of Singular-Objects in LaTex2e
    126AUTHOR: Christian Gorzel, gorzelc@math.uni-muenster.de
    137
    … …  
    3024GLOBAL VARIABLES:
    3125  TeXwidth, TeXnofrac, TeXbrack, TeXproj, TeXaligned, TeXreplace, NoDollars
    32                   are used to control the typesetting
    33     Call example texdemo; to become familiar with the features of latex.lib
    34 
     26  are used to control the typesetting
     27  Call example texdemo; to become familiar with the features of latex.lib
    3528
    3629  TeXwidth      : int: -1,0,1..9, >9  controls the breaking of long polynomials
    … …  
    31173110  return();
    31183111 }
     3112///////////////////////////////////////////////////////////////////////////////

  • Singular/LIB/linalg.lib

    r803c5a1 r8942a5  
    1 //
    2 //      last modified: 04/25/2000 by GMG
    3 //////////////////////////////////////////////////////////////////////////////
    4 
    5 version="$Id: linalg.lib,v 1.6 2000-12-19 14:37:26 anne Exp $";
     1//GMG last modified: 04/25/2000
     2//////////////////////////////////////////////////////////////////////////////
     3version="$Id: linalg.lib,v 1.7 2000-12-22 14:12:32 greuel Exp $";
    64category="Linear Algebra";
    75info="
    8 LIBRARY:  linalg.lib    PROCEDURES FOR ALGORITHMIC LINEAR ALGEBRA
     6LIBRARY:  linalg.lib    Algorithmic Linear Algebra
    97AUTHOR:   Ivor Saynisch (ivs@math.tu-cottbus.de)
    108
    … …  
    3230
    3331//////////////////////////////////////////////////////////////////////////////
    34 
    35 //////////////////////////////////////////////////////////////////////////////
    3632// help functions
    3733//////////////////////////////////////////////////////////////////////////////
    38 static
    39 proc abs(poly c)
     34static proc abs(poly c)
    4035"RETURN: absolut value of c, c must be constants"
    4136{
    … …  
    6560  return(1); 
    6661}
    67 static
    68 proc red(matrix A,int i,int j)
     62//////////////////////////////////////////////////////////////////////////////
     63static proc red(matrix A,int i,int j)
    6964"USAGE:    red(A,i,j);  A = constant matrix
    7065          reduces column j with respect to A[i,i] and column i
    … …  
    9186}
    9287
    93 //proc sp(vector v1,vector v2)
     88//////////////////////////////////////////////////////////////////////////////
    9489proc inner_product(vector v1,vector v2)
    9590"RETURN:   inner product <v1,v2> "
    … …  
    9994  return ((transpose(matrix(v1,k,1))*matrix(v2,k,1))[1,1]);
    10095}
    101 
    10296
    10397/////////////////////////////////////////////////////////////////////////////
    … …  
    515509}
    516510
    517 
    518511//////////////////////////////////////////////////////////////////////////////
    519512proc inverse_B(matrix A)
    … …  
    560553}
    561554
    562 
    563555//////////////////////////////////////////////////////////////////////////////
    564556proc det_B(matrix A)
    … …  
    575567  L=busadj(A);
    576568  return((-1)^n*L[1][1]);
    577  
    578  
    579569}
    580570example
    … …  
    585575  det_B(A);
    586576}
    587 
    588577
    589578//////////////////////////////////////////////////////////////////////////////
    … …  
    820809}
    821810
    822 
    823811//////////////////////////////////////////////////////////////////////////////
    824812proc gauss_nf(matrix A)
    … …  
    929917}
    930918
    931 
    932919//////////////////////////////////////////////////////////////////////////////
    933920proc pos_def(matrix A)
    … …  
    991978}
    992979
    993 
    994980//////////////////////////////////////////////////////////////////////////////
    995981proc linsolve(matrix A, matrix b)

  • Singular/LIB/makedbm.lib

    r803c5a1 r8942a5  
    1 // $Id: makedbm.lib,v 1.10 2000-12-19 18:31:47 obachman Exp $
    2 //=========================================================================
    3 //
    4 // Please send bugs and comments to krueger@mathematik.uni-kl.de
    5 //
    6 //=============================================================================
    7 
    8 version="$Id: makedbm.lib,v 1.10 2000-12-19 18:31:47 obachman Exp $";
     1///////////////////////////////////////////////////////////////////////////////
     2version="$Id: makedbm.lib,v 1.11 2000-12-22 14:14:05 greuel Exp $";
    93category="Miscellaneous";
    104info="
    11 LIBRARY:  makedbm.lib     some usefull tools needed by the Arnold-Classifier.
    12 
    13    dbm_read(l);          read all entries from a DBM-databaes pointed by l
    14    dbm_getnext(l);       read next entry from a DBM-databaes pointed by l
    15    create_sing_dbm();
    16    read_sing_dbm();
     5LIBRARY:  makedbm.lib     Data Base of Singularities for the Arnold-Classifier
     6AUTHOR:   Kai Krueger, krueger@mathematik.uni-kl.de
     7
     8PROCEDURES:
     9 dbm_read(l);          read all entries from a DBM-databaes pointed by l
     10 dbm_getnext(l);       read next entry from a DBM-databaes pointed by l
     11 create_sing_dbm();
     12 read_sing_dbm();
    1713";
    1814

  • Singular/LIB/matrix.lib

    r803c5a1 r8942a5  
    1 // $Id: matrix.lib,v 1.14 2000-12-19 14:37:26 anne Exp $
    21// GMG/BM, last modified: 8.10.98
    32///////////////////////////////////////////////////////////////////////////////
    4 
    5 version="$Id: matrix.lib,v 1.14 2000-12-19 14:37:26 anne Exp $";
     3version="$Id: matrix.lib,v 1.15 2000-12-22 14:15:05 greuel Exp $";
    64category="Linear Algebra";
    75info="
    8 LIBRARY:  matrix.lib    PROCEDURES FOR MATRIX OPERATIONS
     6LIBRARY:  matrix.lib    Elementary Matrix Operations
    97
    108PROCEDURES:
    … …  
    463461{
    464462   int i,j;
    465    matrix C=B;
    466    for( i=2; i<=nrows(A); i=i+1 ) { C=dsum(C,B); }
    467    matrix D[nrows(C)][ncols(A)*nrows(B)];
    468    for( j=1; j<=nrows(B); j=j+1 )
    469    {
    470       for( i=1; i<=nrows(A); i=i+1 )
    471       {
    472          D[(i-1)*nrows(B)+j,(j-1)*ncols(A)+1..j*ncols(A)]=A[i,1..ncols(A)];
    473       }
    474    }
    475    return(concat(C,D));
     463   matrix C,D;
     464   for( i=1; i<=nrows(A); i++ )
     465   {
     466     C = A[i,1]*B;
     467     for( j=2; j<=ncols(A); j++ )
     468     {
     469       C = concat(C,A[i,j]*B);
     470     } 
     471     D = concat(D,transpose(C));
     472   }
     473   D = transpose(D);
     474   return(submat(D,2..nrows(D),1..ncols(D)));
    476475}
    477476example

  • Singular/LIB/mondromy.lib

    r803c5a1 r8942a5  
    11///////////////////////////////////////////////////////////////////////////////
    2 
    3 version="$Id: mondromy.lib,v 1.17 2000-12-19 15:05:30 anne Exp $";
     2version="$Id: mondromy.lib,v 1.18 2000-12-22 14:16:11 greuel Exp $";
    43category="Singularities";
    54info="
    6 LIBRARY:  mondromy.lib  PROCEDURES TO COMPUTE THE MONODROMY OF A SINGULARITY
     5LIBRARY:  mondromy.lib  Monodromy of an Isolated Hypersurface Singularity
    76AUTHOR:   Mathias Schulze, email: mschulze@mathematik.uni-kl.de
    87
    … …  
    1514
    1615PROCEDURES:
     16 detadj(U);            determinant and adjoint matrix of square matrix U
    1717 invunit(u,n);         series inverse of polynomial u up to order n
    18  detadj(U);            determinant and adjoint matrix of square matrix U
    1918 jacoblift(f);         lifts f^kappa in jacob(f) with minimal kappa
    2019 monodromy(f[,opt]);   monodromy of isolated hypersurface singularity f

  • Singular/LIB/mregular.lib

    r803c5a1 r8942a5  
    1 // $Id: mregular.lib,v 1.3 2000-12-19 14:41:43 anne Exp $
    21// IB/PG/GMG, last modified:  21.7.2000
    32//////////////////////////////////////////////////////////////////////////////
    4 version = "$Id: mregular.lib,v 1.3 2000-12-19 14:41:43 anne Exp $";
     3version = "$Id: mregular.lib,v 1.4 2000-12-22 14:17:21 greuel Exp $";
    54category="Commutative Algebra";
    65info="
    7 LIBRARY: mregular.lib       PROCEDURES FOR THE CASTELNUOVO-MUMFORD REGULARITY
    8 AUTHORS: I.Bermejo, email: ibermejo@ull.es
    9          Ph.Gimenez, email: pgimenez@agt.uva.es
    10          G.-M.Greuel, email: greuel@mathematik.uni-kl.de
     6LIBRARY: mregular.lib   Castelnuovo-Mumford Regularity of CM-Schemes and Curves
     7AUTHORS: I.Bermejo,     ibermejo@ull.es
     8         Ph.Gimenez,   pgimenez@agt.uva.es
     9         G.-M.Greuel,   greuel@mathematik.uni-kl.de
    1110
    12 A library for computing the Castelnuovo-Mumford regularity of a subscheme of
    13 the projective n-space that DOES NOT require the computation of a minimal
    14 graded free resolution of the saturated ideal defining the subscheme.
     11OVERVIEW:
     12 A library for computing the Castelnuovo-Mumford regularity of a subscheme of
     13 the projective n-space that DOES NOT require the computation of a minimal
     14 graded free resolution of the saturated ideal defining the subscheme.
     15 The procedures are based on two papers by Isabel Bermejo and Philippe Gimenez:
     16 'On Castelnuovo-Mumford regularity of projective curves' Proc.Amer.Math.Soc.
     17 128(5) (2000), and 'Computing the Castelnuovo-Mumford regularity of some
     18 subschemes of Pn using quotients of monomial ideals', Proceedings of
     19 MEGA-2000, J. Pure Appl. Algebra (to appear).
     20 The algorithm assumes the variables to be in Noether position.
    1521
    1622PROCEDURES:
    … …  
    1824 reg_curve(id,[,e]); regularity of projective curve V(id_sat) in Pn
    1925 reg_moncurve(li);   regularity of projective monomial curve defined by li
     26";
    2027
    21 REMARK:
    22 The procedures are based on two papers by Isabel Bermejo and Philippe Gimenez:
    23 'On Castelnuovo-Mumford regularity of projective curves'
    24  Proc.Amer.Math.Soc. 128(5) (2000), and
    25 'Computing the Castelnuovo-Mumford regularity of some subschemes of Pn using
    26  quotients of monomial ideals',
    27  Proceedings of MEGA-2000, J. Pure Appl. Algebra (to appear).
    28 
    29 IMPORTANT:
    30 To use the first two procedures, the variables must be in Noether
    31 position, i.e. that the polynomial ring in the last variables must be a
    32 Noether normalization of basering/id.
    33 If it is not the case, you should compute a Noether normalization before,
    34 e.g. by using the procedure noetherNormal from algebra.lib.
    35 ";
    36 //
    3728LIB "general.lib";
    38 LIB "elim.lib";
     29LIB "algebra.lib";
    3930LIB "sing.lib";
    4031LIB "poly.lib";
    4132//////////////////////////////////////////////////////////////////////////////
    42 //
     33
    4334proc reg_CM (ideal i)
    4435"
    … …  
    4839         the field K is infinite, and S/i-sat is Cohen-Macaulay.
    4940         Assume that K[x(n-d),...,x(n)] is a Noether normalization of S/i-sat
    50          where d=dim S/i -1.
     41         where d=dim S/i -1. If this is not the case, compute a Noether
     42         normalization e.g. by using the proc noetherNormal from algebra.lib.
    5143NOTE:    The output is reg(X)=reg(i-sat) where X is the arithmetically
    5244         Cohen-Macaulay subscheme of the projective n-space defined by i.
    … …  
    147139   reg_CM(i);
    148140}
     141
     142///////////////////////////////////////////////////////////////////////////////
    149143/*
    150144Out-commented examples:
    … …  
    195189*/
    196190//////////////////////////////////////////////////////////////////////////////
    197 //
     191
    198192proc reg_curve (ideal i, list #)
    199193"
    … …  
    494488   reg_curve(j);
    495489}
     490
     491///////////////////////////////////////////////////////////////////////////////
    496492/*
    497493Out-commented examples:
    … …  
    552548*/
    553549//////////////////////////////////////////////////////////////////////////////
    554 //
     550
    555551proc reg_moncurve (list #)
    556552"
    … …  
    774770   reg_moncurve(0,1,3,5,6);
    775771}
     772///////////////////////////////////////////////////////////////////////////////
    776773/*
    777774Out-commented examples:
    … …  
    811808//
    812809*/
    813 //
    814810//////////////////////////////////////////////////////////////////////////////
    815 //
     811

  • Singular/LIB/normal.lib

    r803c5a1 r8942a5  
    11///////////////////////////////////////////////////////////////////////////////
    2 // normal.lib
    3 // algorithms for computing the normalization based on
    4 // the criterion of Grauert/Remmert and ideas of De Jong & Vasconcelos
    5 ///////////////////////////////////////////////////////////////////////////////
    6 
    7 version="$Id: normal.lib,v 1.27 2000-12-19 14:41:43 anne Exp $";
     2version="$Id: normal.lib,v 1.28 2000-12-22 14:18:34 greuel Exp $";
    83category="Commutative Algebra";
    94info="
    10 LIBRARY:  normal.lib     PROCEDURES FOR NORMALIZATION
    11 AUTHORS:  Gert-Martin Greuel, email: greuel@mathematik.uni-kl.de,
    12           Gerhard Pfister, email: pfister@mathematik.uni-kl.de
     5LIBRARY:  normal.lib     Normalization of Affine Rings
     6AUTHORS:  G.-M. Greuel  greuel@mathematik.uni-kl.de,
     7          G. Pfister    pfister@mathematik.uni-kl.de
    138
    149PROCEDURES:
    … …  
    2419LIB "inout.lib";
    2520///////////////////////////////////////////////////////////////////////////////
    26 static
    27 proc isR_HomJR (list Li)
     21static proc isR_HomJR (list Li)
    2822"USAGE:   isR_HomJR (Li);  Li = list: ideal SBid, ideal J, poly p
    2923COMPUTE: module Hom_R(J,R) = R:J and compare with R
    … …  
    376370
    377371///////////////////////////////////////////////////////////////////////////////
     372
    378373proc normal(ideal id, list #)
    379374"USAGE:   normal(i [,choose]);  i a radical ideal, choose empty or 1
    380375         if choose=1 the normalization of the associated primes is computed
    381376         (which is sometimes more efficient)
     377ASSUME:  The ideal must be radical, for non radical ideals the output may
     378         be wrong (i=radical(i); makes i radical)
    382379RETURN:  a list of rings (say nor), in each ring nor[i] are two ideals
    383380         norid, normap such that the direct sum of the rings nor[i]/norid is
    … …  
    386383NOTE:    to use the i-th ring type: def R=nor[i]; setring R;
    387384         increasing printlevel displays more comments (default: printlevel=0)
    388 COMMENT: Not implemented for local or mixed orderings.
     385        Not implemented for local or mixed orderings.
    389386         If the input ideal i is weighted homogeneous a weighted ordering may
    390387         be used (qhweight(i); computes weights).
    391 CAUTION: The proc does not check whether the input is radical, for non radical
    392          ideals the output may be wrong (i=radical(i); makes i radical)
    393388EXAMPLE: example normal; shows an example
    394389"
    … …  
    536531
    537532///////////////////////////////////////////////////////////////////////////////
    538 static
    539 proc normalizationPrimes(ideal i,ideal ihp, list #)
     533static proc normalizationPrimes(ideal i,ideal ihp, list #)
    540534"USAGE:   normalizationPrimes(i,ihp[,si]);  i prime ideal, ihp map
    541535         (partial normalization), si SB of singular locus
    … …  
    11331127}
    11341128///////////////////////////////////////////////////////////////////////////////
    1135 static
    1136 proc substpart(ideal endid, ideal endphi, int homo, intvec rw)
     1129static proc substpart(ideal endid, ideal endphi, int homo, intvec rw)
    11371130
    11381131"//Repeated application of elimpart to endid, until no variables can be
    … …  
    14171410ring r=0,(u,v,w,x,y,z),wp(1,1,1,3,2,1);
    14181411ideal i=wx,wy,wz,vx,vy,vz,ux,uy,uz,y3-x2;
    1419 
    1420 
    1421 
    14221412*/
    14231413

  • Singular/LIB/ntsolve.lib

    r803c5a1 r8942a5  
    11//(GMG, last modified 16.12.00)
    22///////////////////////////////////////////////////////////////////////////////
    3 version="$Id: ntsolve.lib,v 1.9 2000-12-19 15:05:31 anne Exp $";
     3version="$Id: ntsolve.lib,v 1.10 2000-12-22 14:20:04 greuel Exp $";
    44category="Symbolic-numerical solving";
    55info="
    6 LIBRARY:  ntsolve.lib     REAL NEWTON SOLVING OF POLYNOMIAL SYSTEMS
     6LIBRARY:  ntsolve.lib     Real Newton Solving of Polynomial Systems
    77AUTHORS:  Wilfred Pohl, email: pohl@mathematik.uni-kl.de
    88          Dietmar Hillebrand

  • Singular/LIB/paramet.lib

    r803c5a1 r8942a5  
    1 // $Id: paramet.lib,v 1.7 2000-12-19 15:05:31 anne Exp $
    2 // author : Thomas Keilen email: keilen@mathematik.uni-kl.de
    31// last change:           05.12.2000
    42///////////////////////////////////////////////////////////////////////////////
    5 version="$Id: paramet.lib,v 1.7 2000-12-19 15:05:31 anne Exp $";
     3version="$Id: paramet.lib,v 1.8 2000-12-22 14:20:59 greuel Exp $";
    64category="Visualization";
    75info="
    8 LIBRARY: paramet.lib   PROCEDURES FOR PARAMETRIZATIONS
    9 AUTHOR:  Thomas Keilen, email: keilen@mathematik.uni-kl.de
     6LIBRARY: paramet.lib   Parametrization of Varieties
     7AUTHOR:  Thomas Keilen, keilen@mathematik.uni-kl.de
    108
    119OVERVIEW:
    1210 A library to compute parametrizations of algebraic varieties (if possible)
    13  with the aid of a primary decomposition, respectively to compute a
    14  parametrization of a plane curve singularity with the aid of a
     11 with the aid of a normalization, or a primary decomposition, resp. to compute
     12 a parametrization of a plane curve singularity with the aid of a
    1513 Hamburger-Noether expansion.
    1614
    … …  
    2624///////////////////////////////////////////////////////////////////////////////
    2725
    28 
    2926proc parametrize(ideal I)
    30 "USAGE:  parametrize(); I ideal in an arbitrary number of variables,
     27"USAGE:  parametrize(I); I ideal in an arbitrary number of variables,
    3128         whose radical is prime, in a ring with global ordering
    3229RETURN:  a list containing the parametrization ideal resp. the original ideal,
    … …  
    9996  ring RING=0,(x,y,z),dp;
    10097  ideal I=z2-y2x2+x3;
    101   parametrize(I);parametrize(I);
     98  parametrize(I);
    10299}
    103100///////////////////////////////////////////////////////////////////////////////
    104101
    105 
    106 
    107102proc parametrizepd(ideal I)
    108 "USAGE:  parametrizepd(); I ideal in a polynomial ring with global ordering
     103"USAGE:  parametrizepd(I); I ideal in a polynomial ring with global ordering
    109104RETURN:  a list of lists, where each entry contains the parametrization
    110105         of a primary component of I resp. 0, the number of variables
    … …  
    184179/////////////////////////////////////////////////////////////////////////////
    185180
    186 
    187 
    188181proc parametrizesing(poly f)
    189182"USAGE:  parametrizesing(); f a polynomial in two variables,ordering ls or ds
    190 RETURN:  a list containing the parametrizations of the different branches of the
    191          singularity at the origin resp. 0, if f was not of the desired kind
     183RETURN:  a list of ideals, each ideal parametrizes a branch of the
     184         singularity at the origin; resp. 0, if f was not of the desired kind
    192185CREATE:  If the parametrization is successful, the basering will be changed to
    193186         the parametrization ring, that is to the ring  0,(x,y),ls;

  • Singular/LIB/poly.lib

    r803c5a1 r8942a5  
    1 // $Id: poly.lib,v 1.28 2000-12-19 14:37:26 anne Exp $
    2 //(GMG, last modified 22.06.96)
    3 //(obachman: 17.12.97 -- added katsura)
    4 //(anne: 11.12.2000 -- added mod2id, id2mod, subrInterred)
    5 ///////////////////////////////////////////////////////////////////////////////
    6 
    7 version="$Id: poly.lib,v 1.28 2000-12-19 14:37:26 anne Exp $";
     1///////////////////////////////////////////////////////////////////////////////
     2version="$Id: poly.lib,v 1.29 2000-12-22 14:22:23 greuel Exp $";
    83category="General purpose";
    94info="
    10 LIBRARY:  poly.lib      PROCEDURES FOR MANIPULATING POLYS, IDEALS, MODULES
     5LIBRARY:  poly.lib      Procedures for Manipulating Polys, Ideals, Modules
     6AUTHORS:  O. Bachmann, G.-M: Greuel, A. Fruehbis
    117
    128PROCEDURES:
    … …  
    6864"USAGE: katsura([n]): n integer
    6965RETURN: katsura(n) : n-th katsura ideal of
    70                       (1) newly created and set ring (32003, x(0..n), dp), if
    71                           nvars(basering) < n
    72                       (2) basering, if nvars(basering) >= n
     66         (1) newly created and set ring (32003, x(0..n), dp), if
     67             nvars(basering) < n
     68         (2) basering, if nvars(basering) >= n
    7369        katsura()  : katsura ideal of basering
    7470EXAMPLE: example katsura; shows examples
    … …  
    820816
    821817proc subrInterred(ideal mon, ideal sm, intvec iv)
    822 "USAGE:    subrInterred(mon,sm,iv);
    823           sm:   ideal in a ring r with n + s variables,
    824                 e.g. x_1,..,x_n and t_1,..,t_s
    825           mon:  ideal with monomial generators (not divisible by
    826                 one of the t_i) such that sm is contained in the module
    827                 k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)]
    828           iv:   intvec listing the variables which are supposed to be used
    829                 as x_i
    830 RETURN:   list l:
     818"USAGE:   subrInterred(mon,sm,iv);
     819         sm:   ideal in a ring r with n + s variables,
     820               e.g. x_1,..,x_n and t_1,..,t_s
     821         mon:  ideal with monomial generators (not divisible by
     822               one of the t_i) such that sm is contained in the module
     823               k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)]
     824         iv:   intvec listing the variables which are supposed to be used
     825               as x_i
     826RETURN:  list l:
    831827          l[1]=the monomials from mon in the order used
    832828          l[2]=their coefficients after interreduction
    833829          l[3]=l[1]*l[2]
    834                (interreduced system of generators of sm seen as a submodule
    835                 of k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)])
    836 EXAMPLE:  example subrInterred; shows an example"
     830          (interreduced system of generators of sm seen as a submodule
     831          of k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)])
     832EXAMPLE: example subrInterred; shows an example"
    837833{
    838834  int p = printlevel-voice+3;  // p=printlevel+1 (default: p=1)

  • Singular/LIB/presolve.lib

    r803c5a1 r8942a5  
    1 // $Id: presolve.lib,v 1.14 2000-12-19 15:05:32 anne Exp $
    2 //(GMG)
    3 ///////////////////////////////////////////////////////////////////////////////
    4 
    5 version="$Id: presolve.lib,v 1.14 2000-12-19 15:05:32 anne Exp $";
     1///////////////////////////////////////////////////////////////////////////////
     2version="$Id: presolve.lib,v 1.15 2000-12-22 14:23:35 greuel Exp $";
    63category="Symbolic-numerical solving";
    74info="
    8 LIBRARY:  presolve.lib     PROCEDURES FOR PRE-SOLVING POLYNOMIAL EQUATIONS
     5LIBRARY:  presolve.lib     Pre-Solving of Polynomial Equations
    96AUTHOR:   Gert-Martin Greuel, email: greuel@mathematik.uni-kl.de,
    107

  • Singular/LIB/primdec.lib

    r803c5a1 r8942a5  
    1 // $Id: primdec.lib,v 1.80 2000-12-19 14:41:44 anne Exp $
    21///////////////////////////////////////////////////////////////////////////////
    3 // primdec.lib                                                               //
    4 // algorithms for primary decomposition based on                             //
    5 // the ideas of Gianni,Trager,Zacharias                                      //
    6 // written by Gerhard Pfister                                                //
    7 //                                                                           //
    8 // algorithms for primary decomposition based on                             //
    9 // the ideas of Shimoyama/Yokoyama                                           //
    10 // written by Wolfram Decker and Hans Schoenemann                            //
    11 ///////////////////////////////////////////////////////////////////////////////
    12 
    13 version="$Id: primdec.lib,v 1.80 2000-12-19 14:41:44 anne Exp $";
     2version="$Id: primdec.lib,v 1.81 2000-12-22 14:24:36 greuel Exp $";
    143category="Commutative Algebra";
    154info="
    16 LIBRARY: primdec.lib   PROCEDURES FOR PRIMARY DECOMPOSITION
     5LIBRARY: primdec.lib   Primary Decomposition and Radical of Ideals
    176AUTHORS:  Gerhard Pfister, email: pfister@mathematik.uni-kl.de (GTZ)
    187          Wolfram Decker, email: decker@math.uni-sb.de         (SY)
    198          Hans Schoenemann, email: hannes@mathematik.uni-kl.de (SY)
    209
     10OVERVIEW:
     11 Algorithms for primary decomposition based on the ideas of
     12 Gianni,Trager,Zacharias was written by Gerhard Pfister.                       
     13 Algorithms for primary decomposition based on the ideas of
     14 Shimoyama/Yokoyama was written by Wolfram Decker and Hans Schoenemann.   
     15 These procedures are implemented to be used in characteristic 0.
     16 @*They also work in positive characteristic >> 0.
     17 @*In small characteristic and for algebraic extensions, primdecGTZ,
     18 minAssGTZ, radical and equiRadical may not terminate and primdecSY and
     19 minAssChar may not give a complete decomposition.
     20
    2121PROCEDURES:
    22   primdecGTZ(I);    complete primary decomposition via Gianni,Trager,Zacharias
    23   primdecSY(I...);  complete primary decomposition via Shimoyama-Yokoyama
    24   minAssGTZ(I);     the minimal associated primes via Gianni,Trager,Zacharias
    25   minAssChar(I...); the minimal associated primes using characteristic sets
    26   testPrimary(L,k); tests the result of the primary decomposition
    27   radical(I);       computes the radical of the ideal I
    28   equiRadical(I);   the radical of the equidimensional part of the ideal I
    29   prepareAss(I);    list of radicals of the equidimensional components of I
    30   equidim(I);       weak equidimensional decomposition of I
    31   equidimMax(I);    equidimensional locus of I
    32   equidimMaxEHV(I); equidimensional locus of I via Eisenbud,Huneke,Vasconcelos
    33   zerodec(I);       zerodimensional decomposition via Monico
    34 
    35 REMARK:
    36 These procedures are implemented to be used in characteristic 0.
    37 @*They also work in positive characteristic >> 0.
    38 @*In small characteristic and for algebraic extensions, primdecGTZ,
    39 minAssGTZ, radical and equiRadical may not terminate and primdecSY and
    40 minAssChar may not give a complete decomposition.  ";
     22 primdecGTZ(I);    complete primary decomposition via Gianni,Trager,Zacharias
     23 primdecSY(I...);  complete primary decomposition via Shimoyama-Yokoyama
     24 minAssGTZ(I);     the minimal associated primes via Gianni,Trager,Zacharias
     25 minAssChar(I...); the minimal associated primes using characteristic sets
     26 testPrimary(L,k); tests the result of the primary decomposition
     27 radical(I);       computes the radical of the ideal I
     28 equiRadical(I);   the radical of the equidimensional part of the ideal I
     29 prepareAss(I);    list of radicals of the equidimensional components of I
     30 equidim(I);       weak equidimensional decomposition of I
     31 equidimMax(I);    equidimensional locus of I
     32 equidimMaxEHV(I); equidimensional locus of I via Eisenbud,Huneke,Vasconcelos
     33 zerodec(I);       zerodimensional decomposition via Monico
     34";
    4135
    4236LIB "general.lib";
    … …  
    47024696RETURN:  a list of primary ideals, the zero-dimensional decomposition of I
    47034697ASSUME:  I is zero-dimensional, the characterisitic of the ground field is 0
    4704 NOTE:    the algorithm,due to C. Monico, works well only good for small total
     4698NOTE:    the algorithm (of C. Monico), works well only for small total
    47054699         number of solutions (i.e. vdim(std(I)) should be < 100)
    4706          and without parameters. In practise, it works also in big
     4700         and without parameters. In practice, it works also in big
    47074701         characteristic p>0 but may fail for small p.
    47084702         If printlevel > 0 (default = 0) additional information is displayed

  • Singular/LIB/primitiv.lib

    r803c5a1 r8942a5  
    1 // $Id: primitiv.lib,v 1.12 2000-12-19 14:41:45 anne Exp $
    2 // last change:            12.08.99
     1// last change ML: 12.08.99
    32///////////////////////////////////////////////////////////////////////////////
    43// This library is for Singular 1.2 or newer
    54
    6 version="$Id: primitiv.lib,v 1.12 2000-12-19 14:41:45 anne Exp $";
     5version="$Id: primitiv.lib,v 1.13 2000-12-22 14:25:37 greuel Exp $";
    76category="Commutative Algebra";
    87info="
    9 LIBRARY:    primitiv.lib    PROCEDURES FOR FINDING A PRIMITIVE ELEMENT
     8LIBRARY:    primitiv.lib    Computing a Primitive Element
    109AUTHOR:     Martin Lamm,    email: lamm@mathematik.uni-kl.de
     10
    1111PROCEDURES:
    1212 primitive(ideal i);   find minimal polynomial for a primitive element
    … …  
    1515";
    1616
    17 ///////////////////////////////////////////////////////////////////////////////
    1817LIB "random.lib";
    1918///////////////////////////////////////////////////////////////////////////////
    … …  
    2120proc primitive(ideal i)
    2221"USAGE:   primitive(i); i ideal of the following form:
    23  Let k be the ground field of your basering, a_1,...,a_n algebraic over k, @*
    24  m_1(x_1), m_2(x_1,x_2),...,m_n(x_1,...,x_n) polynomials in k such that    @*
    25  m_j(a_1,...,a_(j-1),x_j) is minimal polynomial for a_j over k(a_1,...,a_(j-1))
    26                                                         for all j=1,...,n.
    27  Then i has to be generated by m_1,...,m_n.
    28 
    29 RETURN:  ideal j in k[x_n] such that
    30  j[1] is minimal polynomial for a primitive element b of k(a_1,...,a_n)=k(b)
    31          over k
    32  j[2],...,j[n+1] polynomials in k[x_n] : j[i+1](b)=a_i for i=1,...,n
    33 NOTE:    the number of variables in the basering has to be exactly the number n
    34          of given algebraic elements (and minimal polynomials).
    35 
    36          If k has few elements it can be that no one of the linear combinations
    37          of a_1,...,a_n is a primitive element. In this case `primitive'
    38          returns the zero ideal. If this occurs use primitive_extra instead.
     22          Let k be the ground field of your basering, a_1,...,a_n algebraic
     23          over k, m_1(x_1), m_2(x_1,x_2),...,m_n(x_1,...,x_n) polynomials over
     24          k such that  m_j(a_1,...,a_(j-1),x_j) is minimal polynomial for
     25          a_j over k(a_1,...,a_(j-1)) for all j=1,...,n.
     26          Then i has to be generated by m_1,...,m_n.
     27RETURN:   ideal j in k[x_n] such that
     28          j[1] is minimal polynomial for a primitive element b of
     29          k(a_1,...,a_n)=k(b) over k
     30          j[2],...,j[n+1] polynomials in k[x_n] : j[i+1](b)=a_i for i=1,...,n
     31NOTE:     the number of variables in the basering has to be exactly the number
     32          n of given algebraic elements (and minimal polynomials).
     33          If k has few elements it may happen that no linear combination
     34          of a_1,...,a_n is a primitive element. In this case `primitive'
     35          returns the zero ideal. If this occurs use primitive_extra instead.
    3936SEE ALSO: primitive_extra
    4037KEYWORDS: primitive element
    41 EXAMPLE: example primitive;  shows an example
     38EXAMPLE:  example primitive;  shows an example
    4239"
    4340{
    … …  
    141138proc primitive_extra(ideal i)
    142139"USAGE:   primitive_extra(i);  ideal i=f,g;  with the following properties: @*
    143  Let k=Q or k=Z/pZ be the ground field of the basering, a,b algebraic over k,
    144  x the name of the first ring variable, y the name of the second, then:     @*
    145  f is the minimal polynomial of a in k[x], g is a polynomial in k[x,y] s.t.
    146  g(a,y) is the minimal polynomial of b in k(a)[y]
    147 
     140          Let k=Q or k=Z/pZ be the ground field of the basering, a,b algebraic
     141          over k, x the name of the first ring variable, y the name of the
     142          second, then:
     143          f is the minimal polynomial of a in k[x], g is a polynomial in
     144          k[x,y] s.t. g(a,y) is the minimal polynomial of b in k(a)[y]
    148145RETURN:  ideal j in k[y] such that
    149  j[1] is minimal polynomial over k for a primitive element c of k(a,b)=k(c) @*
    150  j[2] is a polynomial s.t. j[2](c)=a
    151 
    152 NOTE: - While `primitive' may fail for finite fields, this proc tries all
    153         elements of k(a,b) and hence finds by assurance a primitive element.
    154         In order to do this (try all elements) field extensions like Z/pZ(a)
    155         are not allowed for the ground field k.
    156       - primitive_extra assumes that g is monic as polynomial in (k[x])[y]
     146         j[1] is minimal polynomial over k for a primitive element c of
     147         k(a,b)=k(c)
     148         j[2] is a polynomial s.t. j[2](c)=a
     149NOTE:   While `primitive' may fail for finite fields, this proc tries all
     150         elements of k(a,b) and hence finds by assurance a primitive element.
     151         In order to do this (try all elements) field extensions like Z/pZ(a)
     152         are not allowed for the ground field k.
     153        primitive_extra assumes that g is monic as polynomial in (k[x])[y]
    157154EXAMPLE: example primitive_extra;  shows an example
    158155"
    … …  
    248245
    249246proc splitring
    250 "USAGE:  splitring(f,R[,L]);  f poly, univariate and irreducible(!) over the
     247"USAGE:   splitring(f,R[,L]);  f poly, univariate and irreducible(!) over the
    251248         active basering; R string, L list of polys and/or ideals (optional)
    252 CREATE: a ring with name R, in which f is reducible, and change to it.
    253         If the old ring has no parameter, the name 'a' is chosen for the
    254         parameter of R (if a is no variable; if it is, the proc takes 'b',
    255         etc.; if a,b,c,o are variables of the ring, produce an error message),
    256         otherwise the name of the parameter is kept and only the
    257         minimal polynomial is changed.
    258         The names of variables and orderings are not affected.
    259 
    260         It is also allowed to call splitring with R==\"\". Then the old basering
    261         will be REPLACED by the new ring (with the same name as the old ring).
    262 
    263 RETURN: list L mapped into the new ring R, if L is given; else nothing
    264 ASSUME: The active ring must allow an algebraic extension
     249CREATE:  a ring with name R, in which f is reducible, and change to it.
     250         If the old ring has no parameter, the name 'a' is chosen for the
     251         parameter of R (if a is no variable; if it is, the proc takes 'b',
     252         etc.; if a,b,c,o are variables of the ring, produce an error message),
     253         otherwise the name of the parameter is kept and only the
     254         minimal polynomial is changed.
     255         The names of variables and orderings are not affected.
     256         It is also allowed to call splitring with R==\"\".
     257         Then the old basering will be REPLACED by the new ring
     258         (with the same name as the old ring).
     259RETURN:  list L mapped into the new ring R, if L is given; else nothing
     260ASSUME:  The active ring must allow an algebraic extension
    265261         (e.g. it cannot be a transcendent ring extension of Q or Z/p).
    266262KEYWORDS: algebraic field extension; extension of rings
    … …  
    400396 kill r1; kill r2;
    401397}
     398///////////////////////////////////////////////////////////////////////////////

  • Singular/LIB/qhmoduli.lib

    r803c5a1 r8942a5  
    33category="Singularities";
    44info="
    5 LIBRARY:  qhmoduli.lib    PROCEDURES FOR MODULI SPACES OF SQH-SINGULARITIES
     5LIBRARY:  qhmoduli.lib    Moduli Spaces of Semi-Quasihomogeneous Singularities
    66AUTHOR:   Thomas Bayer, email: bayert@in.tum.de
    77
    … …  
    4343         2 use a primary decomposition
    4444         4 compute E_f0, i.e., the image of G_f0
    45          To combine options, add their value.
    46 DEFAULT: opt = 7
     45         To combine options, add their value, default: opt =7
    4746EXAMPLE: example ModEqn; shows an example
    4847"
    … …  
    199198RETURN:   polynomial ring over a simple extension of the groundfield of the
    200199          basering, containing the ideals 'id' and 'embedid'.
    201    - 'id' contains the equations of the quotient if opt = 1,
    202      if opt = 0, 2 'id' contains generators of the coordinate ring R
    203            of the quotient (Spec(R) is the quotient)
    204    - 'embedid' = 0 if opt = 1,
    205            if opt = 0, 2 it is the ideal defining the equivariant embedding
     200          - 'id' contains the equations of the quotient if opt = 1,
     201            if opt = 0, 2 'id' contains generators of the coordinate ring R
     202            of the quotient (Spec(R) is the quotient)
     203          - 'embedid' = 0 if opt = 1,
     204            if opt = 0, 2 it is the ideal defining the equivariant embedding
    206205OPTIONS: 1 compute equations of the quotient,
    207206         2 use a primary decomposition when computing the Reynolds operator
    208    To combine options, add their value.
    209 DEFAULT: opt = 3
     207         To combine options, add their value, default: opt =3.
    210208EXAMPLE: example QuotientEquations; shows an example
    211209"
    … …  
    726724RETURN:  list
    727725         _[1]  list of monomials
    728         _[2]  list of terms
     726         _[2]  list of terms
    729727EXAMPLE: example MonosAndTerms shows an example
    730728"
    … …  
    761759         weighted degree = d
    762760RETURN:  list
    763    _[1]  list of monomials
    764    _[2]  list of terms
     761         _[1]  list of monomials
     762         _[2]  list of terms
    765763EXAMPLE: example SelectMonos; shows an example
    766764"
    … …  
    11911189proc AllCombinations(list partition, list indices)
    11921190"USAGE:   AllCombinations(partition,indices); list partition, indices)
    1193 PURPOSE: all compbinations for a given partititon
     1191PURPOSE: all combinations for a given partititon
    11941192RETURN:  list
    11951193GLOBAL: varSubsList, contains the index j s.t. x(i) -> x(i)t(j) ...

  • Singular/LIB/random.lib

    r803c5a1 r8942a5  
    1 // $Id: random.lib,v 1.12 2000-12-19 14:37:27 anne Exp $
    21//(GMG/BM, last modified 22.06.96)
    32///////////////////////////////////////////////////////////////////////////////
    4 
    5 version="$Id: random.lib,v 1.12 2000-12-19 14:37:27 anne Exp $";
     3version="$Id: random.lib,v 1.13 2000-12-22 14:29:01 greuel Exp $";
    64category="General purpose";
    75info="
    8 LIBRARY:  random.lib    PROCEDURES OF RANDOM MATRIX AND POLY OPERATIONS
     6LIBRARY:  random.lib    Creating Random and Sparse Matrices, Ideals, Polys
    97
    108PROCEDURES:
    11  genericid(id[,p,b]);     generic sparse linear combinations of generators of id
    12  randomid(id,[k,b]);      random linear combinations of generators of id
    13  randommat(n,m[,id,b]);   nxm matrix of random linear combinations of id
    14  sparseid(k,u[,o,p,b]);   ideal of k random sparse poly's of degree d [u<=d<=o]
    15  sparsemat(n,m[,p,b]);    nxm sparse integer matrix with random coefficients
    16  sparsepoly(u[,o,p,b]);   random sparse polynomial with terms of degree in [u,o]
    17  sparsetriag(n,m[,.]);    nxm sparse lower-triag intmat with random coefficients
    18  randomLast(b);           random transformation of the last variable
    19  randomBinomial(k,u[,.]); binomial ideal, k random generators of degree >=u
     9 genericid(i[,p,b]);     generic sparse linear combinations of generators of i
     10 randomid(id,[k,b]);     random linear combinations of generators of id
     11 randommat(n,m[,id,b]);  nxm matrix of random linear combinations of id
     12 sparseid(k,u[,o,p,b]);  ideal of k random sparse poly's of degree d [u<=d<=o]
     13 sparsemat(n,m[,p,b]);   nxm sparse integer matrix with random coefficients
     14 sparsepoly(u[,o,p,b]);  random sparse polynomial with terms of degree in [u,o]
     15 sparsetriag(n,m[,.]);   nxm sparse lower-triag intmat with random coefficients
     16 randomLast(b);          random transformation of the last variable
     17 randomBinomial(k,u,..); binomial ideal, k random generators of degree >=u
    2018           (parameters in square brackets [] are optional)
    2119";

  • Singular/LIB/reesclos.lib

    r803c5a1 r8942a5  
    11///////////////////////////////////////////////////////////////////////////////
    2 // reesclos.lib
    3 ///////////////////////////////////////////////////////////////////////////////
    4 
    52version="$id reesclos.lib,v 1.30 2000/12/5 hirsch Exp $";
    63category="Commutative Algebra";
    74info="
    8 LIBRARY:     reesclos.lib
     5LIBRARY:     reesclos.lib Rees Algebra and Integral Closure of Ideals
    96AUTHOR:      Tobias Hirsch, email: hirsch@math.tu-cottbus.de
    107
    … …  
    9895////////////////////////////////////////////////////////////////////////////
    9996
    100 static
    101 proc ClosureRees (list L)
     97static proc ClosureRees (list L)
    10298"USAGE:    ClosureRees (L); L a list containing
    10399          - a ring L[1], inside L[1] an ideal ker such that L[1]/ker is
    … …  
    401397////////////////////////////////////////////////////////////////////////////
    402398
    403 static
    404 proc ClosurePower(list images, list #)
     399static proc ClosurePower(list images, list #)
    405400"USAGE:    ClosurePower (L [,#]);
    406401          - L a list containing generators of the closure of R[It] in k[x,t]
    … …  
    672667  J;                             // J is the integral closure of I
    673668}
     669///////////////////////////////////////////////////////////////////////////////
     670/*
     671  BEISPIELE
     672*/

  • Singular/LIB/ring.lib

    r803c5a1 r8942a5  
    1 // $Id: ring.lib,v 1.13 2000-12-19 14:37:27 anne Exp $
    21//(GMG, last modified 03.11.95)
    32///////////////////////////////////////////////////////////////////////////////
    4 
    5 version="$Id: ring.lib,v 1.13 2000-12-19 14:37:27 anne Exp $";
     3version="$Id: ring.lib,v 1.14 2000-12-22 14:33:13 greuel Exp $";
    64category="General purpose";
    75info="
    8 LIBRARY:  ring.lib      PROCEDURES FOR MANIPULATING RINGS AND MAPS
     6LIBRARY:  ring.lib      Manipulating Rings and Maps
    97
    108PROCEDURES:
    … …  
    1311 changevar(\"R\",v[,r]);  make a copy R of basering [ring r] with new vars v
    1412 defring(\"R\",c,n,v,o);  define a ring R in specified char c, n vars v, ord o
    15  defrings(n[,p]);       define ring Sn in n vars, char 32003 [p], ord ds
    16  defringp(n[,p]);       define ring Pn in n vars, char 32003 [p], ord dp
     13 defrings(n[,p]);         define ring Sn in n vars, char 32003 [p], ord ds
     14 defringp(n[,p]);         define ring Pn in n vars, char 32003 [p], ord dp
    1715 extendring(\"R\",n,v,o); extend given ring by n vars v, ord o and name it R
    18  fetchall(R[,str]);     fetch all objects of ring R to basering
    19  imapall(R[,str]);      imap all objects of ring R to basering
    20  mapall(R,i[,str]);     map all objects of ring R via ideal i to basering
    21  ord_test(R);           test wether ordering of R is global, local or mixed
     16 fetchall(R[,str]);       fetch all objects of ring R to basering
     17 imapall(R[,str]);        imap all objects of ring R to basering
     18 mapall(R,i[,str]);       map all objects of ring R via ideal i to basering
     19 ord_test(R);             test wether ordering of R is global, local or mixed
    2220 ringtensor(\"R\",s,t,..);create ring R, tensor product of rings s,t,...
    2321           (parameters in square brackets [] are optional)
    … …  
    739737   setring s;
    740738   ideal i = a2+b3+c5;
    741    changevar("S","x,y,z");       //set S (change vars of s to x,y,z) the basering
     739   changevar("S","x,y,z");      //set S (change vars of s to x,y,z) the basering
    742740   qring qS =std(fetch(s,i));    //create qring of S mod i (maped to S)
    743741   changevar("T","d,e,f,g,h",t); //set T (change vars of t to d..h) the basering
Note: See TracChangeset for help on using the changeset viewer.