# Changeset 8942a5 in git

Ignore:
Timestamp:
Dec 22, 2000, 3:33:13 PM (22 years ago)
Branches:
(u'spielwiese', '828514cf6e480e4bafc26df99217bf2a1ed1ef45')
Children:
8bb77bfee92151ac9ed599c9d789653dc8a3570c
Parents:
Message:
```* GMG: Kosmetik

Location:
Singular/LIB
Files:
21 edited

Unmodified
Removed
• ## Singular/LIB/homolog.lib

 r803c5a1 // \$Id: homolog.lib,v 1.11 2000-12-19 14:41:42 anne Exp \$ //(BM/GMG) /////////////////////////////////////////////////////////////////////////////// version="\$Id: homolog.lib,v 1.11 2000-12-19 14:41:42 anne Exp \$"; version="\$Id: homolog.lib,v 1.12 2000-12-22 14:05:48 greuel Exp \$"; category="Commutative Algebra"; info=" LIBRARY:  homolog.lib   PROCEDURES FOR HOMOLOGICAL ALGEBRA LIBRARY:  homolog.lib   Procedures for Homological Algebra AUTHORS:  Gert-Martin Greuel, email: greuel@mathematik.uni-kl.de, Bernd Martin, email: martin@math.tu-cottbus.de kb1 = matrix(ker)*kb1; dbprint(p-1,"// kbase of Ext^1(M,M)", "//  - the columns present the kbase elements in Hom(F(1),F(0))", "//  - F(*) a free resolution of M",kb1); "//  - the columns present the kbase elements in Hom(F(1),F(0))", "//  - F(*) a free resolution of M",kb1); //------ compute the liftings of Ext^1 ---------------------------------------- for( ii=1; ii<=s; ii++ ) { k=v[ii]; if( k<0  )                                    // Ext^k is 0 for negative k if( k<0  )                                   // Ext^k is 0 for negative k { dbprint(p-1,"// Ext^k=0 for k<0!"); extMN    = gen(1); printlevel = p; } //////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// proc Hom (module M, module N, list #) {  for (l=1;l<=ncols(kb);l=l+1) { "// element",l,"of kbase of Hom in Hom(F0,G0) as matrix: F0-->G0:"; "// element",l,"of kbase of Hom in Hom(F0,G0) as matrix: F0-->G0:"; print(matrix(ideal(kb[l]),nrows(N),nrows(M))); } } else { dbprint(p-1,"// columns of matrix are kbase of Hom in Hom(F0,G0)",kb); } {dbprint(p-1,"// columns of matrix are kbase of Hom in Hom(F0,G0)",kb);} L=homMN,homMN0,kb; return(L); } printlevel = p; } //////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// proc homology (matrix A,matrix B,module M,module N,list #) ker(B)/im(A) := ker(M'/im(A) --B--> N'/im(BM)+im(BA)). If B induces a map M'--B-->N' (i.e BM=0) and if R^k--A-->M'--B-->N' is a complex (i.e. BA=0) then ker(B)/im(A) is the homology of this complex a complex (i.e. BA=0) then ker(B)/im(A) is the homology of the complex RETURN:  module H, a presentation of ker(B)/im(A) NOTE:    homology returns a free module of rank m if ker(B)=im(A) print(K); } //////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// proc kohom (matrix M, int j) print(kohom(n,3)); } ///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// proc kontrahom (matrix M, int j)
• ## Singular/LIB/inout.lib

 r803c5a1 // \$Id: inout.lib,v 1.18 2000-12-19 14:37:25 anne Exp \$ // (GMG/BM, last modified 22.06.96) /////////////////////////////////////////////////////////////////////////////// version="\$Id: inout.lib,v 1.18 2000-12-19 14:37:25 anne Exp \$"; version="\$Id: inout.lib,v 1.19 2000-12-22 14:06:55 greuel Exp \$"; category="General purpose"; info=" LIBRARY:  inout.lib     PROCEDURES FOR MANIPULATING IN- AND OUTPUT LIBRARY:  inout.lib     Printing and Manipulating In- and Output PROCEDURES:
• ## Singular/LIB/intprog.lib

 r803c5a1 version="\$Id: intprog.lib,v 1.2 2000-12-19 14:41:42 anne Exp \$"; /////////////////////////////////////////////////////////////////////////////// version="\$Id: intprog.lib,v 1.3 2000-12-22 14:08:19 greuel Exp \$"; category="Commutative Algebra"; info=" LIBRARY: intprog.lib      Integer Programming with Groebner Basis Methods AUTHOR:  Christine Theis, email: ctheis@math.uni-sb.de PROCEDURES: solve_IP(..);   procedures for solving Integer Programming  problems "; /////////////////////////////////////////////////////////////////////////////// info=" LIBRARY: intprog.lib      INTEGER PROGRAMMING WITH GROEBNER BASIS METHODS AUTHOR:  Christine Theis, email: ctheis@math.uni-sb.de PROCEDURES: solve_IP(intmat A, [intvec|list] bx, intvec c, string alg [, intvec prsv]); procedures for solving IP-problems "; /////////////////////////////////////////////////////////////////////////////// static proc solve_IP_1(intmat A, intvec bx, intvec c, string alg) { return(v); } /////////////////////////////////////////////////////////////////////////////// static proc solve_IP_2(intmat A, list bx, intvec c, string alg) { return(l); } /////////////////////////////////////////////////////////////////////////////// static proc solve_IP_3(intmat A, intvec bx, intvec c, string alg, intvec prsv) return(v); } /////////////////////////////////////////////////////////////////////////////// static proc solve_IP_4(intmat A, list bx, intvec c, string alg, intvec prsv) return(l); } /////////////////////////////////////////////////////////////////////////////// proc solve_IP "USAGE:   solve_IP(A,bx,c,alg);       A intmat, bx intvec, c intvec, alg string solve_IP(A,bx,c,alg);       A intmat, bx list of intvec, c intvec, alg string solve_IP(A,bx,c,alg,prsv);  A intmat, bx intvec, c intvec, alg string, prsv intvec solve_IP(A,bx,c,alg,prsv);  A intmat, bx list of intvec, c intvec, alg string, prsv intvec RETURN:   type of bx: solution of the associated integer programming problem(s) as explained in @texinfo @ref{Toric ideals and integer programming}. @end texinfo NOTE:     This procedure returns the solution(s) of the given IP-problem(s) or the message `not solvable'. One may call the procedure with several different algorithms: - the algorithm of Conti/Traverso using elimination (ect), - the algorithm of Pottier (pt), - an algorithm of Bigatti/La Scala/Robbiano (blr), - the algorithm of Hosten/Sturmfels (hs), - the algorithm of DiBiase/Urbanke (du). The argument `alg' should be the abbreviation for an algorithm as above: ect, pt, blr, hs or du. `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. 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. 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. solve_IP may also be called with a list bx of intvecs instead of a single intvec. "USAGE:  solve_IP(A,bx,c,alg);  A intmat, bx intvec, c intvec, alg string solve_IP(A,bx,c,alg);  A intmat, bx list of intvec, c intvec, alg string solve_IP(A,bx,c,alg,prsv);  A intmat, bx intvec, c intvec, alg string, prsv intvec solve_IP(A,bx,c,alg,prsv);  A intmat, bx list of intvec, c intvec, alg string, prsv intvec RETURN: type of bx: solution of the associated integer programming problem(s) as explained in @texinfo @ref{Toric ideals and integer programming}. @end texinfo NOTE:   This procedure returns the solution(s) of the given IP-problem(s) or the message `not solvable'. One may call the procedure with several different algorithms: - the algorithm of Conti/Traverso using elimination (ect), - the algorithm of Pottier (pt), - an algorithm of Bigatti/La Scala/Robbiano (blr), - the algorithm of Hosten/Sturmfels (hs), - the algorithm of DiBiase/Urbanke (du). The argument `alg' should be the abbreviation for an algorithm as above: ect, pt, blr, hs or du. `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. 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. 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. solve_IP may also be called with a list bx of intvecs instead of a single intvec. SEE ALSO: intprog_lib, toric_lib, Integer programming EXAMPLE:  example solve_IP; shows an example SEE ALSO: intprog_lib, toric_lib, Integer programming " { example { "EXAMPLE"; echo=2; // call with single right-hand vector intmat A[2][3]=1,1,0,0,1,1; A; intvec b1=1,1; b1; intvec c=2,2,1; c; intvec solution_vector=solve_IP(A,b1,c,"pct"); solution_vector; // call with list of right-hand vectors intvec b2=-1,1; list l=b1,b2; l; list solution_list=solve_IP(A,l,c,"ct"); solution_list; // call with single initial solution vector A=2,1,-1,-1,1,2; A; b1=3,4,5; solution_vector=solve_IP(A,b1,c,"du"); // call with single initial solution vector // and algorithm needing a positive row space vector solution_vector=solve_IP(A,b1,c,"hs"); // call with single initial solution vector // and positive row space vector intvec prsv=1,2,1; prsv; solution_vector=solve_IP(A,b1,c,"hs",prsv); solution_vector; // call with list of initial solution vectors // and positive row space vector b2=7,8,0; l=b1,b2; l; solution_list=solve_IP(A,l,c,"blr",prsv); solution_list; { "EXAMPLE"; echo=2; // 1. call with single right-hand vector intmat A[2][3]=1,1,0,0,1,1; intvec b1=1,1; intvec c=2,2,1; intvec solution_vector=solve_IP(A,b1,c,"pct"); solution_vector;""; // 2. call with list of right-hand vectors intvec b2=-1,1; list l=b1,b2; l; list solution_list=solve_IP(A,l,c,"ct"); solution_list;""; // 3. call with single initial solution vector A=2,1,-1,-1,1,2; b1=3,4,5; solve_IP(A,b1,c,"du");""; // 4. call with single initial solution vector //    and algorithm needing a positive row space vector solution_vector=solve_IP(A,b1,c,"hs");""; // 5. call with single initial solution vector //     and positive row space vector intvec prsv=1,2,1; solution_vector=solve_IP(A,b1,c,"hs",prsv); solution_vector;""; // 6. call with list of initial solution vectors //    and positive row space vector b2=7,8,0; l=b1,b2; l; solution_list=solve_IP(A,l,c,"blr",prsv); solution_list; }
• ## Singular/LIB/jordan.lib

 r803c5a1 /////////////////////////////////////////////////////////////////////////////// version="\$Id: jordan.lib,v 1.18 2000-12-19 14:37:25 anne Exp \$"; version="\$Id: jordan.lib,v 1.19 2000-12-22 14:09:44 greuel Exp \$"; category="Linear Algebra"; info=" LIBRARY: jordan.lib  PROCEDURES TO COMPUTE THE JORDAN NORMAL FORM LIBRARY: jordan.lib  Jordan Normal Form of a Matrix with rational Eigenvalues AUTHOR:  Mathias Schulze, email: mschulze@mathematik.uni-kl.de
• ## Singular/LIB/latex.lib

 r803c5a1 // \$Id: latex.lib,v 1.12 2000-12-19 15:05:28 anne Exp \$ //                        1998/04/17 // author : Christian Gorzel email: gorzelc@math.uni-muenster.de // /////////////////////////////////////////////////////////////////////////////// version="\$Id: latex.lib,v 1.12 2000-12-19 15:05:28 anne Exp \$"; version="\$Id: latex.lib,v 1.13 2000-12-22 14:11:33 greuel Exp \$"; category="Visualization"; info=" LIBRARY: latex.lib    PROCEDURES FOR TYPESET OF SINGULAROBJECTS IN LATEX2E LIBRARY: latex.lib    Typesetting of Singular-Objects in LaTex2e AUTHOR: Christian Gorzel, gorzelc@math.uni-muenster.de GLOBAL VARIABLES: TeXwidth, TeXnofrac, TeXbrack, TeXproj, TeXaligned, TeXreplace, NoDollars are used to control the typesetting Call example texdemo; to become familiar with the features of latex.lib are used to control the typesetting Call example texdemo; to become familiar with the features of latex.lib TeXwidth      : int: -1,0,1..9, >9  controls the breaking of long polynomials return(); } ///////////////////////////////////////////////////////////////////////////////
• ## Singular/LIB/linalg.lib

 r803c5a1 // //      last modified: 04/25/2000 by GMG ////////////////////////////////////////////////////////////////////////////// version="\$Id: linalg.lib,v 1.6 2000-12-19 14:37:26 anne Exp \$"; //GMG last modified: 04/25/2000 ////////////////////////////////////////////////////////////////////////////// version="\$Id: linalg.lib,v 1.7 2000-12-22 14:12:32 greuel Exp \$"; category="Linear Algebra"; info=" LIBRARY:  linalg.lib    PROCEDURES FOR ALGORITHMIC LINEAR ALGEBRA LIBRARY:  linalg.lib    Algorithmic Linear Algebra AUTHOR:   Ivor Saynisch (ivs@math.tu-cottbus.de) ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // help functions ////////////////////////////////////////////////////////////////////////////// static proc abs(poly c) static proc abs(poly c) "RETURN: absolut value of c, c must be constants" { return(1); } static proc red(matrix A,int i,int j) ////////////////////////////////////////////////////////////////////////////// static proc red(matrix A,int i,int j) "USAGE:    red(A,i,j);  A = constant matrix reduces column j with respect to A[i,i] and column i } //proc sp(vector v1,vector v2) ////////////////////////////////////////////////////////////////////////////// proc inner_product(vector v1,vector v2) "RETURN:   inner product " return ((transpose(matrix(v1,k,1))*matrix(v2,k,1))[1,1]); } ///////////////////////////////////////////////////////////////////////////// } ////////////////////////////////////////////////////////////////////////////// proc inverse_B(matrix A) } ////////////////////////////////////////////////////////////////////////////// proc det_B(matrix A) L=busadj(A); return((-1)^n*L[1][1]); } example det_B(A); } ////////////////////////////////////////////////////////////////////////////// } ////////////////////////////////////////////////////////////////////////////// proc gauss_nf(matrix A) } ////////////////////////////////////////////////////////////////////////////// proc pos_def(matrix A) } ////////////////////////////////////////////////////////////////////////////// proc linsolve(matrix A, matrix b)
• ## Singular/LIB/makedbm.lib

 r803c5a1 // \$Id: makedbm.lib,v 1.10 2000-12-19 18:31:47 obachman Exp \$ //========================================================================= // // Please send bugs and comments to krueger@mathematik.uni-kl.de // //============================================================================= version="\$Id: makedbm.lib,v 1.10 2000-12-19 18:31:47 obachman Exp \$"; /////////////////////////////////////////////////////////////////////////////// version="\$Id: makedbm.lib,v 1.11 2000-12-22 14:14:05 greuel Exp \$"; category="Miscellaneous"; info=" LIBRARY:  makedbm.lib     some usefull tools needed by the Arnold-Classifier. dbm_read(l);          read all entries from a DBM-databaes pointed by l dbm_getnext(l);       read next entry from a DBM-databaes pointed by l create_sing_dbm(); read_sing_dbm(); LIBRARY:  makedbm.lib     Data Base of Singularities for the Arnold-Classifier AUTHOR:   Kai Krueger, krueger@mathematik.uni-kl.de PROCEDURES: dbm_read(l);          read all entries from a DBM-databaes pointed by l dbm_getnext(l);       read next entry from a DBM-databaes pointed by l create_sing_dbm(); read_sing_dbm(); ";
• ## Singular/LIB/matrix.lib

 r803c5a1 // \$Id: matrix.lib,v 1.14 2000-12-19 14:37:26 anne Exp \$ // GMG/BM, last modified: 8.10.98 /////////////////////////////////////////////////////////////////////////////// version="\$Id: matrix.lib,v 1.14 2000-12-19 14:37:26 anne Exp \$"; version="\$Id: matrix.lib,v 1.15 2000-12-22 14:15:05 greuel Exp \$"; category="Linear Algebra"; info=" LIBRARY:  matrix.lib    PROCEDURES FOR MATRIX OPERATIONS LIBRARY:  matrix.lib    Elementary Matrix Operations PROCEDURES: { int i,j; matrix C=B; for( i=2; i<=nrows(A); i=i+1 ) { C=dsum(C,B); } matrix D[nrows(C)][ncols(A)*nrows(B)]; for( j=1; j<=nrows(B); j=j+1 ) { for( i=1; i<=nrows(A); i=i+1 ) { D[(i-1)*nrows(B)+j,(j-1)*ncols(A)+1..j*ncols(A)]=A[i,1..ncols(A)]; } } return(concat(C,D)); matrix C,D; for( i=1; i<=nrows(A); i++ ) { C = A[i,1]*B; for( j=2; j<=ncols(A); j++ ) { C = concat(C,A[i,j]*B); } D = concat(D,transpose(C)); } D = transpose(D); return(submat(D,2..nrows(D),1..ncols(D))); } example
• ## Singular/LIB/mondromy.lib

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

 r803c5a1 // \$Id: mregular.lib,v 1.3 2000-12-19 14:41:43 anne Exp \$ // IB/PG/GMG, last modified:  21.7.2000 ////////////////////////////////////////////////////////////////////////////// version = "\$Id: mregular.lib,v 1.3 2000-12-19 14:41:43 anne Exp \$"; version = "\$Id: mregular.lib,v 1.4 2000-12-22 14:17:21 greuel Exp \$"; category="Commutative Algebra"; info=" LIBRARY: mregular.lib       PROCEDURES FOR THE CASTELNUOVO-MUMFORD REGULARITY AUTHORS: I.Bermejo, email: ibermejo@ull.es Ph.Gimenez, email: pgimenez@agt.uva.es G.-M.Greuel, email: greuel@mathematik.uni-kl.de LIBRARY: mregular.lib   Castelnuovo-Mumford Regularity of CM-Schemes and Curves AUTHORS: I.Bermejo,     ibermejo@ull.es Ph.Gimenez,   pgimenez@agt.uva.es G.-M.Greuel,   greuel@mathematik.uni-kl.de A library for computing the Castelnuovo-Mumford regularity of a subscheme of the projective n-space that DOES NOT require the computation of a minimal graded free resolution of the saturated ideal defining the subscheme. OVERVIEW: A library for computing the Castelnuovo-Mumford regularity of a subscheme of the projective n-space that DOES NOT require the computation of a minimal graded free resolution of the saturated ideal defining the subscheme. The procedures are based on two papers by Isabel Bermejo and Philippe Gimenez: 'On Castelnuovo-Mumford regularity of projective curves' Proc.Amer.Math.Soc. 128(5) (2000), and 'Computing the Castelnuovo-Mumford regularity of some subschemes of Pn using quotients of monomial ideals', Proceedings of MEGA-2000, J. Pure Appl. Algebra (to appear). The algorithm assumes the variables to be in Noether position. PROCEDURES: reg_curve(id,[,e]); regularity of projective curve V(id_sat) in Pn reg_moncurve(li);   regularity of projective monomial curve defined by li "; REMARK: The procedures are based on two papers by Isabel Bermejo and Philippe Gimenez: 'On Castelnuovo-Mumford regularity of projective curves' Proc.Amer.Math.Soc. 128(5) (2000), and 'Computing the Castelnuovo-Mumford regularity of some subschemes of Pn using quotients of monomial ideals', Proceedings of MEGA-2000, J. Pure Appl. Algebra (to appear). IMPORTANT: To use the first two procedures, the variables must be in Noether position, i.e. that the polynomial ring in the last variables must be a Noether normalization of basering/id. If it is not the case, you should compute a Noether normalization before, e.g. by using the procedure noetherNormal from algebra.lib. "; // LIB "general.lib"; LIB "elim.lib"; LIB "algebra.lib"; LIB "sing.lib"; LIB "poly.lib"; ////////////////////////////////////////////////////////////////////////////// // proc reg_CM (ideal i) " the field K is infinite, and S/i-sat is Cohen-Macaulay. Assume that K[x(n-d),...,x(n)] is a Noether normalization of S/i-sat where d=dim S/i -1. where d=dim S/i -1. If this is not the case, compute a Noether normalization e.g. by using the proc noetherNormal from algebra.lib. NOTE:    The output is reg(X)=reg(i-sat) where X is the arithmetically Cohen-Macaulay subscheme of the projective n-space defined by i. reg_CM(i); } /////////////////////////////////////////////////////////////////////////////// /* Out-commented examples: */ ////////////////////////////////////////////////////////////////////////////// // proc reg_curve (ideal i, list #) " reg_curve(j); } /////////////////////////////////////////////////////////////////////////////// /* Out-commented examples: */ ////////////////////////////////////////////////////////////////////////////// // proc reg_moncurve (list #) " reg_moncurve(0,1,3,5,6); } /////////////////////////////////////////////////////////////////////////////// /* Out-commented examples: // */ // ////////////////////////////////////////////////////////////////////////////// //
• ## Singular/LIB/normal.lib

 r803c5a1 /////////////////////////////////////////////////////////////////////////////// // normal.lib // algorithms for computing the normalization based on // the criterion of Grauert/Remmert and ideas of De Jong & Vasconcelos /////////////////////////////////////////////////////////////////////////////// version="\$Id: normal.lib,v 1.27 2000-12-19 14:41:43 anne Exp \$"; version="\$Id: normal.lib,v 1.28 2000-12-22 14:18:34 greuel Exp \$"; category="Commutative Algebra"; info=" LIBRARY:  normal.lib     PROCEDURES FOR NORMALIZATION AUTHORS:  Gert-Martin Greuel, email: greuel@mathematik.uni-kl.de, Gerhard Pfister, email: pfister@mathematik.uni-kl.de LIBRARY:  normal.lib     Normalization of Affine Rings AUTHORS:  G.-M. Greuel  greuel@mathematik.uni-kl.de, G. Pfister    pfister@mathematik.uni-kl.de PROCEDURES: LIB "inout.lib"; /////////////////////////////////////////////////////////////////////////////// static proc isR_HomJR (list Li) static proc isR_HomJR (list Li) "USAGE:   isR_HomJR (Li);  Li = list: ideal SBid, ideal J, poly p COMPUTE: module Hom_R(J,R) = R:J and compare with R /////////////////////////////////////////////////////////////////////////////// proc normal(ideal id, list #) "USAGE:   normal(i [,choose]);  i a radical ideal, choose empty or 1 if choose=1 the normalization of the associated primes is computed (which is sometimes more efficient) ASSUME:  The ideal must be radical, for non radical ideals the output may be wrong (i=radical(i); makes i radical) RETURN:  a list of rings (say nor), in each ring nor[i] are two ideals norid, normap such that the direct sum of the rings nor[i]/norid is NOTE:    to use the i-th ring type: def R=nor[i]; setring R; increasing printlevel displays more comments (default: printlevel=0) COMMENT: Not implemented for local or mixed orderings. Not implemented for local or mixed orderings. If the input ideal i is weighted homogeneous a weighted ordering may be used (qhweight(i); computes weights). CAUTION: The proc does not check whether the input is radical, for non radical ideals the output may be wrong (i=radical(i); makes i radical) EXAMPLE: example normal; shows an example " /////////////////////////////////////////////////////////////////////////////// static proc normalizationPrimes(ideal i,ideal ihp, list #) static proc normalizationPrimes(ideal i,ideal ihp, list #) "USAGE:   normalizationPrimes(i,ihp[,si]);  i prime ideal, ihp map (partial normalization), si SB of singular locus } /////////////////////////////////////////////////////////////////////////////// static proc substpart(ideal endid, ideal endphi, int homo, intvec rw) static proc substpart(ideal endid, ideal endphi, int homo, intvec rw) "//Repeated application of elimpart to endid, until no variables can be ring r=0,(u,v,w,x,y,z),wp(1,1,1,3,2,1); ideal i=wx,wy,wz,vx,vy,vz,ux,uy,uz,y3-x2; */
• ## Singular/LIB/ntsolve.lib

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

 r803c5a1 // \$Id: paramet.lib,v 1.7 2000-12-19 15:05:31 anne Exp \$ // author : Thomas Keilen email: keilen@mathematik.uni-kl.de // last change:           05.12.2000 /////////////////////////////////////////////////////////////////////////////// version="\$Id: paramet.lib,v 1.7 2000-12-19 15:05:31 anne Exp \$"; version="\$Id: paramet.lib,v 1.8 2000-12-22 14:20:59 greuel Exp \$"; category="Visualization"; info=" LIBRARY: paramet.lib   PROCEDURES FOR PARAMETRIZATIONS AUTHOR:  Thomas Keilen, email: keilen@mathematik.uni-kl.de LIBRARY: paramet.lib   Parametrization of Varieties AUTHOR:  Thomas Keilen, keilen@mathematik.uni-kl.de OVERVIEW: A library to compute parametrizations of algebraic varieties (if possible) with the aid of a primary decomposition, respectively to compute a parametrization of a plane curve singularity with the aid of a with the aid of a normalization, or a primary decomposition, resp. to compute a parametrization of a plane curve singularity with the aid of a Hamburger-Noether expansion. /////////////////////////////////////////////////////////////////////////////// proc parametrize(ideal I) "USAGE:  parametrize(); I ideal in an arbitrary number of variables, "USAGE:  parametrize(I); I ideal in an arbitrary number of variables, whose radical is prime, in a ring with global ordering RETURN:  a list containing the parametrization ideal resp. the original ideal, ring RING=0,(x,y,z),dp; ideal I=z2-y2x2+x3; parametrize(I);parametrize(I); parametrize(I); } /////////////////////////////////////////////////////////////////////////////// proc parametrizepd(ideal I) "USAGE:  parametrizepd(); I ideal in a polynomial ring with global ordering "USAGE:  parametrizepd(I); I ideal in a polynomial ring with global ordering RETURN:  a list of lists, where each entry contains the parametrization of a primary component of I resp. 0, the number of variables ///////////////////////////////////////////////////////////////////////////// proc parametrizesing(poly f) "USAGE:  parametrizesing(); f a polynomial in two variables,ordering ls or ds RETURN:  a list containing the parametrizations of the different branches of the singularity at the origin resp. 0, if f was not of the desired kind RETURN:  a list of ideals, each ideal parametrizes a branch of the singularity at the origin; resp. 0, if f was not of the desired kind CREATE:  If the parametrization is successful, the basering will be changed to the parametrization ring, that is to the ring  0,(x,y),ls;
• ## Singular/LIB/poly.lib

 r803c5a1 // \$Id: poly.lib,v 1.28 2000-12-19 14:37:26 anne Exp \$ //(GMG, last modified 22.06.96) //(obachman: 17.12.97 -- added katsura) //(anne: 11.12.2000 -- added mod2id, id2mod, subrInterred) /////////////////////////////////////////////////////////////////////////////// version="\$Id: poly.lib,v 1.28 2000-12-19 14:37:26 anne Exp \$"; /////////////////////////////////////////////////////////////////////////////// version="\$Id: poly.lib,v 1.29 2000-12-22 14:22:23 greuel Exp \$"; category="General purpose"; info=" LIBRARY:  poly.lib      PROCEDURES FOR MANIPULATING POLYS, IDEALS, MODULES LIBRARY:  poly.lib      Procedures for Manipulating Polys, Ideals, Modules AUTHORS:  O. Bachmann, G.-M: Greuel, A. Fruehbis PROCEDURES: "USAGE: katsura([n]): n integer RETURN: katsura(n) : n-th katsura ideal of (1) newly created and set ring (32003, x(0..n), dp), if nvars(basering) < n (2) basering, if nvars(basering) >= n (1) newly created and set ring (32003, x(0..n), dp), if nvars(basering) < n (2) basering, if nvars(basering) >= n katsura()  : katsura ideal of basering EXAMPLE: example katsura; shows examples proc subrInterred(ideal mon, ideal sm, intvec iv) "USAGE:    subrInterred(mon,sm,iv); sm:   ideal in a ring r with n + s variables, e.g. x_1,..,x_n and t_1,..,t_s mon:  ideal with monomial generators (not divisible by one of the t_i) such that sm is contained in the module k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)] iv:   intvec listing the variables which are supposed to be used as x_i RETURN:   list l: "USAGE:   subrInterred(mon,sm,iv); sm:   ideal in a ring r with n + s variables, e.g. x_1,..,x_n and t_1,..,t_s mon:  ideal with monomial generators (not divisible by one of the t_i) such that sm is contained in the module k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)] iv:   intvec listing the variables which are supposed to be used as x_i RETURN:  list l: l[1]=the monomials from mon in the order used l[2]=their coefficients after interreduction l[3]=l[1]*l[2] (interreduced system of generators of sm seen as a submodule of k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)]) EXAMPLE:  example subrInterred; shows an example" (interreduced system of generators of sm seen as a submodule of k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)]) EXAMPLE: example subrInterred; shows an example" { int p = printlevel-voice+3;  // p=printlevel+1 (default: p=1)
• ## Singular/LIB/presolve.lib

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

• ## Singular/LIB/primitiv.lib

 r803c5a1 // \$Id: primitiv.lib,v 1.12 2000-12-19 14:41:45 anne Exp \$ // last change:            12.08.99 // last change ML: 12.08.99 /////////////////////////////////////////////////////////////////////////////// // This library is for Singular 1.2 or newer version="\$Id: primitiv.lib,v 1.12 2000-12-19 14:41:45 anne Exp \$"; version="\$Id: primitiv.lib,v 1.13 2000-12-22 14:25:37 greuel Exp \$"; category="Commutative Algebra"; info=" LIBRARY:    primitiv.lib    PROCEDURES FOR FINDING A PRIMITIVE ELEMENT LIBRARY:    primitiv.lib    Computing a Primitive Element AUTHOR:     Martin Lamm,    email: lamm@mathematik.uni-kl.de PROCEDURES: primitive(ideal i);   find minimal polynomial for a primitive element "; /////////////////////////////////////////////////////////////////////////////// LIB "random.lib"; /////////////////////////////////////////////////////////////////////////////// proc primitive(ideal i) "USAGE:   primitive(i); i ideal of the following form: Let k be the ground field of your basering, a_1,...,a_n algebraic over k, @* m_1(x_1), m_2(x_1,x_2),...,m_n(x_1,...,x_n) polynomials in k such that    @* m_j(a_1,...,a_(j-1),x_j) is minimal polynomial for a_j over k(a_1,...,a_(j-1)) for all j=1,...,n. Then i has to be generated by m_1,...,m_n. RETURN:  ideal j in k[x_n] such that j[1] is minimal polynomial for a primitive element b of k(a_1,...,a_n)=k(b) over k j[2],...,j[n+1] polynomials in k[x_n] : j[i+1](b)=a_i for i=1,...,n NOTE:    the number of variables in the basering has to be exactly the number n of given algebraic elements (and minimal polynomials). If k has few elements it can be that no one of the linear combinations of a_1,...,a_n is a primitive element. In this case `primitive' returns the zero ideal. If this occurs use primitive_extra instead. Let k be the ground field of your basering, a_1,...,a_n algebraic over k, m_1(x_1), m_2(x_1,x_2),...,m_n(x_1,...,x_n) polynomials over k such that  m_j(a_1,...,a_(j-1),x_j) is minimal polynomial for a_j over k(a_1,...,a_(j-1)) for all j=1,...,n. Then i has to be generated by m_1,...,m_n. RETURN:   ideal j in k[x_n] such that j[1] is minimal polynomial for a primitive element b of k(a_1,...,a_n)=k(b) over k j[2],...,j[n+1] polynomials in k[x_n] : j[i+1](b)=a_i for i=1,...,n NOTE:     the number of variables in the basering has to be exactly the number n of given algebraic elements (and minimal polynomials). If k has few elements it may happen that no linear combination of a_1,...,a_n is a primitive element. In this case `primitive' returns the zero ideal. If this occurs use primitive_extra instead. SEE ALSO: primitive_extra KEYWORDS: primitive element EXAMPLE: example primitive;  shows an example EXAMPLE:  example primitive;  shows an example " { proc primitive_extra(ideal i) "USAGE:   primitive_extra(i);  ideal i=f,g;  with the following properties: @* Let k=Q or k=Z/pZ be the ground field of the basering, a,b algebraic over k, x the name of the first ring variable, y the name of the second, then:     @* f is the minimal polynomial of a in k[x], g is a polynomial in k[x,y] s.t. g(a,y) is the minimal polynomial of b in k(a)[y] Let k=Q or k=Z/pZ be the ground field of the basering, a,b algebraic over k, x the name of the first ring variable, y the name of the second, then: f is the minimal polynomial of a in k[x], g is a polynomial in k[x,y] s.t. g(a,y) is the minimal polynomial of b in k(a)[y] RETURN:  ideal j in k[y] such that j[1] is minimal polynomial over k for a primitive element c of k(a,b)=k(c) @* j[2] is a polynomial s.t. j[2](c)=a NOTE: - While `primitive' may fail for finite fields, this proc tries all elements of k(a,b) and hence finds by assurance a primitive element. In order to do this (try all elements) field extensions like Z/pZ(a) are not allowed for the ground field k. - primitive_extra assumes that g is monic as polynomial in (k[x])[y] j[1] is minimal polynomial over k for a primitive element c of k(a,b)=k(c) j[2] is a polynomial s.t. j[2](c)=a NOTE:   While `primitive' may fail for finite fields, this proc tries all elements of k(a,b) and hence finds by assurance a primitive element. In order to do this (try all elements) field extensions like Z/pZ(a) are not allowed for the ground field k. primitive_extra assumes that g is monic as polynomial in (k[x])[y] EXAMPLE: example primitive_extra;  shows an example " proc splitring "USAGE:  splitring(f,R[,L]);  f poly, univariate and irreducible(!) over the "USAGE:   splitring(f,R[,L]);  f poly, univariate and irreducible(!) over the active basering; R string, L list of polys and/or ideals (optional) CREATE: a ring with name R, in which f is reducible, and change to it. If the old ring has no parameter, the name 'a' is chosen for the parameter of R (if a is no variable; if it is, the proc takes 'b', etc.; if a,b,c,o are variables of the ring, produce an error message), otherwise the name of the parameter is kept and only the minimal polynomial is changed. The names of variables and orderings are not affected. It is also allowed to call splitring with R==\"\". Then the old basering will be REPLACED by the new ring (with the same name as the old ring). RETURN: list L mapped into the new ring R, if L is given; else nothing ASSUME: The active ring must allow an algebraic extension CREATE:  a ring with name R, in which f is reducible, and change to it. If the old ring has no parameter, the name 'a' is chosen for the parameter of R (if a is no variable; if it is, the proc takes 'b', etc.; if a,b,c,o are variables of the ring, produce an error message), otherwise the name of the parameter is kept and only the minimal polynomial is changed. The names of variables and orderings are not affected. It is also allowed to call splitring with R==\"\". Then the old basering will be REPLACED by the new ring (with the same name as the old ring). RETURN:  list L mapped into the new ring R, if L is given; else nothing ASSUME:  The active ring must allow an algebraic extension (e.g. it cannot be a transcendent ring extension of Q or Z/p). KEYWORDS: algebraic field extension; extension of rings kill r1; kill r2; } ///////////////////////////////////////////////////////////////////////////////
