Changeset 906458 in git

Ignore:
Timestamp:
Apr 7, 2009, 6:18:06 PM (14 years ago)
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')
Children:
5d98f437864469b655868be585350eeb57da2863
Parents:
2ae96e40fc5453bcb155aec76d376d79dd549cbe
Message:
removed some docu errors prior to release 3-1-0

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

Unmodified
Removed
• Singular/LIB/algebra.lib

 r2ae96e //new proc  nonZeroEntry(id), used to fix a bug in proc finitenessTest /////////////////////////////////////////////////////////////////////////////// version="$Id: algebra.lib,v 1.20 2009-04-03 20:58:53 motsak Exp$"; version="$Id: algebra.lib,v 1.21 2009-04-07 16:18:05 seelisch Exp$"; category="Commutative Algebra"; info=" nonlinear relation h(p,i[1],...,i[k])=0. @end format NOTE:    the proc algebra_containment tests the same with a different NOTE:    the proc algebra_containment tests the same using a different algorithm, which is often faster if l[1] == 0 then l[2] may contain more than one relation h(y(0),y(1),...,y(k)), NOTE:    The algorithm returns 1 iff all the variables of the basering are contained in the polynomial subalgebra generated by the polynomials defining phi. Hence, if the basering has local or mixed ordering or if the preimage ring is a quotient ring (in which case the map may not be well defined) then the return value 1 means \"surjectivity\" in this sense. defining phi. Hence, it tests surjectivity in the case of a global odering. If the basering has local or mixed ordering or if the preimage ring is a quotient ring (in which case the map may not be well defined) then the return value 1 needs to be interpreted with care. EXAMPLE: example is_surjective; shows an example " "USAGE:   is_bijective(phi,pr); phi map to basering, pr preimage ring RETURN:  an integer,  1 if phi is bijective, 0 if not NOTE:    The algorithm checks first injectivity and then surjectivity NOTE:    The algorithm checks first injectivity and then surjectivity. To interprete this for local/mixed orderings, or for quotient rings type help is_surjective; and help is_injective; @end format NOTE:    Designed for characteristic 0.It works also in char k > 0 if it terminates,but may result in an infinite loop in small characteristic terminates,but may result in an infinite loop in small characteristic. EXAMPLE: example noetherNormal; shows an example "
• Singular/LIB/cimonom.lib

 r2ae96e // IB/IG/JJS, last modified: 10.07.2007 /////////////////////////////////////////////////////////////////////////////////////////////////////////// version = "$Id: cimonom.lib,v 1.3 2008-10-07 09:05:07 Singular Exp$"; version = "$Id: cimonom.lib,v 1.4 2009-04-07 16:18:05 seelisch Exp$"; category="Commutative Algebra"; info=" example { "EXAMPLE:"; "printlevel = 0;"; printlevel = 0; "intvec d = 14,15,10,21;"; intvec d = 14,15,10,21; "CompInt(d);"; CompInt(d); " "; "printlevel = 2;"; printlevel = 3; "d = 36,54,125,150,225;"; d = 36,54,125,150,225; "CompInt(d);"; CompInt(d); " "; "d = 45,70,75,98,147;"; d = 45,70,75,98,147; "CompInt(d);"; CompInt(d); };
• Singular/LIB/elim.lib

 r2ae96e // $Id: elim.lib,v 1.28 2009-01-15 13:51:18 Singular Exp$ // $Id: elim.lib,v 1.29 2009-04-07 16:18:05 seelisch Exp$ // (GMG, modified 22.06.96) // GMG, last modified 30.10.08: new procedure elimRing; // and can now choose as method slimgb or std. /////////////////////////////////////////////////////////////////////////////// version="$Id: elim.lib,v 1.28 2009-01-15 13:51:18 Singular Exp$"; version="$Id: elim.lib,v 1.29 2009-04-07 16:18:05 seelisch Exp$"; category="Commutative Algebra"; info=" PROCEDURES: blowup0(j[,s1,s2]);   create presentation of blownup ring of ideal j elimRing(p);          create ring with block ordering for elimating vars in p elim(id,..);          variables .. eliminated from id (ideal/module) elim1(id,p);          variables .. eliminated from id (different algorithm) elim2(id,..);         variables .. eliminated from id (different algorithm) nselect(id,v);        select generators not containing variables given by v sat(id,j);            saturated quotient of ideal/module id by ideal j select(id,v]);        select generators containing all variables given by v select1(id,v);        select generators containing one variable given by v blowup0(j[,s1,s2])   create presentation of blownup ring of ideal j elimRing(p)          create ring with block ordering for elimating vars in p elim(id,..)          variables .. eliminated from id (ideal/module) elim1(id,p)          variables .. eliminated from id (different algorithm) elim2(id,..)         variables .. eliminated from id (different algorithm) nselect(id,v)        select generators not containing variables given by v sat(id,j)            saturated quotient of ideal/module id by ideal j select(id,v])        select generators containing all variables given by v select1(id,v)        select generators containing one variable given by v (parameters in square brackets [] are optional) "; The preimage of V(C) is called the exceptional set, the preimage of V(J) is called the total transform of V(J). The strict transform is the closure of (total transform - exceptional set). is the closure of (total transform minus the exceptional set). @*       If C = then aS = and Z is the blowup of A^n in 0, the exceptional set is P^(k-1). resp. the weighted ordering wp(b1,...bk) if C is homogeneous with deg(C[i])=bi. SEE ALSO:blowUp SEE ALSO:blowUp, blowUp2 EXAMPLE: example blowup0; shows examples "{
