Changeset 906458 in git for Singular/LIB


Ignore:
Timestamp:
Apr 7, 2009, 6:18:06 PM (15 years ago)
Author:
Frank Seelisch <seelisch@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'dce4ad324f6e216ae93a99713959b505fb6213d3')
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

Legend:

Unmodified
Added
Removed
  • Singular/LIB/algebra.lib

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

    r2ae96e r906458  
    11// IB/IG/JJS, last modified: 10.07.2007
    22///////////////////////////////////////////////////////////////////////////////////////////////////////////
    3 version = "$Id: cimonom.lib,v 1.3 2008-10-07 09:05:07 Singular Exp $";
     3version = "$Id: cimonom.lib,v 1.4 2009-04-07 16:18:05 seelisch Exp $";
    44category="Commutative Algebra";
    55info="
     
    560560example
    561561{ "EXAMPLE:";
    562    "printlevel = 0;";
    563562   printlevel = 0;
    564    "intvec d = 14,15,10,21;";
    565563   intvec d = 14,15,10,21;
    566    "CompInt(d);";
    567564   CompInt(d);
    568    " ";
    569    "printlevel = 2;";
    570565   printlevel = 3;
    571    "d = 36,54,125,150,225;";
    572566   d = 36,54,125,150,225;
    573    "CompInt(d);";
    574567   CompInt(d);
    575    " ";
    576    "d = 45,70,75,98,147;";
    577568   d = 45,70,75,98,147;
    578    "CompInt(d);";
    579569   CompInt(d);
    580570};
  • Singular/LIB/elim.lib

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

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

    r2ae96e r906458  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: intprog.lib,v 1.6 2006-07-25 17:54:27 Singular Exp $";
     2version="$Id: intprog.lib,v 1.7 2009-04-07 16:18:05 seelisch Exp $";
    33category="Commutative Algebra";
    44info="
     
    633633
    634634proc solve_IP
    635 "USAGE:  solve_IP(A,bx,c,alg);  A intmat, bx intvec, c intvec, alg string.
     635"USAGE:  solve_IP(A,bx,c,alg);  A intmat, bx intvec, c intvec, alg string.@*
    636636        solve_IP(A,bx,c,alg);  A intmat, bx list of intvec, c intvec,
    637                                  alg string.
     637                                 alg string.@*
    638638        solve_IP(A,bx,c,alg,prsv);  A intmat, bx intvec, c intvec,
    639                                  alg string, prsv intvec.
     639                                 alg string, prsv intvec.@*
    640640        solve_IP(A,bx,c,alg,prsv);  A intmat, bx list of intvec, c intvec,
    641641                                 alg string, prsv intvec.
  • Singular/LIB/linalg.lib

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

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

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

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

    r2ae96e r906458  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: phindex.lib,v 1.3 2008-10-09 09:31:57 Singular Exp $";
     2version="$Id: phindex.lib,v 1.4 2009-04-07 16:18:05 seelisch Exp $";
    33category=" ";
    44info="
     
    1010      germ  found by Eisenbud-Levine in 1997. This result was also proved by
    1111      Khimshiashvili. If the isolated singularity is non algebraically
    12       isolated  and the vector field has a reduced complex zeroes of
     12      isolated  and the vector field has similar reduced complex zeroes of
    1313      codimension 1, we use a formula as the Eisenbud-Levine found by Victor
    1414      Castellanos, in both cases is necessary to use a local order (ds,...).
     
    3030"USAGE:    signatureL(M[,r]); M symmetric matrix, r int (optional).
    3131RETURN:   the signature of M of type int or if r is given and !=0 then
    32           intvec with (signature, no of +, no of -) is returned.
    33 THEORY:   Given the matrix M we construct the quadratic form associated, after
     32          intvec with (signature, nr. of +, nr. of -) is returned.
     33THEORY:   Given the matrix M, we construct the quadratic form associated. Afterwards
    3434          we use the method of Lagrange to compute the signature. The law of
    35           inertia for a real quadratic form A(x,x) say that in a
     35          inertia for a real quadratic form A(x,x) says that in a
    3636          representation of A(x,x) as a sum of independent squares
    3737                            A(x,x)=sum_{i=1}^r a_iX_i^2.
     
    9898"USAGE:    signatureLqf(h); h quadratic form (poly type).
    9999RETURN:   the signature of h of type int or if r is given and !=0 then
    100           intvec with (signature, no of +, no of -) is returned.
     100          intvec with (signature, nr. of +, nr. of -) is returned.
    101101THEORY:   To compute the signature we use the method of Lagrange. The law of
    102           inertia for a real quadratic form h(x,x) say that in a
     102          inertia for a real quadratic form h(x,x) says that in a
    103103          representation  of h(x,x) as a sum of independent squares
    104                              h(x,x)=sum_{i=1}^r a_iX_i^ 2
    105           the number of positive and the number of negative squares are
     104          h(x,x)=sum_{i=1}^r a_i*X_i^2 the number of positive and the number of negative squares are
    106105          independent of the choice of representation. The signature -s- of
    107106          h(x,x) is the difference between the number -pi- of positive squares
     
    229228NOTE:     the isolated singularity must be algebraically isolated.
    230229THEORY:   The Poincare-Hopf index of a real vector field X at the isolated
    231           singularity 0 is the degree of map
    232                            (X/|X|) : S_epsilon ---> S,
     230          singularity 0 is the degree of the map (X/|X|) : S_epsilon ---> S,
    233231          where S is the unit sphere, and the spheres are oriented as
    234232          (n-1)-spheres in R^n. The degree depends only on the germ, X, of X
     
    245243          composition of the product in the algebra Qx with a linear
    246244          functional map
    247                                         .       L
    248                        <,> : (Qx)x(Qx)----->Qx----->R
     245                       <,> : (Qx)x(Qx) ---(.)--> Qx ---(L)--> R
    249246          with L(Jo)>0, where Jo is the residue class of the Jacobian
    250247          determinant in Qx. Here, we use a natural linear functional defined
    251           as follows. Suppose that E={E_1,..E_r} is a basis of Qx, then Jo is
    252           writing as
    253                       Jo=a_1E_{j1}+...+a_kE_{jk},  js\in {1...r}, s=1..k, k<=r.
     248          as follows. Suppose that E={E_1,..E_r} is a basis of Qx, then Jo can
     249          be written as
     250                      Jo=a_1E_{j1}+...+a_kE_{jk},  js\in {1...r}, s=1..k, k<=r,
    254251          where a_s are constant. The linear functional L:Qx--->R is defined as
    255252                                  L(E_{j1})=(a_1)/|a_1|=sign of a_1,
     
    355352          at 0, with reduced complex zeros of codimension 1.
    356353THEORY:   Suppose that 0 is an algebraically isolated singularity of the real
    357           analytic vector field X, geometrically its mean that the
     354          analytic vector field X, geometrically this corresponds to the fact that the
    358355          complexified vector field has positive dimension singular locus,
    359           algebraically this mean that the local ring
    360                       Qx=R[[x1..xn]]/Ix
     356          algebraically this mean that the local ring Qx=R[[x1..xn]]/Ix
    361357          where R[[x1,..,xn]] is the ring of germs at 0 of real-valued analytic
    362358          functions on R^n, and Ix is the ideal generated by the components
    363359          of X is infinite dimensional as real vector space. In the case that
    364           X has a reduced hypersurface as complex zeroes we have the next.
     360          X has a reduced hypersurface as complex zeros we have the next.
    365361          There exist a real analytic function f:R^n-->R, and a real analytic
    366362          vector field Y s. t. X=fY. The function f does not change of sign
     
    371367          bilinear form <,> obtained by composition of the product in the
    372368          algebra Mx with a linear functional map
    373                                         .       L
    374                        <,> : (Mx)x(Mx)----->Mx----->R
     369                       <,> : (Mx)x(Mx) ---(.)--> Mx ---(L)--> R
    375370          with L(Jp)>0, where Jp is the residue class of the Jacobian
    376371          determinant of X, JX, over f^n, JX/(f^n) in Mx. Here, we use a
    377372          natural linear functional defined as follows. Suppose that
    378373          E={E_1,..E_r} is a basis of Mx, then Jp is writing as
    379                       Jp=a_1E_{j1}+...+a_kE_{jk},  js\in {1...r}, s=1..k, k<=r.
     374                      Jp=a_1E_{j1}+...+a_kE_{jk},  js\in {1...r}, s=1..k, k<=r,
    380375          where a_s are constant. The linear functional L:M--->R is defined as
    381376                                  L(E_{j1})=(a_1)/|a_1|=sign of a_1,
  • Singular/LIB/polymake.lib

    r2ae96e r906458  
    1 version="$Id: polymake.lib,v 1.13 2009-04-06 12:39:02 seelisch Exp $";
     1version="$Id: polymake.lib,v 1.14 2009-04-07 16:18:06 seelisch Exp $";
    22category="Tropical Geometry";
    33info="
     
    99   Most procedures will not work unless polymake or topcom is installed and
    1010   if so, they will only work with the operating system LINUX!
    11    For more detailed information see IMPORTANT NOTE respectively consult the
     11   For more detailed information see the following note or consult the
    1212   help string of the procedures.
    1313
    14 IMPORTANT NOTE:
     14NOTE:
    1515   Even though this is a Singular library for computing polytopes and fans
    1616   such as the Newton polytope or the Groebner fan of a polynomial, most of
     
    1919@*   (see http://www.math.tu-berlin.de/polymake/), 
    2020@* respectively (only in the procedure triangularions) by the program
    21 @* - topcom by Joerg Rambau, Universitaet Bayreuth (see
    22 @*   http://www.uni-bayreuth.de/departments/wirtschaftsmathematik/rambau/TOPCOM);
    23 @*   this library should rather be seen as an interface which allows to use a
     21@* - topcom by Joerg Rambau, Universitaet Bayreuth (see http://www.uni-bayreuth.de/
     22     departments/wirtschaftsmathematik/rambau/TOPCOM);
     23@*   This library should rather be seen as an interface which allows to use a
    2424     (very limited) number of options which polymake respectively topcom offers
    2525     to compute with polytopes and fans and to make the results available in
    26      Singular for further computations; 
     26     Singular for further computations;
    2727     moreover, the user familiar with Singular does not have to learn the syntax
    2828     of polymake or topcom, if the options offered here are sufficient for his
     
    4747  secondaryFan       computes the secondary fan of a marked polytope
    4848
    49 PROCEDURES CONERNED WITH PLANAR POLYGONS:
    50   cycleLength      computes the cycleLength of cycle 
     49PROCEDURES CONCERNED WITH PLANAR POLYGONS:
     50  cycleLength      computes the cycleLength of cycle
    5151  splitPolygon     splits a marked polygon into vertices, facets, interior points
    5252  eta              computes the eta-vector of a triangulation
     
    125125         computations with polymake, you have to use the procedure
    126126         polymakeKeepTmpFiles in before
    127 @*    -  moreover, the procedure creates the file /tmp/polytope.output which 
     127@*    -  moreover, the procedure creates the file /tmp/polytope.output which
    128128         it deletes again before ending
    129 @*    -  it is possible to provide an optional second argument as string
     129@*    -  it is possible to provide an optional second argument a string
    130130         which then will be used instead of 'polytope' in the name of the
    131131         polymake output file
     
    257257proc newtonPolytope (poly f,list #)
    258258"USAGE: newtonPolytope(f[,#]);  f poly, # string
    259 RETURN: list, L with four entries
     259RETURN: list L with four entries
    260260@*            L[1] : an integer matrix whose rows are the coordinates of vertices
    261261                     of the Newton polytope of f
     
    282282         further computations with polymake
    283283@*    -  moreover, the procedure creates the file /tmp/newtonPolytope.output
    284          which it deletes again before ending
    285 @*    -  it is possible to give as an optional second argument as string
     284         and deletes it again before ending
     285@*    -  it is possible to give as an optional second argument a string
    286286         which then will be used instead of 'newtonPolytope' in the name of
    287287         the polymake output file
     
    398398           see http://www.math.tu-berlin.de/polymake/
    399399@*       - in the optional argument # it is possible to hand over other names
    400            for the variables to be used -- be carful, the format must be correct
    401            and that is not tested, e.g. if you want the variable names to be
    402            u00,u10,u01,u11 then you must hand over the string u11,u10,u01,u11
     400           for the variables to be used -- be careful, the format must be correct
     401           which is not tested, e.g. if you want the variable names to be
     402           u00,u10,u01,u11 then you must hand over the string 'u11,u10,u01,u11'
    403403EXAMPLE: example normalFan;   shows an example"
    404404{
     
    570570@*             L[4] = integer matrix where each row represents the exponet
    571571                      vector of one monomial occuring in the input polynomial
    572 NOTE: - if you have alread computed the Newton polytope of f then you might want
     572NOTE: - if you have already computed the Newton polytope of f then you might want
    573573        to use the procedure normalFan instead in order to avoid doing costly
    574574        computation twice
     
    652652           format;
    653653@*       - art is one of the following strings:
    654 @*         + 'rays'   : indicating that a first column of 0's should be added
    655 @*         + 'points' : indicating that a first column of 1's should be added
     654@*           + 'rays'   : indicating that a first column of 0's should be added
     655@*           + 'points' : indicating that a first column of 1's should be added
    656656RETURN:  string, the matrix is transformed in a string and a first column has
    657657                 been added
     
    702702         the result which consists of vectors either over the integers
    703703         or over the rationals
    704 RETURN:  intmat, the rows of the matrix are basically the vectors in pm from
    705                  the second row on where each row has been multiplied with the
    706                  lowest common multiple of the denominators of its entries so
    707                  as to be an integer matrix; moreover, if art=='affine', then
     704RETURN:  intmat, the rows of the matrix are basically the vectors in pm, starting
     705                 from the second row, where each row has been multiplied with the
     706                 lowest common multiple of the denominators of its entries as if
     707                 it is an integer matrix; moreover, if art=='affine', then
    708708                 the first column is omitted since we only want affine
    709709                 coordinates
     
    990990proc secondaryPolytope (list polygon,list #)
    991991"USAGE:  secondaryPolytope(polygon[,#]); list polygon, list #
    992 ASSUME:  - polygon is a list of integer vectors of the same size representing 
     992ASSUME:  - polygon is a list of integer vectors of the same size representing
    993993           the affine coordinates of lattice points
    994 @*       - if the triangulations of the corresponding polygon have already been 
     994@*       - if the triangulations of the corresponding polygon have already been
    995995           computed with the procedure triangulations then these can be given as
    996996           a second (optional) argument in order to avoid doing this computation
     
    998998PURPOSE: the procedure considers the marked polytope given as the convex hull of
    999999         the lattice points and with these lattice points as markings; it then
    1000          computes the lattice points of the secondary polytope given by this 
     1000         computes the lattice points of the secondary polytope given by this
    10011001         marked polytope which correspond to the triangulations computed by
    10021002         the procedure triangulations
    10031003RETURN:  list, say L, such that:
    10041004@*             L[1] = intmat, each row gives the affine coordinates of a lattice
    1005                       point in the secondary polytope given by the marked
    1006                       polytope corresponding to polygon
     1005                      point in the secondary polytope given by the marked polytope
     1006                      corresponding to polygon
    10071007@*             L[2] = the list of corresponding triangulations
    1008 NOTE: if the triangluations are not handed over as optional argument the 
     1008NOTE: if the triangluations are not handed over as optional argument the
    10091009      procedure calls for its computation of these triangulations the program
    1010       points2triangs from the program topcom by Joerg Rambau, Universitaet 
    1011       Bayreuth; it therefore is necessary that this program is installed in 
     1010      points2triangs from the program topcom by Joerg Rambau, Universitaet
     1011      Bayreuth; it therefore is necessary that this program is installed in
    10121012      order to use this procedure; see
    10131013@*    http://www.uni-bayreuth.de/departments/wirtschaftsmathematik/rambau/TOPCOM
     
    11171117       see http://www.math.tu-berlin.de/polymake/
    11181118@*   - in the optional argument # it is possible to hand over other names for
    1119        the variables to be used -- be carful, the format must be correct and
    1120        that is not tested, e.g. if you want the variable names to be
    1121        u00,u10,u01,u11 then you must hand over the string u11,u10,u01,u11
     1119       the variables to be used -- be careful, the format must be correct
     1120       which is not tested, e.g. if you want the variable names to be
     1121       u00,u10,u01,u11 then you must hand over the string 'u11,u10,u01,u11'
    11221122@*   - if the triangluations are not handed over as optional argument the
    11231123       procedure calls for its computation of these triangulations the program
     
    13811381@*       triang is a list of integer vectors all of size three describing a
    13821382         triangulation of the polygon described by polygon; if an entry of
    1383          triang is the vector (i,j,k) then the triangle is build by the vertices
     1383         triang is the vector (i,j,k) then the triangle is built from the vertices
    13841384         with indices i, j and k
    13851385RETURN:  intvec, the integer vector eta describing that vertex of the Newton
     
    13871387                 Groebner fan contains the cone of the secondary fan of the
    13881388                 polygon corresponding to the given triangulation
    1389 NOTE:  for a better description of eta see either Gelfand, Kapranov,
     1389NOTE:  for a better description of eta see Gelfand, Kapranov,
    13901390       Zelevinski: Discriminants, Resultants and multidimensional Determinants.
    13911391       Chapter 10.
     
    15921592proc findOrientedBoundary (list polygon)
    15931593"USAGE: findOrientedBoundary(polygon); polygon list
    1594 ASSUME: polygon is a list of integer vectors defining integer lattice points 
     1594ASSUME: polygon is a list of integer vectors defining integer lattice points
    15951595        in the plane
    1596 RETURN: list, l with the followin interpretation
    1597 @*            l[1] = list of integer vectors such that the polygonal path 
    1598                      defined by these is the boundary of the convex hull of 
     1596RETURN: list l with the following interpretation
     1597@*            l[1] = list of integer vectors such that the polygonal path
     1598                     defined by these is the boundary of the convex hull of
    15991599                     the lattice points in polygon
    16001600@*            l[2] = list, the redundant points in l[1] have been removed
     
    16791679  // the basic idea is that a vertex can be
    16801680  // the next one on the boundary if all other vertices
    1681   // ly to the right of the vector v pointing
     1681  // lie to the right of the vector v pointing
    16821682  // from the testvertex to this one; this can be tested
    16831683  // by checking if the determinant of the 2x2-matrix
     
    18201820             points in points which in the triangulation triang are connected
    18211821             to the point points[pt]; the procedure computes all marked points
    1822              in points which ly on the boundary of that polygon, ordered
     1822             in points which lie on the boundary of that polygon, ordered
    18231823             clockwise
    18241824RETURN:      list, of integer vectors which are the coordinates of the lattice
     
    19751975proc ellipticNF (list polygon)
    19761976"USAGE:  ellipticNF(polygon);   polygon list
    1977 ASSUME:  polygon is a list of integer vectors in the plane such that their 
    1978          convex hull C has precisely one interior lattice point; i.e. C is the
     1977ASSUME:  polygon is a list of integer vectors in the plane such that their
     1978         convex hull C has precisely one interior lattice point, i.e. C is the
    19791979         Newton polygon of an elliptic curve
    19801980PURPOSE: compute the normal form of the polygon with respect to the unimodular
     
    22462246proc ellipticNFDB (int n,list #)
    22472247"USAGE:  ellipticNFDB(n[,#]);   n int, # list
    2248 ASSUME:  n is an intger between 1 and 16
     2248ASSUME:  n is an integer between 1 and 16
    22492249PURPOSE: this is a database storing the 16 normal forms of planar polygons with
    22502250         precisely one interior point up to unimodular affine transformations
  • Singular/LIB/resolve.lib

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

    r2ae96e r906458  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: sagbi.lib,v 1.12 2008-10-06 17:04:28 Singular Exp $";
     2version="$Id: sagbi.lib,v 1.13 2009-04-07 16:18:06 seelisch Exp $";
    33category="Commutative Algebra";
    44info="
    5 LIBRARY:  sagbi.lib  Compute Subalgebras bases Analogous to Groebner bases for ideals
     5LIBRARY:  sagbi.lib  Compute subalgebra bases analogous to Groebner bases for ideals
    66AUTHORS: Gerhard Pfister,        pfister@mathematik.uni-kl.de,
    77@*       Anen Lakhal,            alakhal@mathematik.uni-kl.de
     
    2424@format
    2525      - If (n=0 or default) an ideal, whose generators are the S-polynomials.
    26       - If (n=1) a  list of size 2:
     26      - If (n=1) a list of size 2:
    2727        the first element of this list is the ideal of S-polynomials.
    28         the second element of this list is the ring in which is defined
    29         the ideal of algebraic relations.
     28        the second element of this list is the ring in which the ideal of algebraic
     29        relations is defined.
    3030@end format
    3131EXAMPLE: example sagbiSPoly; show an example "
     
    426426proc sagbiNF(id,ideal dom,int k,list#)
    427427"USAGE: sagbiNF(id,dom,k[,n]); id either poly or ideal,dom ideal, k and n positive intergers.
    428 RETURN: depends On the type of id; ideal or polynomial.
     428RETURN: same as type of id; ideal or polynomial.
    429429@format
    430430    The integer k determines what kind of s-reduction is performed:
    431431    - if (k=0) no tail s-reduction is performed.
    432432    - if (k=1) tail s-reduction is performed.
    433     Three Algorthim  variants  are used to perform Subalgebra reduction.
    434     The positive integer n determine which variant should be used.
     433    Three Algorithm variants are used to perform subalgebra reduction.
     434    The positive integer n determines which variant should be used.
    435435    n may take the values (0 or default),1 or 2.
    436436@end format
    437 NOTE: computation of Subalgebras normal forms may be performed either
    438       in polynomial rings or quotient polynomial rings
     437NOTE: computation of subalgebra normal forms may be performed in polynomial rings or quotients
     438      thereof
    439439EXAMPLE: example sagbiNF; show example "
    440440{
     
    514514RETURN: A SAGBI basis for the subalgebra defined by the generators of id.
    515515@format
    516     k determine what kind of s-reduction is performed:
     516    k determines what kind of s-reduction is performed:
    517517     - if (k=0) no tail s-reduction is performed.
    518518     - if (k=1) tail s-reduction is performed, and S-interreduced SAGBI basis
    519519       is returned.
    520     Three Algorithm variants are used to perform Subalgebra reduction.
     520    Three algorithm variants are used to perform subalgebra reduction.
    521521    The positive interger n determine which variant should be used.
    522522    n may take the values (0 or default),1 or 2.
    523523@end format
    524 NOTE: SAGBI bases computations may be performed either
    525       in polynomial rings or quotient polynomial rings.
     524NOTE: SAGBI bases computations may be performed in polynomial rings or quotients
     525      thereof.
    526526EXAMPLE: example sagbi; show example "
    527527{
     
    548548///////////////////////////////////////////////////////////////////////////////
    549549proc sagbiPart(id,int k,int c,list #)
    550 "USAGE: sagbi(id,k,c[,n]); id ideal, k, c and n positive integer.
     550"USAGE: sagbiPart(id,k,c[,n]); id ideal, k, c and n positive integers
    551551RETURN: A partial SAGBI basis for the subalgebra defined by the generators of id.
    552552@format
    553      should stop. k determine what kind of s-reduction is performed:
     553     k determines what kind of s-reduction is performed:
    554554     - if (k=0) no tail s-reduction is performed.
    555555     - if (k=1) tail s-reduction is performed, and S-intereduced SAGBI basis
    556556      is returned.
    557      c  determines, after which turn Sagbi basis computations should stop
    558      Three Algorithm variants are used to perform Subalgebra reduction.
     557     c determines, after how many loops the Sagbi basis computation should stop.
     558     Three algorithm variants are used to perform subalgebra reduction.
    559559     The positive integer n determines which variant should be used.
    560560     n may take the values (0 or default),1 or 2.
    561561@end format
    562 NOTE:- SAGBI bases computations may be performed either
    563        in polynomial rings or quotient polynomial rings.
    564      - This version of sagbi procedure is interesting in the case of an Subalgebras
    565        with infinte SAGBI basis. In this case, by means of this procedure,
    566        we may check for example, if the elements of this basis have a particular form.
     562NOTE:- SAGBI bases computations may be performed in polynomial rings or quotients
     563       thereof.
     564     - This version of sagbi is interesting in the case of subalgebras with infinte
     565       SAGBI basis. In this case, it may be used to check, if the elements of this
     566       basis have a particular form.
    567567EXAMPLE: example sagbiPart; show example "
    568568{
  • Singular/LIB/sheafcoh.lib

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

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

    r2ae96e r906458  
    1 version="$Id: tropical.lib,v 1.12 2009-03-25 11:27:13 keilen Exp $";
     1version="$Id: tropical.lib,v 1.13 2009-04-07 16:18:06 seelisch Exp $";
    22category="Tropical Geometry";
    33info="
     
    5050  rational numbers Q and to replace Puiseux series in t by rational functions
    5151  in t, i.e. we replace C{{t}} by Q(t), or sometimes even by Q[t].
    52   Note, that this in particular forbits rational exponents for the t's.
     52  Note, that this in particular forbids rational exponents for the t's.
    5353
    5454  Moreover, in Singular no negative exponents of monomials are allowed, so
     
    6060  have to pass right away to the tropicalisation of the equations, whereever
    6161  this is allowed -- these are linear polynomials where the constant coefficient
    62   correspond to the valuation of the original coefficient and where
     62  corresponds to the valuation of the original coefficient and where
    6363  the non-constant coefficient correspond to the exponents of the monomials,
    6464  thus they may be rational numbers respectively negative numbers:
     
    7474                         subring of C{{t}}[x1,...,xn]; a solution will be
    7575                         constructed up to given order; note that several
    76                          field extensions of Q might be necessary thoughout
    77                          the intermediate computations; the procedures uses
     76                         field extensions of Q might be necessary throughout
     77                         the intermediate computations; the procedures use
    7878                         the external program gfan
    7979@*  - drawTropicalCurve  visualises a tropical plane curve either given by a
     
    218218           e.g. ring r=0,(t,x(1..n)),dp;
    219219@*       - the first variable of the basering will be treated as the
    220            parameter t in the Puiseux series field !!!!
     220           parameter t in the Puiseux series field
    221221@*       - the optional parameter opt should be one or more strings among
    222222           the following:
     
    230230                                  ideal over (w_1/w_0,...,w_n/w_0)
    231231@*         'noAbs'              : do NOT use absolute primary decomposition
    232 @*         'noResubst'         : avoids computing the resubstitution
     232@*         'noResubst'         : avoids the computation of the resubstitution
    233233RETURN:  IF THE OPTION 'findAll' WAS NOT SET THEN:
    234234@*       list, containing one lifting of the given point (w_1/w_0,...,w_n/w_0)
    235235               in the tropical variety of i to a point in V(i) over Puiseux
    236236               series field up to the first ord terms; more precisely:
    237 @*             IF THE OPTION 'noAbs' WAS NOT SET THEN:
     237@*             IF THE OPTION 'noAbs' WAS NOT SET, THEN:
    238238@*             l[1] = ring Q[a]/m[[t]]
    239239@*             l[2] = int
    240240@*             l[3] = intvec
    241241@*             l[4] = list
    242 @*             IF THE OPTION 'noAbs' WAS SET THEN:
     242@*             IF THE OPTION 'noAbs' WAS SET, THEN:
    243243@*             l[1] = ring Q[X(1),...,X(k)]/m[[t]]
    244244@*             l[2] = int
     
    246246@*             l[4] = list
    247247@*             l[5] = string
    248 @*       IF THE OPITON 'findAll' WAS NOT SET THEN:
     248@*       IF THE OPITON 'findAll' WAS SET, THEN:
    249249@*       list, containing ALL liftings of the given point ((w_1/w_0,...,w_n/w_0)
    250250               in the tropical variety of i to a point in V(i) over Puiseux
     
    252252               zero-dimensional over Q{{t}};
    253253               more precisely, each entry of the list is a list l as computed
    254                if  'find_all' was NOT set
     254               if  'findAll' was NOT set
    255255@*       WE NOW DESCRIBE THE LIST ENTRIES IF 'findAll' WAS NOT SET:
    256256@*       - the ring l[1] contains an ideal LIFT, which contains
     
    278278           in Q{{t}}[x_1,...,x_n] then ALL points in V(i) lying over w are
    279279           computed up to order ord; if the ideal is not-zero dimenisonal, then
    280            only all points in the ideal after cutting down to dimension zero
     280           only the points in the ideal after cutting down to dimension zero
    281281           will be computed
    282 @*       - the procedure REQUIRES that the program GFAN is installed on your
    283            computer; if you have GFAN version less than 0.3.0 then you MUST
     282@*       - the procedure requires that the program GFAN is installed on your
     283           computer; if you have GFAN version less than 0.3.0 then you must
    284284           use the optional parameter 'oldGfan'
    285285@*       - the procedure requires the Singular procedure absPrimdecGTZ to be
     
    288288           the option 'noAbs' in order to avoid the costly absolute primary
    289289           decomposition; the side effect is that the field extension which is
    290            computed throughout the recursion might need more only one
     290           computed throughout the recursion might need more than one
    291291           parameter to be described
    292292@*       - since Q is infinite, the procedure finishes with probability one
     
    304304             decomposition in Singular only works in characteristic zero
    305305@*       - the basefield should either be Q or Z/pZ for some prime p;
    306            field extensions will be computed where necessary; if you need
     306           field extensions will be computed if necessary; if you need
    307307           parameters or field extensions from the beginning they should
    308308           rather be simulated as variables possibly adding their relations to
     
    13161316             variables and up to one parameter!
    13171317RETURN:      NONE
    1318 NOTE:        - the procedure produces the files /tmp/tropicalcurveNUMBER.tex and
     1318NOTE:        - the procedure creates the files /tmp/tropicalcurveNUMBER.tex and
    13191319               /tmp/tropicalcurveNUMBER.ps, where NUMBER is a random four
    13201320               digit integer;
     
    14801480          and up to one parameter!
    14811481RETURN:   NONE
    1482 NOTE:     - the procedure produces the files /tmp/newtonsubdivisionNUMBER.tex,
     1482NOTE:     - the procedure creates the files /tmp/newtonsubdivisionNUMBER.tex,
    14831483            and /tmp/newtonsubdivisionNUMBER.ps, where NUMBER is a random
    14841484            four digit integer;
     
    22422242/////////////////////////////////////////////////////////////////////////
    22432243
    2244 proc tInitialIdeal (ideal i,intvec w,list #) 
     2244proc tInitialIdeal (ideal i,intvec w,list #)
    22452245"USAGE:      tInitialIdeal(i,w); i ideal, w intvec
    22462246ASSUME:      i is an ideal in Q[t,x_1,...,x_n] and w=(w_0,...,w_n)
     
    23202320"USAGE:      initialForm(f,w); f a polynomial, w an integer vector
    23212321ASSUME:      f is a polynomial in Q[x_1,...,x_n] and w=(w_1,...,w_n)
    2322 RETURN:      poly, the initialForm of f(x) w.r.t. w
    2323 NOTE:        the initialForm are the terms with MAXIMAL weighted order w.r.t. w
     2322RETURN:      poly, the initial form of f(x) w.r.t. w
     2323NOTE:        the initialForm consists of the terms with MAXIMAL weighted order w.r.t. w
    23242324EXAMPLE:     example initialForm;   shows an example"
    23252325{
     
    23542354ASSUME:      i is an ideal in Q[x_1,...,x_n] and w=(w_1,...,w_n)
    23552355RETURN:      ideal, the initialIdeal of i w.r.t. w
    2356 NOTE:        the initialform are the terms with MAXIMAL weighted order w.r.t. w
     2356NOTE:        the initialIdeal consists of the terms with MAXIMAL weighted order w.r.t. w
    23572357EXAMPLE:     example initialIdeal;   shows an example"
    23582358{
     
    27552755"USAGE:      texDrawNewtonSubdivision(graph[,#]); graph list, # optional list
    27562756ASSUME:      graph is the output of tropicalCurve
    2757 RETURN:      string, the texdraw code of the Newton subdivision of the 
     2757RETURN:      string, the texdraw code of the Newton subdivision of the
    27582758                     tropical plane curve encoded by graph
    2759 NOTE:        - the list # should contain as only entry a string; if this string
    2760                is 'max', then the tropical curve is considered with respect 
    2761                to the maximum; otherwise the curve is considered with respect 
    2762                to the minimum and the string can be used to insert further 
     2759NOTE:        - the list # should contain only one entry which is a string; if this string
     2760               is 'max', then the tropical curve is considered with respect
     2761               to the maximum; otherwise the curve is considered with respect
     2762               to the minimum and the string can be used to insert further
    27632763               texdraw commands (e.g. to have a lighter image as when called
    2764                from inside conicWithTangents); the list # is optional and may 
     2764               from inside conicWithTangents); the list # is optional and may
    27652765               as well be empty
    2766 @*           - note that lattice points in the Newton subdivision which are 
    2767                black correspond to markings of the marked subdivision, 
     2766@*           - note that lattice points in the Newton subdivision which are
     2767               black correspond to markings of the marked subdivision,
    27682768               while lattice points in grey are not marked
    27692769EXAMPLE:     example texDrawNewtonSubdivision;   shows an example"
     
    27712771  int i,j,k,l;
    27722772  list boundary=graph[size(graph)][1];
    2773   list inneredges=graph[size(graph)][2]; 
     2773  list inneredges=graph[size(graph)][2];
    27742774  intvec shiftvector=graph[size(graph)][3];
    27752775  string subdivision;
     
    32433243ASSUME:   f is a polynomial in Q(t)[x_1,...,x_n] describing
    32443244          a plane curve over Q(t)
    3245 RETURN:   poly, f with t replaced by t^N
     3245RETURN:   poly f with t replaced by t^N
    32463246EXAMPLE:  example parameterSubstitute;   shows an example"
    32473247{
Note: See TracChangeset for help on using the changeset viewer.