• ## Singular/LIB/qhmoduli.lib

 r803c5a1 category="Singularities"; info=" LIBRARY:  qhmoduli.lib    PROCEDURES FOR MODULI SPACES OF SQH-SINGULARITIES LIBRARY:  qhmoduli.lib    Moduli Spaces of Semi-Quasihomogeneous Singularities AUTHOR:   Thomas Bayer, email: bayert@in.tum.de 2 use a primary decomposition 4 compute E_f0, i.e., the image of G_f0 To combine options, add their value. DEFAULT: opt = 7 To combine options, add their value, default: opt =7 EXAMPLE: example ModEqn; shows an example " RETURN:   polynomial ring over a simple extension of the groundfield of the basering, containing the ideals 'id' and 'embedid'. - 'id' contains the equations of the quotient if opt = 1, if opt = 0, 2 'id' contains generators of the coordinate ring R of the quotient (Spec(R) is the quotient) - 'embedid' = 0 if opt = 1, if opt = 0, 2 it is the ideal defining the equivariant embedding - 'id' contains the equations of the quotient if opt = 1, if opt = 0, 2 'id' contains generators of the coordinate ring R of the quotient (Spec(R) is the quotient) - 'embedid' = 0 if opt = 1, if opt = 0, 2 it is the ideal defining the equivariant embedding OPTIONS: 1 compute equations of the quotient, 2 use a primary decomposition when computing the Reynolds operator To combine options, add their value. DEFAULT: opt = 3 To combine options, add their value, default: opt =3. EXAMPLE: example QuotientEquations; shows an example " RETURN:  list _[1]  list of monomials _[2]  list of terms _[2]  list of terms EXAMPLE: example MonosAndTerms shows an example " weighted degree = d RETURN:  list _[1]  list of monomials _[2]  list of terms _[1]  list of monomials _[2]  list of terms EXAMPLE: example SelectMonos; shows an example " proc AllCombinations(list partition, list indices) "USAGE:   AllCombinations(partition,indices); list partition, indices) PURPOSE: all compbinations for a given partititon PURPOSE: all combinations for a given partititon RETURN:  list GLOBAL: varSubsList, contains the index j s.t. x(i) -> x(i)t(j) ...