• Singular/LIB/homolog.lib

 r2ae96e /////////////////////////////////////////////////////////////////////////////// version="$Id: homolog.lib,v 1.27 2008-10-09 09:31:57 Singular Exp$"; version="$Id: homolog.lib,v 1.28 2009-04-07 16:18:05 seelisch Exp$"; category="Commutative Algebra"; info=" COMPUTE: A presentation of the p-th Koszul homology module H_p(f_1,...,f_k;M'), where M'=coker(M) and f_1,...,f_k are the given (ordered list of non-zero generators of the) ideal I. of non-zero) generators of the ideal I. The computed presentation is minimized via prune. In particular, if H_p(f_1,...,f_k;M')=0 then the return value is 0.
• Singular/LIB/intprog.lib

 r2ae96e /////////////////////////////////////////////////////////////////////////////// version="$Id: intprog.lib,v 1.6 2006-07-25 17:54:27 Singular Exp$"; version="$Id: intprog.lib,v 1.7 2009-04-07 16:18:05 seelisch Exp$"; category="Commutative Algebra"; info=" proc solve_IP "USAGE:  solve_IP(A,bx,c,alg);  A intmat, bx intvec, c intvec, alg string. "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. alg string.@* solve_IP(A,bx,c,alg,prsv);  A intmat, bx intvec, c intvec, alg string, prsv intvec. alg string, prsv intvec.@* solve_IP(A,bx,c,alg,prsv);  A intmat, bx list of intvec, c intvec, alg string, prsv intvec.
• Singular/LIB/linalg.lib

 r2ae96e //GMG last modified: 04/25/2000 ////////////////////////////////////////////////////////////////////////////// version="$Id: linalg.lib,v 1.39 2006-07-24 14:06:05 Singular Exp$"; version="$Id: linalg.lib,v 1.40 2009-04-07 16:18:05 seelisch Exp$"; category="Linear Algebra"; info=" "USAGE:   spnf(list(a[,m])); ideal a, intvec m ASSUME:  ncols(a)==size(m) RETURN:  order a[i] with multiplicity m[i] lexicographically RETURN:  list l: l[1] an ideal, the generators of a; sorted and with multiple entries displayed only once@* l[2] and intvec, l[2][i] provides the multiplicity of l[1][i] EXAMPLE: example spnf; shows examples " proc spprint(list sp) "USAGE:   spprint(sp); list sp (helper routine for spnf, gmssing.lib) "USAGE:   spprint(sp); list sp (helper routine for spnf) RETURN:  string s;  spectrum sp EXAMPLE: example spprint; shows examples
• Singular/LIB/mregular.lib

 r2ae96e // IB/PG/GMG, last modified:  15.10.2004 ////////////////////////////////////////////////////////////////////////////// version = "$Id: mregular.lib,v 1.9 2008-10-06 17:04:27 Singular Exp$"; version = "$Id: mregular.lib,v 1.10 2009-04-07 16:18:05 seelisch Exp$"; category="Commutative Algebra"; info=" (returns -1 if i = (0) or (1)). ASSUME:  The field K is infinite and i is a nonzero proper ideal. NOTES    1. It works also if K is a finite field if it terminates, but NOTE:    1. It works also if K is a finite field if it terminates, but may result in an infinite loop. If the procedure enters more than 30 loops, -1 is returned and a warning message is displayed. than 30 loops, -1 is returned and a warning message is displayed.@* 2. If printlevel > 0 (default = 0), additional info is displayed: dim(S/i) and K[x(n-d+1),...,x(n)] are given. ASSUME:  i is a nonzero proper monomial ideal. NOTES:   1. The ideal must be monomial, otherwise the result has no meaning (so check this before using this procedure). 2. is_nested is used in procedures depthIdeal, regIdeal and satiety. (so check this before using this procedure).@* 2. is_nested is used in procedures depthIdeal, regIdeal and satiety.@* 3. When i is a monomial ideal of nested type of S=K[x(0)..x(n)], the a-invariant of S/i coincides with the upper bound obtained
• Singular/LIB/noether.lib

 r2ae96e // AH last modified:  01.07.2007 ////////////////////////////////////////////////////////////////////////////// version = "$Id: noether.lib,v 1.11 2008-10-06 17:04:28 Singular Exp$"; version = "$Id: noether.lib,v 1.12 2009-04-07 16:18:05 seelisch Exp$"; category="Commutative Algebra"; info=" these algorithms is also provided. The procedures are based on a paper of Amir Hashemi 'Efficient Algorithms for Computing Noether Normalization' (presented in ASCM 2007) Computing Noether Normalization' (presented in ASCM 2007) This library computes also Castelnuovo-Mumford regularity and satiety of an ideal.  A modular version of these algorithms is also provided. The procedures are based on a paper of Amir Hashemi 'Computation of Castelnuovo-Mumford regularity and satiety' (preprint 2008) Castelnuovo-Mumford regularity and satiety' (preprint 2008) " USAGE:  NPos_test (I); I monomial ideal RETURN: A list which first element is 1 if i is in Noether position 0  otherwise. The second element of this list is the list of variable which its first part is the variable such that a power of this varaibles belong to the initial of i. It return also the dimension of i if i is in Noether position RETURN: A list whose first element is 1, if i is in Noether position, 0 otherwise. The second element of this list is a list of variables ordered such that those variables are listed first, of which a power belongs to the initial ideal of i. If i is in Noether position, the method returns furthermore the dimension of i. ASSUME: i is a nonzero monomial ideal. "
