Changeset f42f106 in git


Ignore:
Timestamp:
Jul 21, 1999, 11:55:35 AM (25 years ago)
Author:
Anne Frühbis-Krüger <anne@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
9139a2542fdbd4dd772ac6494d00af0985a1d7a4
Parents:
bb9d6dea650af33c4445435cce27a639c58d4a08
Message:
anne: changed help to mixed ASCII/DOC format to get better HTML output


git-svn-id: file:///usr/local/Singular/svn/trunk@3307 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/spcurve.lib

    rbb9d6d rf42f106  
    1 // $Id: spcurve.lib,v 1.6 1999-07-20 08:47:19 Singular Exp $
     1// $Id: spcurve.lib,v 1.7 1999-07-21 09:55:35 anne Exp $
    22// (anne, last modified 31.5.99)
    33/////////////////////////////////////////////////////////////////////////////
    44
    5 version="$Id: spcurve.lib,v 1.6 1999-07-20 08:47:19 Singular Exp $";
     5version="$Id: spcurve.lib,v 1.7 1999-07-21 09:55:35 anne Exp $";
    66info="
    7 LIBRARY: spcurve.lib    PROCEDURES FOR CM CODIMENSION 2 SINGULARITIES
    8 AUTHOR:  Anne Fruehbis-Krueger, anne@mathematik.uni-kl.de
     7LIBRARY:  spcurve.lib    PROCEDURES FOR CM CODIMENSION 2 SINGULARITIES
     8AUTHOR:   Anne Fruehbis-Krueger, anne@mathematik.uni-kl.de
    99last modified: 31.5.99
     10SEE ALSO: sing_lib, deform_lib
    1011
    1112PROCEDURES:
     
    3132
    3233proc isCMcod2(ideal kurve)
    33 "USAGE:   isCMcod2(i);   i an ideal
    34 RETURN:  presentation matrix of i, if i is Cohen-Macaulay of codimension2
    35          a zero matrix otherwise
    36 EXAMPLE: example isCMcod2; shows an example"
     34"USAGE:   @code{isCMcod2(i)};   @code{i} ideal
     35RETURN:  presentation matrix of @code{i}, if @code{i} is Cohen-Macaulay of codimension 2
     36         @* a zero matrix otherwise
     37EXAMPLE: @code{example isCMcod2}; shows an example
     38"
    3739{
    3840  int p = printlevel-voice+3;  // p=printlevel+1 (default: p=1)
     
    6264
    6365proc CMtype(ideal kurve)
    64 "USAGE:   CMtype(i);  i an ideal, CM of codimension 2
    65 RETURN:  Cohen-Macaulay type of i (integer)
    66          (-1, if i is not Cohen-Macaulay of codimension 2)
    67 EXAMPLE: example CMtype; shows an example"
     66"USAGE:   @code{CMtype(i)};  @code{i} ideal, CM of codimension 2
     67RETURN:  Cohen-Macaulay type of @code{i} (integer)
     68         @*(-1, if i is not Cohen-Macaulay of codimension 2)
     69EXAMPLE: @code{example CMtype}; shows an example
     70"
    6871{
    6972  int p = printlevel-voice+3;  // p=printlevel+1 (default: p=1)
     
    98101
    99102proc matrixT1(matrix M ,int n)
    100 "USAGE:   matrixT1(M,n);  M matrix, n integer
    101 ASSUME:  M is a presentation matrix of an ideal i, CM of codimension 2;
    102          consider i as a family of ideals in a ring in the first n
     103"USAGE:   @code{matrixT1(M,n)};  @code{M} matrix, @code{n} integer
     104ASSUME:  @code{M} is a presentation matrix of an ideal i, CM of codimension 2;
     105         @* consider i as a family of ideals in a ring in the first @code{n}
    103106         variables where the remaining variables are considered as
    104107         parameters
    105 RETURN:  list consisting of the k x (k+1) matrix M and a module K_M such that
    106          T1=Mat(k,k+1;R)/K_M is the space of first order deformations of i
    107 EXAMPLE: example matrixT1; shows an example"
     108RETURN:  list consisting of the k x (k+1) matrix @code{M} and a
     109         module @math{K_M} such that @math{T1=Mat(k,k+1;R)/K_M} is the space
     110         of first order deformations of i
     111EXAMPLE: @code{example matrixT1}; shows an example
     112"
    108113{
    109114  int p = printlevel-voice+3;  // p=printlevel+1 (default: p=1)
     
    190195
    191196proc semiCMcod2(matrix M, module t1)
    192 "USAGE:   semiCMcod2(M,t1); M matrix, t1 module
    193 ASSUME:  M is a presentation matrix of an ideal i, CM of codimension 2,
    194          and t1 is a presentation of the space of first order deformations
    195          of i ((M,t1) as returned by the procedure matrixT1)
     197"USAGE:   @code{semiCMcod2(M,t1)}; @code{M} matrix, @code{t1} module
     198ASSUME:  @code{M} is a presentation matrix of an ideal i, CM of codimension 2,
     199         and @code{t1} is a presentation of the space of first order
     200         deformations of i (@code{(M,t1)} as returned by the procedure
     201         @code{matrixT1})
    196202CREATE:  new basering with name rneu
    197203RETURN:  ideal in rneu describing the semiuniversal deformation of i
    198204NOTE:    The current basering should not contain any variables named
    199205         A(j) where j is some integer!
    200 EXAMPLE: example semiCMcod2; shows an example"
     206EXAMPLE: @code{example semiCMcod2}; shows an example
     207"
    201208{
    202209  int p = printlevel-voice+3;  // p=printlevel+1 (default: p=1)
     
    269276
    270277proc discr(ideal kurve, int n)
    271 "USAGE:   discr(sem,n);  sem ideal, n integer
    272 ASSUME:  sem is the versal deformation of an ideal of codimension 2
    273          the first n variables of the ring are treated as variables
     278"USAGE:   @code{discr(sem,n)};  @code{sem} ideal, @code{n} integer
     279ASSUME:  @code{sem} is the versal deformation of an ideal of codimension 2
     280         @*the first n variables of the ring are treated as variables
    274281         all the others as parameters
    275282RETURN:  ideal describing the discriminant
    276283NOTE:    This is not a powerful algorithm!
    277 EXAMPLE: example discr; shows an example"
     284EXAMPLE: @code{example discr}; shows an example
     285"
    278286{
    279287  int p = printlevel-voice+3;  // p=printlevel+1 (default: p=1)
     
    323331
    324332proc qhmatrix(matrix M)
    325 "USAGE:   qhmatrix(M);   M a k x (k+1) matrix
     333"USAGE:   @code{qhmatrix(M)};   @code{M} a k x (k+1) matrix
    326334RETURN:  list, consisting of an integer vector containing the weights of
    327335         the variables of the basering and an integer matrix giving the
    328          weights of the entries of M, if M is quasihomogeneous;
    329          zero integer vector and zero integer matrix, if M is not
     336         weights of the entries of @code{M}, if @code{M} is quasihomogeneous;
     337         @*zero integer vector and zero integer matrix, if @code{M} is not
    330338         quasihomogeneous, i.e. does not allow row and column weights
    331 EXAMPLE: example qhmatrix; shows an example"
     339EXAMPLE: @code{example qhmatrix}; shows an example
     340"
    332341{
    333342  int p = printlevel-voice+3;  // p=printlevel+1 (default: p=1)
     
    503512
    504513proc relweight(matrix N, intmat W, intvec a)
    505 "USAGE:   relweight(N,W,a); N matrix, W intmat, a intvec
    506 ASSUME:  N is a non-zero matrix
    507          W is an integer matrix of the same size as N
    508          a is an integer vector giving the weights of the variables
    509 RETURN:  integer, max(a-weighted order(N_ij) - W_ij | all entries ij)
    510          string \"ERROR\" if sizes do not match
    511 EXAMPLE: example relweight; shows an example"
     514"USAGE:   @code{relweight(N,W,a)}; @code{N} matrix, @code{W} intmat, @code{a} intvec
     515ASSUME:  @code{N} is a non-zero matrix
     516         @* @code{W} is an integer matrix of the same size as @code{N}
     517         @* @code{a} is an integer vector giving the weights of the variables
     518RETURN:  integer, @math{max(a-weighted order(N_ij) - W_ij | all entries ij)}
     519         @* string \"ERROR\" if sizes do not match
     520EXAMPLE: @code{example relweight}; shows an example
     521"
    512522{
    513523  int p = printlevel-voice+3;  // p=printlevel+1 (default: p=1)
     
    564574
    565575proc posweight(matrix M, module t1, int choose, list #)
    566 "USAGE:   posweight(M,t1,n[,s]); M matrix, t1 module, n int, s string
    567          n=0 : all deformations of non-negative weight
    568          n=1 : only non-constant deformations of non-negative weight
    569          n=2 : all deformations of positive weight
    570          As an optional parameter the name of a new ring may be
     576"USAGE:   @code{posweight(M,t1,n[,s])}; @code{M} matrix, @code{t1} module, @code{n} int, @code{s} string
     577         @*@code{n}=0 : all deformations of non-negative weight
     578         @*@code{n}=1 : only non-constant deformations of non-negative weight
     579         @*@code{n}=2 : all deformations of positive weight
     580         @*As an optional parameter the name of a new ring may be
    571581         specified.
    572 ASSUME:  M is a presentation matrix of a Cohen-Macaulay codimension 2
    573          ideal and t1 is its T1 space in matrix notation
     582ASSUME:  @code{M} is a presentation matrix of a Cohen-Macaulay codimension 2
     583         ideal and @code{t1} is a presentation of its T1 space in matrix
     584         notation
    574585CREATE:  new basering (default name: rneu); a different name for this ring
    575586         may be given as a 4th parameter
     
    579590NOTE:   The current basering should not contain any variables named
    580591         T(i) where i is some integer!
    581 EXAMPLE: example posweight; shows an example"
     592EXAMPLE: @code{example posweight}; shows an example
     593"
    582594{
    583595//---------------------------------------------------------------------------
     
    725737
    726738proc KSpencerKernel(matrix M,list #)
    727 "USAGE:     KSpencerKernel(M[,s][,v]);  M matrix, s string, v intvec
    728            optional parameters (please specify in this order, if both are
     739"USAGE:     @code{KSpencerKernel(M[,s][,v])};  @code{M} matrix, @code{s} string, @code{v} intvec
     740           @*optional parameters (please specify in this order, if both are
    729741           present):
    730            *  s = first of the names of the new rings
    731               e.g. \"R\" leads to ring names R and R1
    732            *  v of size n(n+1) leads to the following module ordering
    733               gen(v[1]) > gen(v[2]) > ... > gen(v[n(n+1)])
    734               where the matrix entry ij corresponds to gen((i-1)*n+j)
    735 ASSUME:    M is a quasihomogeneous n x (n+1) matrix where the n minors define
    736            an isolated space curve singularity
     742           @* *  @code{s} = first of the names of the new rings
     743           @*   e.g. \"R\" leads to ring names R and R1
     744           @* *  @code{v} of size n(n+1) leads to the following module ordering
     745           @*   @code{gen(v[1]) > gen(v[2]) > ... > gen(v[n(n+1)])}
     746           @*   where the matrix entry ij corresponds to @code{gen((i-1)*n+j)}
     747ASSUME:    @code{M} is a quasihomogeneous n x (n+1) matrix where the n minors
     748           define an isolated space curve singularity
    737749CREATE:    2 new rings (default names: rneu and reneu)
    738750           different ring names may be specified as a 2nd parameter
     
    745757           * setting an intvec with 5 entries and name watchProgress
    746758             shows the progress of the computations:
    747              watchProgress[1]>0  => option(prot) in groebner commands
    748              watchProgress[2]>0  => trace output for highcorner
    749              watchProgress[3]>0  => output of deformed matrix
    750              watchProgress[4]>0  => result of elimination step
    751              watchProgress[4]>1  => trace output of multiplications with xyz
    752                                     and subsequent reductions
    753              watchProgress[5]>0  => matrix representing the kernel
    754                                     using print
    755 EXAMPLE:   example KSpencerKernel; shows an example"
     759           @*  watchProgress[1]>0  => option(prot) in groebner commands
     760           @*  watchProgress[2]>0  => trace output for highcorner
     761           @*  watchProgress[3]>0  => output of deformed matrix
     762           @*  watchProgress[4]>0  => result of elimination step
     763           @*  watchProgress[4]>1  => trace output of multiplications with xyz
     764           @*                         and subsequent reductions
     765           @*  watchProgress[5]>0  => matrix representing the kernel
     766           @*                         using print
     767EXAMPLE:   @code{example KSpencerKernel}; shows an example
     768"
    756769{
    757770  int p = printlevel-voice+3;  // p=printlevel+1 (default: p=1)
     
    912925  if (defined(newname)>1)
    913926  {
    914     list li=posweight(M,mo,0,newname+"1");
     927    list li=posweight(M,mo,2,newname+"1");
    915928    def rneu=basering;
    916929  }
    917930  else
    918931  {
    919     list li=posweight(M,mo,0);
     932    list li=posweight(M,mo,2);
    920933  }
    921934  if (size(li)<=1)
     
    11011114
    11021115proc mod2id(matrix M,intvec vpos)
    1103 "USAGE:     mod2id(M,vpos); M matrix, vpos intvec
    1104 ASSUME:    vpos is an integer vector such that gen(i) corresponds
    1105            to var(vpos[i])
    1106            the basering contains variables var(vpos[i]) which do not occur
    1107            in M
     1116"USAGE:     @code{mod2id(M,vpos)}; @code{M} matrix, @code{vpos} intvec
     1117ASSUME:    @code{vpos} is an integer vector such that @code{gen(i)} corresponds
     1118           to @code{var(vpos[i])}
     1119           @*the basering contains variables @code{var(vpos[i])} which do not
     1120           occur in @code{M}
    11081121NOTE:      this procedure should be used in the following situation:
    11091122           one wants to pass to a ring with new variables, say e(1),..,e(s),
    11101123           which correspond to the components gen(1),..,gen(s) of the
    1111            module M such that e(i)*e(j)=0 for all i,j
     1124           module @code{M} such that e(i)*e(j)=0 for all i,j
    11121125           the new ring should already exist and be the current ring
    1113 RETURN:    ideal i in which each gen(i) from the module is replaced by
    1114            var(vpos[i]) and all monomials var(vpos[i])*var(vpos[j]) have
    1115            been added to the generating set of i
    1116 EXAMPLE:   example mod2id; shows an example"
     1126RETURN:    ideal i in which each gen(i) from the module is replaced by
     1127           @code{var(vpos[i])} and all monomials @code{var(vpos[i])*var(vpos[j])}
     1128           have been added to the generating set of i
     1129EXAMPLE:   @code{example mod2id}; shows an example
     1130"
    11171131{
    11181132  int p = printlevel-voice+3;  // p=printlevel+1 (default: p=1)
     
    11501164
    11511165proc id2mod(ideal i,intvec vpos)
    1152 "USAGE:     id2mod(I,vpos); I ideal, vpos intvec
     1166"USAGE:     @code{id2mod(I,vpos)}; @code{I} ideal, @code{vpos} intvec
    11531167NOTE:      * use this procedure only makes sense if the ideal contains
    1154              all var(vpos[i])*var(vpos[j]) as monomial generators and
     1168             all @code{var(vpos[i])*var(vpos[j])} as monomial generators and
    11551169             all other generators are linear combinations of the
    1156              var(vpos[i]) over the ring in the other variables
    1157            * this is the inverse procedure to mod2id and should be applied
    1158              only to ideals created by mod2id using the same intvec vpos
    1159              (possibly after a standard basis computation)
    1160 RETURN:    module corresponding to the ideal by replacing var(vpos[i]) by
    1161            gen(i) and omitting all generators var(vpos[i])*var(vpos[j])
    1162 EXAMPLE:   example id2mod; shows an example"
     1170             @code{var(vpos[i])} over the ring in the other variables
     1171           @* * this is the inverse procedure to @code{mod2id} and should be
     1172             applied only to ideals created by @code{mod2id} using the same
     1173             intvec @code{vpos} (possibly after a standard basis computation)
     1174RETURN:    module corresponding to the ideal by replacing @code{var(vpos[i])} by
     1175           gen(i) and omitting all generators @code{var(vpos[i])*var(vpos[j])}
     1176EXAMPLE:   @code{example id2mod}; shows an example"
    11631177{
    11641178  int p = printlevel-voice+3;  // p=printlevel+1 (default: p=1)
     
    11951209
    11961210proc subrInterred(ideal mon, ideal sm, intvec iv)
    1197 "USAGE:    subrInterred(mon,sm,iv);
    1198           sm:   ideal in a ring r with n + s variables,
     1211"USAGE:    @code{subrInterred(mon,sm,iv)};
     1212          @*@code{sm}:   ideal in a ring r with n + s variables,
    11991213                e.g. x_1,..,x_n and t_1,..,t_s
    1200           mon:  ideal with monomial generators (not divisible by
     1214          @*@code{mon}:  ideal with monomial generators (not divisible by
    12011215                one of the t_i) such that sm is contained in the module
    1202                 k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)]
    1203           iv:   intvec listing the variables which are supposed to be used
    1204                 as x_i
     1216                @code{k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)]}
     1217          @*@code{iv}:   intvec listing the variables which are supposed to be
     1218                used as x_i
    12051219RETURN:   interreduced system of generators of sm seen as a submodule
    1206           of k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)]
    1207 EXAMPLE:  example subrInterred; shows an example"
     1220          of @code{k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)]}
     1221EXAMPLE:  @code{example subrInterred}; shows an example
     1222"
    12081223{
    12091224  int p = printlevel-voice+3;  // p=printlevel+1 (default: p=1)
Note: See TracChangeset for help on using the changeset viewer.