• ## Singular/LIB/random.lib

 r803c5a1 // \$Id: random.lib,v 1.12 2000-12-19 14:37:27 anne Exp \$ //(GMG/BM, last modified 22.06.96) /////////////////////////////////////////////////////////////////////////////// version="\$Id: random.lib,v 1.12 2000-12-19 14:37:27 anne Exp \$"; version="\$Id: random.lib,v 1.13 2000-12-22 14:29:01 greuel Exp \$"; category="General purpose"; info=" LIBRARY:  random.lib    PROCEDURES OF RANDOM MATRIX AND POLY OPERATIONS LIBRARY:  random.lib    Creating Random and Sparse Matrices, Ideals, Polys PROCEDURES: genericid(id[,p,b]);     generic sparse linear combinations of generators of id randomid(id,[k,b]);      random linear combinations of generators of id randommat(n,m[,id,b]);   nxm matrix of random linear combinations of id sparseid(k,u[,o,p,b]);   ideal of k random sparse poly's of degree d [u<=d<=o] sparsemat(n,m[,p,b]);    nxm sparse integer matrix with random coefficients sparsepoly(u[,o,p,b]);   random sparse polynomial with terms of degree in [u,o] sparsetriag(n,m[,.]);    nxm sparse lower-triag intmat with random coefficients randomLast(b);           random transformation of the last variable randomBinomial(k,u[,.]); binomial ideal, k random generators of degree >=u genericid(i[,p,b]);     generic sparse linear combinations of generators of i randomid(id,[k,b]);     random linear combinations of generators of id randommat(n,m[,id,b]);  nxm matrix of random linear combinations of id sparseid(k,u[,o,p,b]);  ideal of k random sparse poly's of degree d [u<=d<=o] sparsemat(n,m[,p,b]);   nxm sparse integer matrix with random coefficients sparsepoly(u[,o,p,b]);  random sparse polynomial with terms of degree in [u,o] sparsetriag(n,m[,.]);   nxm sparse lower-triag intmat with random coefficients randomLast(b);          random transformation of the last variable randomBinomial(k,u,..); binomial ideal, k random generators of degree >=u (parameters in square brackets [] are optional) ";