• Singular/LIB/normal.lib

 r2ae96e /////////////////////////////////////////////////////////////////////////////// version="$Id: normal.lib,v 1.50 2009-03-26 16:37:19 Singular Exp$"; version="$Id: normal.lib,v 1.51 2009-04-07 16:18:05 seelisch Exp$"; category="Commutative Algebra"; info=" proc genus(ideal I,list #) "USAGE:   genus(i) or genus(i,1); I a 1-dimensional ideal "USAGE:   genus(I) or genus(I,1); I a 1-dimensional ideal RETURN:  an integer, the geometric genus p_g = p_a - delta of the projective curve defined by i, where p_a is the arithmetic genus. i.e. dim(R'/R), R' the normalization of the local ring R of the singularity. @* genus(i,1) uses the normalization to compute delta. Usually genus(i,1) genus(I,1) uses the normalization to compute delta. Usually genus(i,1) is slower than genus(i) but sometimes not. EXAMPLE: example genus; shows an example "USAGE:    primeClosure(L [,c]); L a list of a ring containing a prime ideal ker, c an optional integer RETURN:   a list L (of size n+1) consisting of rings L[1],...,L[n] such that - L[1] is a copy of (not a reference to!) the input ring L[1] RETURN:   a list L (of size n+1) consisting of rings L[1],...,L[n] such that@* - L[1] is a copy of (not a reference to!) the input ring L[1]@* - all rings L[i] contain ideals ker, L[2],...,L[n] contain ideals phi such that L[1]/ker --> ... --> L[n]/ker are injections given by the corresponding ideals phi, and L[n]/ker is the integral closure of L[1]/ker in its quotient field. such that L[1]/ker --> ... --> L[n]/ker are injections given by the corresponding ideals phi, and L[n]/ker is the integral closure of L[1]/ker in its quotient field.@* - all rings L[i] contain a polynomial nzd such that elements of L[i]/ker are quotients of elements of L[i-1]/ker with denominator nzd via the injection phi. L[n+1] is the delta invariant NOTE:     - L is constructed by recursive calls of primeClosure itself. - c determines the choice of nzd: nzd via the injection phi.@* L[n+1] is the delta invariant NOTE:     - L is constructed by recursive calls of primeClosure itself.@* - c determines the choice of nzd:@* - c not given or equal to 0: first generator of the ideal SL, the singular locus of Spec(L[i]/ker) the singular locus of Spec(L[i]/ker)@* - c<>0: the generator of SL with least number of monomials. EXAMPLE:  example primeClosure; shows an example
• Singular/LIB/phindex.lib

 r2ae96e ////////////////////////////////////////////////////////////////////////////// version="$Id: phindex.lib,v 1.3 2008-10-09 09:31:57 Singular Exp$"; version="$Id: phindex.lib,v 1.4 2009-04-07 16:18:05 seelisch Exp$"; category=" "; info=" germ  found by Eisenbud-Levine in 1997. This result was also proved by Khimshiashvili. If the isolated singularity is non algebraically isolated  and the vector field has a reduced complex zeroes of isolated  and the vector field has similar reduced complex zeroes of codimension 1, we use a formula as the Eisenbud-Levine found by Victor Castellanos, in both cases is necessary to use a local order (ds,...). "USAGE:    signatureL(M[,r]); M symmetric matrix, r int (optional). RETURN:   the signature of M of type int or if r is given and !=0 then intvec with (signature, no of +, no of -) is returned. THEORY:   Given the matrix M we construct the quadratic form associated, after intvec with (signature, nr. of +, nr. of -) is returned. THEORY:   Given the matrix M, we construct the quadratic form associated. Afterwards we use the method of Lagrange to compute the signature. The law of inertia for a real quadratic form A(x,x) say that in a inertia for a real quadratic form A(x,x) says that in a representation of A(x,x) as a sum of independent squares A(x,x)=sum_{i=1}^r a_iX_i^2. "USAGE:    signatureLqf(h); h quadratic form (poly type). RETURN:   the signature of h of type int or if r is given and !=0 then intvec with (signature, no of +, no of -) is returned. intvec with (signature, nr. of +, nr. of -) is returned. THEORY:   To compute the signature we use the method of Lagrange. The law of inertia for a real quadratic form h(x,x) say that in a inertia for a real quadratic form h(x,x) says that in a representation  of h(x,x) as a sum of independent squares h(x,x)=sum_{i=1}^r a_iX_i^ 2 the number of positive and the number of negative squares are h(x,x)=sum_{i=1}^r a_i*X_i^2 the number of positive and the number of negative squares are independent of the choice of representation. The signature -s- of h(x,x) is the difference between the number -pi- of positive squares NOTE:     the isolated singularity must be algebraically isolated. THEORY:   The Poincare-Hopf index of a real vector field X at the isolated singularity 0 is the degree of map (X/|X|) : S_epsilon ---> S, singularity 0 is the degree of the map (X/|X|) : S_epsilon ---> S, where S is the unit sphere, and the spheres are oriented as (n-1)-spheres in R^n. The degree depends only on the germ, X, of X composition of the product in the algebra Qx with a linear functional map .       L <,> : (Qx)x(Qx)----->Qx----->R <,> : (Qx)x(Qx) ---(.)--> Qx ---(L)--> R with L(Jo)>0, where Jo is the residue class of the Jacobian determinant in Qx. Here, we use a natural linear functional defined as follows. Suppose that E={E_1,..E_r} is a basis of Qx, then Jo is writing as Jo=a_1E_{j1}+...+a_kE_{jk},  js\in {1...r}, s=1..k, k<=r. as follows. Suppose that E={E_1,..E_r} is a basis of Qx, then Jo can be written as Jo=a_1E_{j1}+...+a_kE_{jk},  js\in {1...r}, s=1..k, k<=r, where a_s are constant. The linear functional L:Qx--->R is defined as L(E_{j1})=(a_1)/|a_1|=sign of a_1, at 0, with reduced complex zeros of codimension 1. THEORY:   Suppose that 0 is an algebraically isolated singularity of the real analytic vector field X, geometrically its mean that the analytic vector field X, geometrically this corresponds to the fact that the complexified vector field has positive dimension singular locus, algebraically this mean that the local ring Qx=R[[x1..xn]]/Ix algebraically this mean that the local ring Qx=R[[x1..xn]]/Ix where R[[x1,..,xn]] is the ring of germs at 0 of real-valued analytic functions on R^n, and Ix is the ideal generated by the components of X is infinite dimensional as real vector space. In the case that X has a reduced hypersurface as complex zeroes we have the next. X has a reduced hypersurface as complex zeros we have the next. There exist a real analytic function f:R^n-->R, and a real analytic vector field Y s. t. X=fY. The function f does not change of sign bilinear form <,> obtained by composition of the product in the algebra Mx with a linear functional map .       L <,> : (Mx)x(Mx)----->Mx----->R <,> : (Mx)x(Mx) ---(.)--> Mx ---(L)--> R with L(Jp)>0, where Jp is the residue class of the Jacobian determinant of X, JX, over f^n, JX/(f^n) in Mx. Here, we use a natural linear functional defined as follows. Suppose that E={E_1,..E_r} is a basis of Mx, then Jp is writing as Jp=a_1E_{j1}+...+a_kE_{jk},  js\in {1...r}, s=1..k, k<=r. Jp=a_1E_{j1}+...+a_kE_{jk},  js\in {1...r}, s=1..k, k<=r, where a_s are constant. The linear functional L:M--->R is defined as L(E_{j1})=(a_1)/|a_1|=sign of a_1,