• ## Singular/LIB/reesclos.lib

 r803c5a1 /////////////////////////////////////////////////////////////////////////////// // reesclos.lib /////////////////////////////////////////////////////////////////////////////// version="\$id reesclos.lib,v 1.30 2000/12/5 hirsch Exp \$"; category="Commutative Algebra"; info=" LIBRARY:     reesclos.lib LIBRARY:     reesclos.lib Rees Algebra and Integral Closure of Ideals AUTHOR:      Tobias Hirsch, email: hirsch@math.tu-cottbus.de //////////////////////////////////////////////////////////////////////////// static proc ClosureRees (list L) static proc ClosureRees (list L) "USAGE:    ClosureRees (L); L a list containing - a ring L[1], inside L[1] an ideal ker such that L[1]/ker is //////////////////////////////////////////////////////////////////////////// static proc ClosurePower(list images, list #) static proc ClosurePower(list images, list #) "USAGE:    ClosurePower (L [,#]); - L a list containing generators of the closure of R[It] in k[x,t] J;                             // J is the integral closure of I } /////////////////////////////////////////////////////////////////////////////// /* BEISPIELE */
• ## Singular/LIB/ring.lib

 r803c5a1 // \$Id: ring.lib,v 1.13 2000-12-19 14:37:27 anne Exp \$ //(GMG, last modified 03.11.95) /////////////////////////////////////////////////////////////////////////////// version="\$Id: ring.lib,v 1.13 2000-12-19 14:37:27 anne Exp \$"; version="\$Id: ring.lib,v 1.14 2000-12-22 14:33:13 greuel Exp \$"; category="General purpose"; info=" LIBRARY:  ring.lib      PROCEDURES FOR MANIPULATING RINGS AND MAPS LIBRARY:  ring.lib      Manipulating Rings and Maps PROCEDURES: changevar(\"R\",v[,r]);  make a copy R of basering [ring r] with new vars v defring(\"R\",c,n,v,o);  define a ring R in specified char c, n vars v, ord o defrings(n[,p]);       define ring Sn in n vars, char 32003 [p], ord ds defringp(n[,p]);       define ring Pn in n vars, char 32003 [p], ord dp defrings(n[,p]);         define ring Sn in n vars, char 32003 [p], ord ds defringp(n[,p]);         define ring Pn in n vars, char 32003 [p], ord dp extendring(\"R\",n,v,o); extend given ring by n vars v, ord o and name it R fetchall(R[,str]);     fetch all objects of ring R to basering imapall(R[,str]);      imap all objects of ring R to basering mapall(R,i[,str]);     map all objects of ring R via ideal i to basering ord_test(R);           test wether ordering of R is global, local or mixed fetchall(R[,str]);       fetch all objects of ring R to basering imapall(R[,str]);        imap all objects of ring R to basering mapall(R,i[,str]);       map all objects of ring R via ideal i to basering ord_test(R);             test wether ordering of R is global, local or mixed ringtensor(\"R\",s,t,..);create ring R, tensor product of rings s,t,... (parameters in square brackets [] are optional) setring s; ideal i = a2+b3+c5; changevar("S","x,y,z");       //set S (change vars of s to x,y,z) the basering changevar("S","x,y,z");      //set S (change vars of s to x,y,z) the basering qring qS =std(fetch(s,i));    //create qring of S mod i (maped to S) 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.