• Singular/LIB/polymake.lib

 r2ae96e version="$Id: polymake.lib,v 1.13 2009-04-06 12:39:02 seelisch Exp$"; version="$Id: polymake.lib,v 1.14 2009-04-07 16:18:06 seelisch Exp$"; category="Tropical Geometry"; info=" Most procedures will not work unless polymake or topcom is installed and if so, they will only work with the operating system LINUX! For more detailed information see IMPORTANT NOTE respectively consult the For more detailed information see the following note or consult the help string of the procedures. IMPORTANT NOTE: NOTE: Even though this is a Singular library for computing polytopes and fans such as the Newton polytope or the Groebner fan of a polynomial, most of @*   (see http://www.math.tu-berlin.de/polymake/), @* respectively (only in the procedure triangularions) by the program @* - topcom by Joerg Rambau, Universitaet Bayreuth (see @*   http://www.uni-bayreuth.de/departments/wirtschaftsmathematik/rambau/TOPCOM); @*   this library should rather be seen as an interface which allows to use a @* - topcom by Joerg Rambau, Universitaet Bayreuth (see http://www.uni-bayreuth.de/ departments/wirtschaftsmathematik/rambau/TOPCOM); @*   This library should rather be seen as an interface which allows to use a (very limited) number of options which polymake respectively topcom offers to compute with polytopes and fans and to make the results available in Singular for further computations; Singular for further computations; moreover, the user familiar with Singular does not have to learn the syntax of polymake or topcom, if the options offered here are sufficient for his secondaryFan       computes the secondary fan of a marked polytope PROCEDURES CONERNED WITH PLANAR POLYGONS: cycleLength      computes the cycleLength of cycle PROCEDURES CONCERNED WITH PLANAR POLYGONS: cycleLength      computes the cycleLength of cycle splitPolygon     splits a marked polygon into vertices, facets, interior points eta              computes the eta-vector of a triangulation computations with polymake, you have to use the procedure polymakeKeepTmpFiles in before @*    -  moreover, the procedure creates the file /tmp/polytope.output which @*    -  moreover, the procedure creates the file /tmp/polytope.output which it deletes again before ending @*    -  it is possible to provide an optional second argument as string @*    -  it is possible to provide an optional second argument a string which then will be used instead of 'polytope' in the name of the polymake output file proc newtonPolytope (poly f,list #) "USAGE: newtonPolytope(f[,#]);  f poly, # string RETURN: list, L with four entries RETURN: list L with four entries @*            L[1] : an integer matrix whose rows are the coordinates of vertices of the Newton polytope of f further computations with polymake @*    -  moreover, the procedure creates the file /tmp/newtonPolytope.output which it deletes again before ending @*    -  it is possible to give as an optional second argument as string and deletes it again before ending @*    -  it is possible to give as an optional second argument a string which then will be used instead of 'newtonPolytope' in the name of the polymake output file see http://www.math.tu-berlin.de/polymake/ @*       - in the optional argument # it is possible to hand over other names for the variables to be used -- be carful, the format must be correct and that is not tested, e.g. if you want the variable names to be u00,u10,u01,u11 then you must hand over the string u11,u10,u01,u11 for the variables to be used -- be careful, the format must be correct which is not tested, e.g. if you want the variable names to be u00,u10,u01,u11 then you must hand over the string 'u11,u10,u01,u11' EXAMPLE: example normalFan;   shows an example" { @*             L[4] = integer matrix where each row represents the exponet vector of one monomial occuring in the input polynomial NOTE: - if you have alread computed the Newton polytope of f then you might want NOTE: - if you have already computed the Newton polytope of f then you might want to use the procedure normalFan instead in order to avoid doing costly computation twice format; @*       - art is one of the following strings: @*         + 'rays'   : indicating that a first column of 0's should be added @*         + 'points' : indicating that a first column of 1's should be added @*           + 'rays'   : indicating that a first column of 0's should be added @*           + 'points' : indicating that a first column of 1's should be added RETURN:  string, the matrix is transformed in a string and a first column has been added the result which consists of vectors either over the integers or over the rationals RETURN:  intmat, the rows of the matrix are basically the vectors in pm from the second row on where each row has been multiplied with the lowest common multiple of the denominators of its entries so as to be an integer matrix; moreover, if art=='affine', then RETURN:  intmat, the rows of the matrix are basically the vectors in pm, starting from the second row, where each row has been multiplied with the lowest common multiple of the denominators of its entries as if it is an integer matrix; moreover, if art=='affine', then the first column is omitted since we only want affine coordinates proc secondaryPolytope (list polygon,list #) "USAGE:  secondaryPolytope(polygon[,#]); list polygon, list # ASSUME:  - polygon is a list of integer vectors of the same size representing ASSUME:  - polygon is a list of integer vectors of the same size representing the affine coordinates of lattice points @*       - if the triangulations of the corresponding polygon have already been @*       - if the triangulations of the corresponding polygon have already been computed with the procedure triangulations then these can be given as a second (optional) argument in order to avoid doing this computation PURPOSE: the procedure considers the marked polytope given as the convex hull of the lattice points and with these lattice points as markings; it then computes the lattice points of the secondary polytope given by this computes the lattice points of the secondary polytope given by this marked polytope which correspond to the triangulations computed by the procedure triangulations RETURN:  list, say L, such that: @*             L[1] = intmat, each row gives the affine coordinates of a lattice point in the secondary polytope given by the marked polytope corresponding to polygon point in the secondary polytope given by the marked polytope corresponding to polygon @*             L[2] = the list of corresponding triangulations NOTE: if the triangluations are not handed over as optional argument the NOTE: if the triangluations are not handed over as optional argument the procedure calls for its computation of these triangulations the program points2triangs from the program topcom by Joerg Rambau, Universitaet Bayreuth; it therefore is necessary that this program is installed in points2triangs from the program topcom by Joerg Rambau, Universitaet Bayreuth; it therefore is necessary that this program is installed in order to use this procedure; see @*    http://www.uni-bayreuth.de/departments/wirtschaftsmathematik/rambau/TOPCOM see http://www.math.tu-berlin.de/polymake/ @*   - in the optional argument # it is possible to hand over other names for the variables to be used -- be carful, the format must be correct and that is not tested, e.g. if you want the variable names to be u00,u10,u01,u11 then you must hand over the string u11,u10,u01,u11 the variables to be used -- be careful, the format must be correct which is not tested, e.g. if you want the variable names to be u00,u10,u01,u11 then you must hand over the string 'u11,u10,u01,u11' @*   - if the triangluations are not handed over as optional argument the procedure calls for its computation of these triangulations the program @*       triang is a list of integer vectors all of size three describing a triangulation of the polygon described by polygon; if an entry of triang is the vector (i,j,k) then the triangle is build by the vertices triang is the vector (i,j,k) then the triangle is built from the vertices with indices i, j and k RETURN:  intvec, the integer vector eta describing that vertex of the Newton Groebner fan contains the cone of the secondary fan of the polygon corresponding to the given triangulation NOTE:  for a better description of eta see either Gelfand, Kapranov, NOTE:  for a better description of eta see Gelfand, Kapranov, Zelevinski: Discriminants, Resultants and multidimensional Determinants. Chapter 10. proc findOrientedBoundary (list polygon) "USAGE: findOrientedBoundary(polygon); polygon list ASSUME: polygon is a list of integer vectors defining integer lattice points ASSUME: polygon is a list of integer vectors defining integer lattice points in the plane RETURN: list, l with the followin interpretation @*            l[1] = list of integer vectors such that the polygonal path defined by these is the boundary of the convex hull of RETURN: list l with the following interpretation @*            l[1] = list of integer vectors such that the polygonal path defined by these is the boundary of the convex hull of the lattice points in polygon @*            l[2] = list, the redundant points in l[1] have been removed // the basic idea is that a vertex can be // the next one on the boundary if all other vertices // ly to the right of the vector v pointing // lie to the right of the vector v pointing // from the testvertex to this one; this can be tested // by checking if the determinant of the 2x2-matrix points in points which in the triangulation triang are connected to the point points[pt]; the procedure computes all marked points in points which ly on the boundary of that polygon, ordered in points which lie on the boundary of that polygon, ordered clockwise RETURN:      list, of integer vectors which are the coordinates of the lattice proc ellipticNF (list polygon) "USAGE:  ellipticNF(polygon);   polygon list ASSUME:  polygon is a list of integer vectors in the plane such that their convex hull C has precisely one interior lattice point; i.e. C is the ASSUME:  polygon is a list of integer vectors in the plane such that their convex hull C has precisely one interior lattice point, i.e. C is the Newton polygon of an elliptic curve PURPOSE: compute the normal form of the polygon with respect to the unimodular proc ellipticNFDB (int n,list #) "USAGE:  ellipticNFDB(n[,#]);   n int, # list ASSUME:  n is an intger between 1 and 16 ASSUME:  n is an integer between 1 and 16 PURPOSE: this is a database storing the 16 normal forms of planar polygons with precisely one interior point up to unimodular affine transformations
• Singular/LIB/resolve.lib

 r2ae96e /////////////////////////////////////////////////////////////////////////////// version="$Id: resolve.lib,v 1.11 2008-09-24 16:41:31 Singular Exp$"; version="$Id: resolve.lib,v 1.12 2009-04-07 16:18:06 seelisch Exp$"; category="Commutative Algebra"; info=" of [Bravo,Encinas,Villamayor] RETURN:  list l, l[1]: ideal describing the center l[2]: intvec w obtained in the process of determining l[1] l[3]: intvec b obtained in the process of determining l[1] l[1]: ideal describing the center@* l[2]: intvec w obtained in the process of determining l[1]@* l[3]: intvec b obtained in the process of determining l[1]@* l[4]: intvec inv obtained in the process of determining l[1] EXAMPLE: example CenterBO;  shows an example
• Singular/LIB/sagbi.lib

 r2ae96e ////////////////////////////////////////////////////////////////////////////// version="$Id: sagbi.lib,v 1.12 2008-10-06 17:04:28 Singular Exp$"; version="$Id: sagbi.lib,v 1.13 2009-04-07 16:18:06 seelisch Exp$"; category="Commutative Algebra"; info=" LIBRARY:  sagbi.lib  Compute Subalgebras bases Analogous to Groebner bases for ideals LIBRARY:  sagbi.lib  Compute subalgebra bases analogous to Groebner bases for ideals AUTHORS: Gerhard Pfister,        pfister@mathematik.uni-kl.de, @*       Anen Lakhal,            alakhal@mathematik.uni-kl.de @format - If (n=0 or default) an ideal, whose generators are the S-polynomials. - If (n=1) a  list of size 2: - If (n=1) a list of size 2: the first element of this list is the ideal of S-polynomials. the second element of this list is the ring in which is defined the ideal of algebraic relations. the second element of this list is the ring in which the ideal of algebraic relations is defined. @end format EXAMPLE: example sagbiSPoly; show an example " proc sagbiNF(id,ideal dom,int k,list#) "USAGE: sagbiNF(id,dom,k[,n]); id either poly or ideal,dom ideal, k and n positive intergers. RETURN: depends On the type of id; ideal or polynomial. RETURN: same as type of id; ideal or polynomial. @format The integer k determines what kind of s-reduction is performed: - if (k=0) no tail s-reduction is performed. - if (k=1) tail s-reduction is performed. Three Algorthim  variants  are used to perform Subalgebra reduction. The positive integer n determine which variant should be used. Three Algorithm variants are used to perform subalgebra reduction. The positive integer n determines which variant should be used. n may take the values (0 or default),1 or 2. @end format NOTE: computation of Subalgebras normal forms may be performed either in polynomial rings or quotient polynomial rings NOTE: computation of subalgebra normal forms may be performed in polynomial rings or quotients thereof EXAMPLE: example sagbiNF; show example " { RETURN: A SAGBI basis for the subalgebra defined by the generators of id. @format k determine what kind of s-reduction is performed: k determines what kind of s-reduction is performed: - if (k=0) no tail s-reduction is performed. - if (k=1) tail s-reduction is performed, and S-interreduced SAGBI basis is returned. Three Algorithm variants are used to perform Subalgebra reduction. Three algorithm variants are used to perform subalgebra reduction. The positive interger n determine which variant should be used. n may take the values (0 or default),1 or 2. @end format NOTE: SAGBI bases computations may be performed either in polynomial rings or quotient polynomial rings. NOTE: SAGBI bases computations may be performed in polynomial rings or quotients thereof. EXAMPLE: example sagbi; show example " { /////////////////////////////////////////////////////////////////////////////// proc sagbiPart(id,int k,int c,list #) "USAGE: sagbi(id,k,c[,n]); id ideal, k, c and n positive integer. "USAGE: sagbiPart(id,k,c[,n]); id ideal, k, c and n positive integers RETURN: A partial SAGBI basis for the subalgebra defined by the generators of id. @format should stop. k determine what kind of s-reduction is performed: k determines what kind of s-reduction is performed: - if (k=0) no tail s-reduction is performed. - if (k=1) tail s-reduction is performed, and S-intereduced SAGBI basis is returned. c  determines, after which turn Sagbi basis computations should stop Three Algorithm variants are used to perform Subalgebra reduction. c determines, after how many loops the Sagbi basis computation should stop. Three algorithm variants are used to perform subalgebra reduction. The positive integer n determines which variant should be used. n may take the values (0 or default),1 or 2. @end format NOTE:- SAGBI bases computations may be performed either in polynomial rings or quotient polynomial rings. - This version of sagbi procedure is interesting in the case of an Subalgebras with infinte SAGBI basis. In this case, by means of this procedure, we may check for example, if the elements of this basis have a particular form. NOTE:- SAGBI bases computations may be performed in polynomial rings or quotients thereof. - This version of sagbi is interesting in the case of subalgebras with infinte SAGBI basis. In this case, it may be used to check, if the elements of this basis have a particular form. EXAMPLE: example sagbiPart; show example " {
• Singular/LIB/sheafcoh.lib

 r2ae96e /////////////////////////////////////////////////////////////////////////////// version="$Id: sheafcoh.lib,v 1.15 2007-10-30 17:17:44 Singular Exp$"; version="$Id: sheafcoh.lib,v 1.16 2009-04-07 16:18:06 seelisch Exp$"; category="Commutative Algebra"; info=" RETURN:  module NOTE:    Output is a presentation matrix for the truncation of coker(M) at d. at degree d. EXAMPLE: example truncate; shows an example KEYWORDS: truncated module
• Singular/LIB/sing4ti2.lib

 r2ae96e /////////////////////////////////////////////////////////////////// version="$Id: sing4ti2.lib,v 1.1 2009-03-10 16:51:29 Singular Exp$"; version="$Id: sing4ti2.lib,v 1.2 2009-04-07 16:18:06 seelisch Exp$"; category="Commutative Algebra"; info=" NOTE:    input rules for 4ti2 also apply to input to this procedure @*       hence ker(A)={x|Ax=0} and Im(A)={xA} RETURN:  toric ideal specified by Graver basis thereof RETURN:  toric ideal specified by Hilbert basis thereof EXAMPLE: example graver4ti2; shows an example "
• Singular/LIB/tropical.lib

 r2ae96e version="$Id: tropical.lib,v 1.12 2009-03-25 11:27:13 keilen Exp$"; version="$Id: tropical.lib,v 1.13 2009-04-07 16:18:06 seelisch Exp$"; category="Tropical Geometry"; info=" rational numbers Q and to replace Puiseux series in t by rational functions in t, i.e. we replace C{{t}} by Q(t), or sometimes even by Q[t]. Note, that this in particular forbits rational exponents for the t's. Note, that this in particular forbids rational exponents for the t's. Moreover, in Singular no negative exponents of monomials are allowed, so have to pass right away to the tropicalisation of the equations, whereever this is allowed -- these are linear polynomials where the constant coefficient correspond to the valuation of the original coefficient and where corresponds to the valuation of the original coefficient and where the non-constant coefficient correspond to the exponents of the monomials, thus they may be rational numbers respectively negative numbers: subring of C{{t}}[x1,...,xn]; a solution will be constructed up to given order; note that several field extensions of Q might be necessary thoughout the intermediate computations; the procedures uses field extensions of Q might be necessary throughout the intermediate computations; the procedures use the external program gfan @*  - drawTropicalCurve  visualises a tropical plane curve either given by a e.g. ring r=0,(t,x(1..n)),dp; @*       - the first variable of the basering will be treated as the parameter t in the Puiseux series field !!!! parameter t in the Puiseux series field @*       - the optional parameter opt should be one or more strings among the following: ideal over (w_1/w_0,...,w_n/w_0) @*         'noAbs'              : do NOT use absolute primary decomposition @*         'noResubst'         : avoids computing the resubstitution @*         'noResubst'         : avoids the computation of the resubstitution RETURN:  IF THE OPTION 'findAll' WAS NOT SET THEN: @*       list, containing one lifting of the given point (w_1/w_0,...,w_n/w_0) in the tropical variety of i to a point in V(i) over Puiseux series field up to the first ord terms; more precisely: @*             IF THE OPTION 'noAbs' WAS NOT SET THEN: @*             IF THE OPTION 'noAbs' WAS NOT SET, THEN: @*             l[1] = ring Q[a]/m[[t]] @*             l[2] = int @*             l[3] = intvec @*             l[4] = list @*             IF THE OPTION 'noAbs' WAS SET THEN: @*             IF THE OPTION 'noAbs' WAS SET, THEN: @*             l[1] = ring Q[X(1),...,X(k)]/m[[t]] @*             l[2] = int @*             l[4] = list @*             l[5] = string @*       IF THE OPITON 'findAll' WAS NOT SET THEN: @*       IF THE OPITON 'findAll' WAS SET, THEN: @*       list, containing ALL liftings of the given point ((w_1/w_0,...,w_n/w_0) in the tropical variety of i to a point in V(i) over Puiseux zero-dimensional over Q{{t}}; more precisely, each entry of the list is a list l as computed if  'find_all' was NOT set if  'findAll' was NOT set @*       WE NOW DESCRIBE THE LIST ENTRIES IF 'findAll' WAS NOT SET: @*       - the ring l[1] contains an ideal LIFT, which contains in Q{{t}}[x_1,...,x_n] then ALL points in V(i) lying over w are computed up to order ord; if the ideal is not-zero dimenisonal, then only all points in the ideal after cutting down to dimension zero only the points in the ideal after cutting down to dimension zero will be computed @*       - the procedure REQUIRES that the program GFAN is installed on your computer; if you have GFAN version less than 0.3.0 then you MUST @*       - the procedure requires that the program GFAN is installed on your computer; if you have GFAN version less than 0.3.0 then you must use the optional parameter 'oldGfan' @*       - the procedure requires the Singular procedure absPrimdecGTZ to be the option 'noAbs' in order to avoid the costly absolute primary decomposition; the side effect is that the field extension which is computed throughout the recursion might need more only one computed throughout the recursion might need more than one parameter to be described @*       - since Q is infinite, the procedure finishes with probability one decomposition in Singular only works in characteristic zero @*       - the basefield should either be Q or Z/pZ for some prime p; field extensions will be computed where necessary; if you need field extensions will be computed if necessary; if you need parameters or field extensions from the beginning they should rather be simulated as variables possibly adding their relations to variables and up to one parameter! RETURN:      NONE NOTE:        - the procedure produces the files /tmp/tropicalcurveNUMBER.tex and NOTE:        - the procedure creates the files /tmp/tropicalcurveNUMBER.tex and /tmp/tropicalcurveNUMBER.ps, where NUMBER is a random four digit integer; and up to one parameter! RETURN:   NONE NOTE:     - the procedure produces the files /tmp/newtonsubdivisionNUMBER.tex, NOTE:     - the procedure creates the files /tmp/newtonsubdivisionNUMBER.tex, and /tmp/newtonsubdivisionNUMBER.ps, where NUMBER is a random four digit integer; ///////////////////////////////////////////////////////////////////////// proc tInitialIdeal (ideal i,intvec w,list #) proc tInitialIdeal (ideal i,intvec w,list #) "USAGE:      tInitialIdeal(i,w); i ideal, w intvec ASSUME:      i is an ideal in Q[t,x_1,...,x_n] and w=(w_0,...,w_n) "USAGE:      initialForm(f,w); f a polynomial, w an integer vector ASSUME:      f is a polynomial in Q[x_1,...,x_n] and w=(w_1,...,w_n) RETURN:      poly, the initialForm of f(x) w.r.t. w NOTE:        the initialForm are the terms with MAXIMAL weighted order w.r.t. w RETURN:      poly, the initial form of f(x) w.r.t. w NOTE:        the initialForm consists of the terms with MAXIMAL weighted order w.r.t. w EXAMPLE:     example initialForm;   shows an example" { ASSUME:      i is an ideal in Q[x_1,...,x_n] and w=(w_1,...,w_n) RETURN:      ideal, the initialIdeal of i w.r.t. w NOTE:        the initialform are the terms with MAXIMAL weighted order w.r.t. w NOTE:        the initialIdeal consists of the terms with MAXIMAL weighted order w.r.t. w EXAMPLE:     example initialIdeal;   shows an example" { "USAGE:      texDrawNewtonSubdivision(graph[,#]); graph list, # optional list ASSUME:      graph is the output of tropicalCurve RETURN:      string, the texdraw code of the Newton subdivision of the RETURN:      string, the texdraw code of the Newton subdivision of the tropical plane curve encoded by graph NOTE:        - the list # should contain as only entry a string; if this string is 'max', then the tropical curve is considered with respect to the maximum; otherwise the curve is considered with respect to the minimum and the string can be used to insert further NOTE:        - the list # should contain only one entry which is a string; if this string is 'max', then the tropical curve is considered with respect to the maximum; otherwise the curve is considered with respect to the minimum and the string can be used to insert further texdraw commands (e.g. to have a lighter image as when called from inside conicWithTangents); the list # is optional and may from inside conicWithTangents); the list # is optional and may as well be empty @*           - note that lattice points in the Newton subdivision which are black correspond to markings of the marked subdivision, @*           - note that lattice points in the Newton subdivision which are black correspond to markings of the marked subdivision, while lattice points in grey are not marked EXAMPLE:     example texDrawNewtonSubdivision;   shows an example" int i,j,k,l; list boundary=graph[size(graph)][1]; list inneredges=graph[size(graph)][2]; list inneredges=graph[size(graph)][2]; intvec shiftvector=graph[size(graph)][3]; string subdivision; ASSUME:   f is a polynomial in Q(t)[x_1,...,x_n] describing a plane curve over Q(t) RETURN:   poly, f with t replaced by t^N RETURN:   poly f with t replaced by t^N EXAMPLE:  example parameterSubstitute;   shows an example" {
Note: See TracChangeset for help on using the changeset viewer.