Changeset 0b59f5 in git


Ignore:
Timestamp:
Dec 13, 1999, 4:33:50 PM (23 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
82ed244cff3158b7a79a6eed4e0548d485960cfe
Parents:
925cab8e04ecb2f3c2e451b913c11bcac28b2374
Message:
* GMG's changes


git-svn-id: file:///usr/local/Singular/svn/trunk@4006 2c84dea3-7e68-4137-9b89-c4e89433aadc
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/classify.lib

    r925cab r0b59f5  
    1 e// $Id: classify.lib,v 1.39 1999-12-09 12:41:44 obachman Exp $
     1e// $Id: classify.lib,v 1.40 1999-12-13 15:33:44 obachman Exp $
    22// KK, last modified: 04.04.1998
    33///////////////////////////////////////////////////////////////////////////////
    44
    5 version  = "$Id: classify.lib,v 1.39 1999-12-09 12:41:44 obachman Exp $";
     5version  = "$Id: classify.lib,v 1.40 1999-12-13 15:33:44 obachman Exp $";
    66info="
    7 LIBRARY:  classify.lib  PROCEDURES FOR THE ARNOLD-CLASSIFIER OF SINGULARITIES
     7LIBRARY:  classify.lib  Procedures for the Arnold-Classifier of Singularities
    88
    99OVERVIEW:

  • Singular/LIB/deform.lib

    r925cab r0b59f5  
    1 // $Id: deform.lib,v 1.18 1999-08-19 15:19:52 obachman Exp $
     1// $Id: deform.lib,v 1.19 1999-12-13 15:33:45 obachman Exp $
    22// author: Bernd Martin email: martin@math.tu-cottbus.de
    33//(bm, last modified 4/98)
    44///////////////////////////////////////////////////////////////////////////////
    5 version="$Id: deform.lib,v 1.18 1999-08-19 15:19:52 obachman Exp $";
     5version="$Id: deform.lib,v 1.19 1999-12-13 15:33:45 obachman Exp $";
    66info="
    77LIBRARY:  deform.lib       PROCEDURES FOR COMPUTING MINIVERSAL DEFORMATION
    … …  
    8484setring  Po;
    8585  poly   X_s  = product(maxideal(1));
    86 //-------  reproduce T12 ------------------------------------------------------
    87   list   Ls   = T12(Fo,1);
     86//-------  reproduce T_12 -----------------------------------------------------
     87  list   Ls   = T_12(Fo,1);
    8888  matrix Ro   = Ls[6];                         // syz(i)
    8989  matrix InfD = Ls[5];                         // matrix of inf. deformations
    9090  matrix PreO = Ls[7];                         // representation of (Syz/Kos)*
    9191  module PreO'= std(PreO);
    92   module PreT = Ls[2];                         // representation of modT2 (sb)
     92  module PreT = Ls[2];                         // representation of modT_2 (sb)
    9393  if(dim(PreT)==0)
    9494  {
    95     matrix kbT2 = kbase(PreT);                 // kbase of T2
     95    matrix kbT_2 = kbase(PreT);                 // kbase of T_2
    9696  }
    9797  else
    9898  {
    99     matrix kbT2 ;                              // kbase of T2 : empty
    100   }
    101   @t1 = Ls[3];                                 // vdim of T1
    102   @t2 = Ls[4];                                 // vdim of T2
     99    matrix kbT_2 ;                              // kbase of T_2 : empty
     100  }
     101  @t1 = Ls[3];                                 // vdim of T_1
     102  @t2 = Ls[4];                                 // vdim of T_2
    103103  kill Ls;
    104104  t1' = @t1;
    105105  if( @t1==0) { dbprint(p,"// rigit!"); return();}
    106106  if( @t2==0) { @smooth=1; dbprint(p,"// smooth base space");}
    107   dbprint(p,"// ready: T1 and T2");
     107  dbprint(p,"// ready: T_1 and T_2");
    108108  @colR = ncols(Ro);
    109109//-----  test: quasi-homogeneous, choice of inf. def.--------------------------
    … …  
    111111  @jv = 1..@t1;
    112112  if (@degrees!="")
    113   { dbprint(p-1,"// T1 is quasi-homogeneous represented with weight-vector",
     113  { dbprint(p-1,"// T_1 is quasi-homogeneous represented with weight-vector",
    114114    @degrees);
    115115  }
    … …  
    160160  module PreO'= imap(Po,PreO');  attrib(PreO',"isSB",1);
    161161  module PreT = imap(Po,PreT);   attrib(PreT,"isSB",1);
    162   matrix kbT2 = imap(Po,kbT2);
     162  matrix kbT_2 = imap(Po,kbT_2);
    163163  matrix Mon  = fetch(`myPx`,Mon);
    164164  matrix F_R  = fetch(`myPx`,F_R);
    … …  
    178178       Cup = jet(Cup,@d,@jv);
    179179     }
    180 //------- express obstructions in kbase of T2  --------------------------------
     180//------- express obstructions in kbase of T_2  --------------------------------
    181181     if ( @noObstr==0 )
    182182     {  Cup' = reduce(Cup,PreO');
    … …  
    187187        }
    188188        Cup   = lift(PreO,Cup);
    189         MASS  = lift_rel_kb(Cup,PreT,kbT2,X_s);
     189        MASS  = lift_rel_kb(Cup,PreT,kbT_2,X_s);
    190190        dbprint(p-3,"// next MASSEY-products:",MASS-jet(MASS,@d-1,@jv));
    191191        if    (MASS==transpose(Js))

  • Singular/LIB/general.lib

    r925cab r0b59f5  
    1 // $Id: general.lib,v 1.22 1999-10-22 09:07:07 obachman Exp $
     1// $Id: general.lib,v 1.23 1999-12-13 15:33:46 obachman Exp $
    22//GMG, last modified 18.6.99
    33///////////////////////////////////////////////////////////////////////////////
    44
    5 version="$Id: general.lib,v 1.22 1999-10-22 09:07:07 obachman Exp $";
     5version="$Id: general.lib,v 1.23 1999-12-13 15:33:46 obachman Exp $";
    66info="
    77LIBRARY:  general.lib   PROCEDURES OF GENERAL TYPE
    88
    99PROCEDURES:
    10  A_Z(\"a\",n);          string a,b,... of n comma seperated letters
     10 A_Z(\"a\",n);          string a,b,... of n comma separated letters
    1111 ASCII([n,m]);          string of printable ASCII characters (number n to m)
    1212 binomial(n,m[,../..]); n choose m (type int), [type string/type number]
    … …  
    3232"USAGE:   A_Z(\"a\",n);  a any letter, n integer (-26<= n <=26, !=0)
    3333RETURN:  string of n small (if a is small) or capital (if a is capital)
    34          letters, comma seperated, beginning with a, in alphabetical
     34         letters, comma separated, beginning with a, in alphabetical
    3535         order (or revers alphabetical order if n<0)
    3636EXAMPLE: example A_Z; shows an example
    … …  
    9595{
    9696  string s1 =
    97  "     !    \"    #    $       &    '    (    )    *    +    ,    -    .
     97 "     !    \"    #    $     &    '    (    )    *    +    ,    -    .
    989832   33   34   35   36   37   38   39   40   41   42   43   44   45   46
    9999/    0    1    2    3    4    5    6    7    8    9    :    ;    <    =
    … …  
    137137"USAGE:   binomial(n,k[,p]); n,k,p integers
    138138RETURN:  binomial(n,k); binomial coefficient n choose k,
    139          - of type string (computed in characteristic 0)
     139@*         - of type string (computed in characteristic 0)
    140140         binomial(n,k,p); n choose k, computed in characteristic prime(p)
    141          - of type number if a basering is present and prime(p)=char(basering)
    142          - of type string else
     141@*         - of type number if a basering is present and prime(p)=char(basering)
     142@*         - of type string else
    143143NOTE:    In any characteristic, binomial(n,k) = coefficient of x^k in (1+x)^n
    144144EXAMPLE: example binomial; shows an example

  • Singular/LIB/graphics.lib

    r925cab r0b59f5  
    1 // $Id: graphics.lib,v 1.5 1999-09-21 12:29:29 obachman Exp $
     1// $Id: graphics.lib,v 1.6 1999-12-13 15:33:46 obachman Exp $
    22//
    33// author : Christian Gorzel email: gorzelc@math.uni-muenster.de
    44//
    55///////////////////////////////////////////////////////////////////////////////
    6 version="$Id: graphics.lib,v 1.5 1999-09-21 12:29:29 obachman Exp $";
     6version="$Id: graphics.lib,v 1.6 1999-12-13 15:33:46 obachman Exp $";
    77info="
    88LIBRARY: graphics.lib    PROCEDURES FOR GRAPHICS WITH MATHEMATICA
    99
     10AUTHOR:   Christian Gorzel, gorzelc@math.uni-muenster.de
    1011PROCEDURES:
    1112 staircase(fname,I);  Mathematica text for displaying staircase of I

  • Singular/LIB/hnoether.lib

    r925cab r0b59f5  
    1 // $Id: hnoether.lib,v 1.17 1999-08-31 14:58:38 lamm Exp $
     1// $Id: hnoether.lib,v 1.18 1999-12-13 15:33:46 obachman Exp $
    22// last change:           31.08.99
    33///////////////////////////////////////////////////////////////////////////////
    44// This library is for Singular 1-3-4 or newer
    55
    6 version="$Id: hnoether.lib,v 1.17 1999-08-31 14:58:38 lamm Exp $";
     6version="$Id: hnoether.lib,v 1.18 1999-12-13 15:33:46 obachman Exp $";
    77info="
    8 LIBRARY:  hnoether.lib   PROCEDURES FOR THE HAMBURGER-NOETHER DEVELOPMENT
     8LIBRARY:  hnoether.lib   Procedures for the Hamburger-Noether (Puiseux) development
    99
    1010AUTHOR:   Martin Lamm,   lamm@mathematik.uni-kl.de
    11 KEYWORDS: Hamburger-Noether expansion; curve singularities
    12 
     11
     12OVERVIEW:
     13           A library for computing the Hamburger-Noether resp. Puiseux
     14           development of a plane curve singularity following A. Campillo:
     15           Algebroid curves in positive characteristic, Lecture Notes in Math.
     16           813, Springer (1980).
     17           The library contains also procedures for computing the (topoligical)
     18           numerical invariants of plane curve singularities.
     19 
    1320MAIN PROCEDURES:
    1421 HNdevelop(f);       Hamburger-Noether development of f
    … …  
    3340 allsquarefree(f,l); returns the maximal squarefree divisor of the poly f
    3441 further_hn_proc();  show further procedures useful for interactive use
     42
     43KEYWORDS: Hamburger-Noether expansion; curve singularities
    3544";
    3645///////////////////////////////////////////////////////////////////////////////

  • Singular/LIB/homolog.lib

    r925cab r0b59f5  
    1 // $Id: homolog.lib,v 1.9 1999-08-03 11:43:06 obachman Exp $
     1// $Id: homolog.lib,v 1.10 1999-12-13 15:33:47 obachman Exp $
    22//(BM/GMG)
    33///////////////////////////////////////////////////////////////////////////////
    44
    5 version="$Id: homolog.lib,v 1.9 1999-08-03 11:43:06 obachman Exp $";
     5version="$Id: homolog.lib,v 1.10 1999-12-13 15:33:47 obachman Exp $";
    66info="
    77LIBRARY:  homolog.lib   PROCEDURES FOR HOMOLOGICAL ALGEBRA
    … …  
    554554         0<--M'<-- F0 <-M-- F1 <-- F2 <--...  resp. 0<--N'<-- G0 <--N- G1 be
    555555         a free resolution of M' resp. a presentations of N'. Consider
     556@format
    556557                      0                  0                  0
    557558                      |^                 |^                 |^
    … …  
    562563                                         |C                 |B
    563564                                      Hom(Fk,G1) -----> Hom(Fk+1,G1)
     565@end format
    564566         (Ak,Ak+1 induced by M and B,C induced by N).
    565567         Let K=modulo(Ak+1,B), J=module(Ak)+module(C) and Ext=modulo(K,J),
    … …  
    568570         R^q -Ext-> R^p --K->Hom(Fk,G0)/im(Ak)+im(C) --Ak+1->Hom(Fk+1,G0)/im(B)
    569571         Hence Ext presents Ext^k(M',N')
    570 RETURN:  Ext, of type module, a presentation of Ext^k(M',N') if v is of type
     572RETURN: 
     573         Ext, of type module, a presentation of Ext^k(M',N') if v is of type
    571574         int, resp. a list of Ext^k (k=v[1],v[2],...) if v is of type intvec.
    572575         In case of a third argument of any type return a list:
    … …  
    715718         Let ...-->F1 --M-> F0-->M'-->0 and ...-->G1 --N-> G0-->N'-->0  be
    716719         presentations of M' and N'. Consider
     720@format
    717721                                         0               0
    718722                                         |^              |^
    … …  
    728732              R^q -Hom-> R^p --D-> Hom(F0,G0)/im(C) --A-> Hom(F1,G0)/im(B).
    729733         Hence Hom presents Hom(M',N')
     734@end format
    730735RETURN:  Hom, of type module, presentation of Hom(M',N') or,
    731736         in case of 3 arguments, a list:
    … …  
    845850         (R=basering) and let A:R^m-->R^n a matrix inducing a map A':M'-->N'.
    846851         Compute a presentation K of ker(A') as in the commutative diagram:
     852@format
    847853                       ker(A') --->  M' --A'--> N'
    848854                           |^        |^         |^
    … …  
    853859                           |         |          |
    854860                          R^s  ---> R^p -----> R^q
     861@end format
    855862RETURN:  module K, a presentation of ker(A')
    856863EXAMPLE: example kernel; shows examples

  • Singular/LIB/linalg.lib

    r925cab r0b59f5  
    33//////////////////////////////////////////////////////////////////////////////
    44
    5 version="$Id: linalg.lib,v 1.3 1999-10-25 12:45:16 obachman Exp $";
     5version="$Id: linalg.lib,v 1.4 1999-12-13 15:33:48 obachman Exp $";
    66info="
    77LIBRARY:  linalg.lib    PROCEDURES FOR ALGORITHMIC LINEAR ALGEBRA
    … …  
    2121 gaussred(A);       gaussian reduction: P*A=U*S, S is a row reduced form of A
    2222 gaussred_pivot(A); gaussian reduction: P*A=U*S, S is a row reduced form of A
    23  gnf(A);            gauss normal form of A
    24  rk(A);             rank of A
    25  UDO(A);            P*A=U*D*O 
     23 gauss_nf(A);            gauss normal form of A
     24 mat_rk(A);             rank of A
     25 U_D_O(A);            P*A=U*D*O 
    2626 pos_def(A,i);      test of positive symmetric matrizes.       
    2727";
    … …  
    824824
    825825//////////////////////////////////////////////////////////////////////////////
    826 proc gnf(matrix A)
    827 "USAGE:    gnf(A); any constant matrix A
     826proc gauss_nf(matrix A)
     827"USAGE:    gauss_nf(A); any constant matrix A
    828828RETURN:   matrix; gauss normal form of A
    829 EXAMPLE:  example gnf; shows an example"
     829EXAMPLE:  example gauss_nf; shows an example"
    830830{
    831831  list Z;
    … …  
    841841ring r=7,(x),dp;
    842842matrix A[4][4]= 1,4,4,7,2,5,5,4,4,1,1,3,0,2,2,7;
    843 print(gnf(A));
    844 }
    845 
    846 //////////////////////////////////////////////////////////////////////////////
    847 proc rk(matrix A)
    848 "USAGE:    rk(A); any constant matrix A
     843print(gauss_nf(A));
     844}
     845
     846//////////////////////////////////////////////////////////////////////////////
     847proc mat_rk(matrix A)
     848"USAGE:    mat_rk(A); any constant matrix A
    849849RETURN:   int; rank of A
    850 EXAMPLE:  example rk; shows an example"
     850EXAMPLE:  example mat_rk; shows an example"
    851851{
    852852  list Z;
    … …  
    862862ring r=7,(x),dp;
    863863matrix A[4][4]= 1,4,4,7,2,5,5,4,4,1,1,3,0,2,2,7;
    864 rk(A);
    865 }
    866 
    867 //////////////////////////////////////////////////////////////////////////////
    868 proc UDO(matrix A)
     864mat_rk(A);
     865}
     866
     867//////////////////////////////////////////////////////////////////////////////
     868proc U_D_O(matrix A)
    869869"USAGE:     gaussred(A);   constant invertible matrix A
    870870RETURN:    list Z:  Z[1]=P , Z[2]=U , Z[3]=D , Z[4]=O
    … …  
    922922               -10,10,-9,5,-1,-6,5;
    923923print(A);
    924 list Z=UDO(A);
     924list Z=U_D_O(A);
    925925"P=";print(Z[1]);
    926926"U=";print(Z[2]);
    … …  
    956956  }
    957957 
    958   Z=UDO(A);
     958  Z=U_D_O(A);
    959959
    960960  if(Z[1]==-1){return(0);} //A not regular , therefor not pos.definit
    … …  
    10231023  }
    10241024 
    1025   r=rk(A);
     1025  r=mat_rk(A);
    10261026       
    10271027  //1. b constant vector

  • Singular/LIB/mondromy.lib

    r925cab r0b59f5  
    11///////////////////////////////////////////////////////////////////////////////
    22
    3 version="$Id: mondromy.lib,v 1.10 1999-11-12 11:21:02 mschulze Exp $";
     3version="$Id: mondromy.lib,v 1.11 1999-12-13 15:33:48 obachman Exp $";
    44info="
    55LIBRARY:  mondromy.lib  PROCEDURES TO COMPUTE THE MONODROMY OF A SINGULARITY
    … …  
    1818 jacoblift(f);         lifts f^kappa in jacob(f) with minimal kappa
    1919 monodromy(f[,opt]);   monodromy of isolated hypersurface singularity f
    20  H''basis(f);          basis of Brieskorn lattice H''
     20 H2basis(f);           basis of Brieskorn lattice H''
    2121";
    2222
    … …  
    916916///////////////////////////////////////////////////////////////////////////////
    917917
    918 proc H''basis(poly f)
    919 "USAGE:   H''basis(f); f poly
     918proc H2basis(poly f)
     919"USAGE:   H2basis(f); f poly
    920920ASSUME:  The polynomial f in a series ring (local ordering) defines
    921921         an isolated hypersurface singularity.
    … …  
    924924THEORY:  H'' is a free C{f}-module of rank milnor(f).
    925925DISPLAY: The procedure displays more comments for higher printlevel.
    926 EXAMPLE: example H''basis; shows an example.
     926EXAMPLE: example H2basis; shows an example.
    927927"
    928928{
    … …  
    10191019  ring R=0,(x,y),ds;
    10201020  poly f=x2y2+x6+y6;
    1021   H''basis(f);
    1022 }
    1023 ///////////////////////////////////////////////////////////////////////////////
     1021  H2basis(f);
     1022}
     1023///////////////////////////////////////////////////////////////////////////////

  • Singular/LIB/poly.lib

    r925cab r0b59f5  
    1 // $Id: poly.lib,v 1.18 1999-09-21 17:32:17 Singular Exp $
     1// $Id: poly.lib,v 1.19 1999-12-13 15:33:48 obachman Exp $
    22//(GMG, last modified 22.06.96)
    33//(obachman: 17.12.97 -- added katsura)
    44///////////////////////////////////////////////////////////////////////////////
    55
    6 version="$Id: poly.lib,v 1.18 1999-09-21 17:32:17 Singular Exp $";
     6version="$Id: poly.lib,v 1.19 1999-12-13 15:33:48 obachman Exp $";
    77info="
    88LIBRARY:  poly.lib      PROCEDURES FOR MANIPULATING POLYS, IDEALS, MODULES
    … …  
    114114{
    115115  "EXAMPLE:"; echo = 2;
    116   ring r;
     116  ring r; basering;
    117117  katsura();
    118   katsura(3);
     118  katsura(4); basering;
    119119}
    120120

  • Singular/LIB/primdec.lib

    r925cab r0b59f5  
    1 // $Id: primdec.lib,v 1.51 1999-11-30 10:09:41 pfister Exp $
     1// $Id: primdec.lib,v 1.52 1999-12-13 15:33:49 obachman Exp $
    22///////////////////////////////////////////////////////////////////////////////
    33// primdec.lib                                                               //
    … …  
    1111///////////////////////////////////////////////////////////////////////////////
    1212
    13 version="$Id: primdec.lib,v 1.51 1999-11-30 10:09:41 pfister Exp $";
     13version="$Id: primdec.lib,v 1.52 1999-12-13 15:33:49 obachman Exp $";
    1414info="
    15 LIBRARY: primdec.lib:   PROCEDURES FOR PRIMARY DECOMPOSITION
     15LIBRARY: primdec.lib   PROCEDURES FOR PRIMARY DECOMPOSITION
    1616AUTHORS:  Gerhard Pfister, email: pfister@mathematik.uni-kl.de (GTZ)
    1717          Wolfram Decker, email: decker@math.uni-sb.de         (SY)

  • Singular/LIB/random.lib

    r925cab r0b59f5  
    1 // $Id: random.lib,v 1.10 1999-09-21 17:32:18 Singular Exp $
     1// $Id: random.lib,v 1.11 1999-12-13 15:33:49 obachman Exp $
    22//(GMG/BM, last modified 22.06.96)
    33///////////////////////////////////////////////////////////////////////////////
    44
    5 version="$Id: random.lib,v 1.10 1999-09-21 17:32:18 Singular Exp $";
     5version="$Id: random.lib,v 1.11 1999-12-13 15:33:49 obachman Exp $";
    66info="
    77LIBRARY:  random.lib    PROCEDURES OF RANDOM MATRIX AND POLY OPERATIONS
    88
     9PROCEDURES:
    910 genericid(id[,p,b]);     generic sparse linear combinations of generators of id
    1011 randomid(id,[k,b]);      random linear combinations of generators of id

  • Singular/LIB/sing.lib

    r925cab r0b59f5  
    1 // $Id: sing.lib,v 1.18 1999-11-11 16:03:33 Singular Exp $
     1// $Id: sing.lib,v 1.19 1999-12-13 15:33:50 obachman Exp $
    22//(GMG/BM, last modified 26.06.96)
    33///////////////////////////////////////////////////////////////////////////////
    44
    5 version="$Id: sing.lib,v 1.18 1999-11-11 16:03:33 Singular Exp $";
     5version="$Id: sing.lib,v 1.19 1999-12-13 15:33:50 obachman Exp $";
    66info="
    77LIBRARY:  sing.lib      PROCEDURES FOR SINGULARITIES
    … …  
    2424 Tjurina(i);            SB of Tjurina module of ideal i (assume i is ICIS)
    2525 tjurina(i);            Tjurina number of ideal i (assume i is ICIS)
    26  T1(i);                 T1-module of ideal i
    27  T2((i);                T2-module of ideal i
    28  T12(i);                T1- and T2-module of ideal i
     26 T_1(i);                T^1-module of ideal i
     27 T_2((i);               T^2-module of ideal i
     28 T_12(i);               T^1- and T^2-module of ideal i
    2929";
    3030
    … …  
    3939"
    4040{
    41    list L=T1(id,"");
     41   list L=T_1(id,"");
    4242   def K=L[1]; attrib(K,"isSB",1);
    4343   return(L[2]*kbase(K));
    … …  
    499499///////////////////////////////////////////////////////////////////////////////
    500500
    501 proc T1 (ideal id, list #)
    502 "USAGE:   T1(id[,<any>]);  id = ideal or poly
    503 RETURN:  T1(id): of type module/ideal if id is of type ideal/poly.
    504          We call T1(id) the T1-module of id. It is a std basis of the
     501proc T_1 (ideal id, list #)
     502"USAGE:   T_1(id[,<any>]);  id = ideal or poly
     503RETURN:  T_1(id): of type module/ideal if id is of type ideal/poly.
     504         We call T_1(id) the T_1-module of id. It is a std basis of the
    505505         presentation of 1st order deformations of P/id, if P is the basering.
    506506         If a second argument is present (of any type) return a list of
    507507         3 modules:
    508             [1]= T1(id)
     508            [1]= T_1(id)
    509509            [2]= generators of normal bundle of id, lifted to P
    510510            [3]= module of relations of [2], lifted to P
    511511                 (note: transpose[3]*[2]=0 mod id)
    512512         The list contains all non-easy objects which must be computed
    513          to get T1(id).
    514 DISPLAY: k-dimension of T1(id) if printlevel >= 0 (default)
    515 NOTE:    T1(id) itself is usually of minor importance. Nevertheless, from it
     513         to get T_1(id).
     514DISPLAY: k-dimension of T_1(id) if printlevel >= 0 (default)
     515NOTE:    T_1(id) itself is usually of minor importance. Nevertheless, from it
    516516         all relevant information can be obtained. The most important are
    517          probably vdim(T1(id)); (which computes the Tjurina number),
    518          hilb(T1(id)); and kbase(T1(id));
    519          If T1 is called with two argument, then matrix([2])*(kbase([1]))
     517         probably vdim(T_1(id)); (which computes the Tjurina number),
     518         hilb(T_1(id)); and kbase(T_1(id));
     519         If T_1 is called with two argument, then matrix([2])*(kbase([1]))
    520520         represents a basis of 1st order semiuniversal deformation of id
    521521         (use proc 'deform', to get this in a direct way).
    522522         For a complete intersection the proc Tjurina is faster
    523 EXAMPLE: example T1; shows an example
     523EXAMPLE: example T_1; shows an example
    524524"
    525525{
    … …  
    530530     ideal t1  = std(J+jacob(J[1]));
    531531     module nb = [1]; module pnb;
    532      dbprint(printlevel-voice+3,"// dim T1 = "+string(vdim(t1)));
     532     dbprint(printlevel-voice+3,"// dim T_1 = "+string(vdim(t1)));
    533533     if( size(#)>0 )
    534534     {
    … …  
    556556//-------------------------- pull back to basering ----------------------------
    557557   setring P;
    558    t1 = fetch(R,t1)+J*freemodule(rk);  // T1-module, presentation of T1
     558   t1 = fetch(R,t1)+J*freemodule(rk);  // T_1-module, presentation of T_1
    559559   t1 = std(t1);
    560    dbprint(printlevel-voice+3,"// dim T1 = "+string(vdim(t1)));
     560   dbprint(printlevel-voice+3,"// dim T_1 = "+string(vdim(t1)));
    561561   if( size(#)>0 )
    562562   {
    … …  
    574574   ring r     = 32003,(x,y,z),(c,ds);
    575575   ideal i    = xy,xz,yz;
    576    module T   = T1(i);
    577    vdim(T);                      // Tjurina number = dim_K(T1), should be 3
    578    list L=T1(i,"");
     576   module T   = T_1(i);
     577   vdim(T);                      // Tjurina number = dim_K(T_1), should be 3
     578   list L=T_1(i,"");
    579579   module kB  = kbase(L[1]);
    580580   print(L[2]*kB);               // basis of 1st order miniversal deformation
    … …  
    586586///////////////////////////////////////////////////////////////////////////////
    587587
    588 proc T2 (ideal id, list #)
    589 "USAGE:   T2(id[,<any>]);  id = ideal
    590 RETURN:  T2(id): T2-module of id . This is a std basis of a presentation of
     588proc T_2 (ideal id, list #)
     589"USAGE:   T_2(id[,<any>]);  id = ideal
     590RETURN:  T_2(id): T_2-module of id . This is a std basis of a presentation of
    591591         the module of obstructions of R=P/id, if P is the basering.
    592592         If a second argument is present (of any type) return a list of
    593593         4 modules and 1 ideal:
    594             [1]= T2(id)
     594            [1]= T_2(id)
    595595            [2]= standard basis of id (ideal)
    596596            [3]= module of relations of id (=1st syzygy module of id)
    … …  
    598598            [5]= relations of Hom_P([3]/kos,R), lifted to P
    599599         The list contains all non-easy objects which must be computed
    600          to get T2(id).
    601 DISPLAY: k-dimension of T2(id) if printlevel >= 0 (default)
    602 NOTE:    The most important information is probably vdim(T2(id)).
     600         to get T_2(id).
     601DISPLAY: k-dimension of T_2(id) if printlevel >= 0 (default)
     602NOTE:    The most important information is probably vdim(T_2(id)).
    603603         Use proc miniversal to get equations of miniversal deformation.
    604 EXAMPLE: example T2; shows an example
     604EXAMPLE: example T_2; shows an example
    605605"
    606606{
    … …  
    624624   list B=nres(t2,2);                     // resolve (syz/kos)*
    625625   def B(1..2)=B[1..2]; kill B;
    626    t2 = modulo(B(2),A2');                 // presentation of T2
     626   t2 = modulo(B(2),A2');                 // presentation of T_2
    627627   rk = nrows(t2);
    628628//---------------------  fetch back to basering -------------------------------
    … …  
    630630   t2 = fetch(R,t2)+J*freemodule(rk);
    631631   t2 = std(t2);
    632    dbprint(printlevel-voice+3,"// dim T2 = "+string(vdim(t2)));
     632   dbprint(printlevel-voice+3,"// dim T_2 = "+string(vdim(t2)));
    633633   if( size(#)>0 )
    634634   {
    … …  
    645645   ring  r    = 32003,(x,y),(c,dp);
    646646   ideal j    = x6-y4,x6y6,x2y4-x5y2;
    647    module T   = T2(j);
     647   module T   = T_2(j);
    648648   vdim(T);
    649649   hilb(T);"";
    650650   ring r1    = 0,(x,y,z),dp;
    651651   ideal id   = xy,xz,yz;
    652    list L     = T2(id,"");
    653    vdim(L[1]);                           // vdim of T2
     652   list L     = T_2(id,"");
     653   vdim(L[1]);                           // vdim of T_2
    654654   print(L[3]);                          // syzygy module of id
    655655   printlevel = p;
    … …  
    657657///////////////////////////////////////////////////////////////////////////////
    658658
    659 proc T12 (ideal i, list #)
    660 "USAGE:   T12(i[,any]);  i = ideal
    661 RETURN:  T12(i): list of 2 modules:
    662              std basis of T1-module =T1(i), 1st order deformations
    663              std basid of T2-module =T2(i), obstructions of R=P/i
     659proc T_12 (ideal i, list #)
     660"USAGE:   T_12(i[,any]);  i = ideal
     661RETURN:  T_12(i): list of 2 modules:
     662             std basis of T_1-module =T_1(i), 1st order deformations
     663             std basid of T_2-module =T_2(i), obstructions of R=P/i
    664664         If a second argument is present (of any type) return a list of
    665665         9 modules, matrices, integers:
    666              [1]= standard basis of T1-module
    667              [2]= standard basis of T2-module
    668              [3]= vdim of T1
    669              [4]= vdim of T2
     666             [1]= standard basis of T_1-module
     667             [2]= standard basis of T_2-module
     668             [3]= vdim of T_1
     669             [4]= vdim of T_2
    670670             [5]= matrix, whose cols present infinitesimal deformations
    671671             [6]= matrix, whose cols are generators of relations of i (=syz(i))
    672672             [7]= matrix, presenting Hom_P(syz/kos,R), lifted to P
    673              [8]= presentation of T1-module, no std basis
    674              [9]= presentation of T2-module, no std basis
    675 DISPLAY: k-dimension of T1 and T2 if printlevel >= 0 (default)
     673             [8]= presentation of T_1-module, no std basis
     674             [9]= presentation of T_2-module, no std basis
     675DISPLAY: k-dimension of T_1 and T_2 if printlevel >= 0 (default)
    676676NOTE:    Use proc miniversal from deform.lib to get miniversal deformation of i,
    677677         the list contains all objects used by proc miniversal
    678 EXAMPLE: example T12; shows an example
     678EXAMPLE: example T_12; shows an example
    679679"
    680680{
    … …  
    684684   i = simplify(i,10);
    685685   module jac,t1,t2,sbt1,sbt2;
    686    matrix Kos,Syz,SK,kbT1,Sx;
     686   matrix Kos,Syz,SK,kbT_1,Sx;
    687687   list L;
    688688   ideal  i0 = std(i);
    … …  
    702702   list resN  = nres(No,2);
    703703   matrix Nx  = resN[2];
    704    module T2  = modulo(Sx,No);                  // presentation of T2
    705    r2         = nrows(T2);
    706    module T1  = modulo(Nx,Jac);                 // presentation of T1
    707    r1         = nrows(T1);
     704   module T_2  = modulo(Sx,No);                  // presentation of T_2
     705   r2         = nrows(T_2);
     706   module T_1  = modulo(Nx,Jac);                 // presentation of T_1
     707   r1         = nrows(T_1);
    708708//------------------------ pull back to basering ------------------------------
    709709   setring P;
    710    t1   = fetch(Ox,T1)+i*freemodule(r1);
    711    t2   = fetch(Ox,T2)+i*freemodule(r2);
     710   t1   = fetch(Ox,T_1)+i*freemodule(r1);
     711   t2   = fetch(Ox,T_2)+i*freemodule(r2);
    712712   sbt1 = std(t1);
    713713   d1   = vdim(sbt1);
    714714   sbt2 = std(t2);
    715715   d2   = vdim(sbt2);
    716    dbprint(printlevel-voice+3,"// dim T1 = "+string(d1),"// dim T2 = "+string(d2));
     716   dbprint(printlevel-voice+3,"// dim T_1 = "+string(d1),"// dim T_2 = "+string(d2));
    717717   if  ( size(#)>0)
    718718   {
    719719     if (d1>0)
    720720     {
    721        kbT1 = fetch(Ox,Nx)*kbase(sbt1);
     721       kbT_1 = fetch(Ox,Nx)*kbase(sbt1);
    722722     }
    723723     else
    724724     {
    725        kbT1 = 0;
     725       kbT_1 = 0;
    726726     }
    727727     Sx   = fetch(Ox,Sx);
    728      L = sbt1,sbt2,d1,d2,kbT1,Syz,Sx,t1,t2;
     728     L = sbt1,sbt2,d1,d2,kbT_1,Syz,Sx,t1,t2;
    729729     return(L);
    730730   }
    … …  
    739739   ideal i    = xz-y2,yz2-xu,xv-yzu,yu-z3,z2u-yv,zv-u2;
    740740                            //a cyclic quotient singularity
    741    list L     = T12(i,1);
     741   list L     = T_12(i,1);
    742742   print(L[5]);             //matrix of infin. deformations
    743743   printlevel = p;

  • Singular/extra.cc

    r925cab r0b59f5  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id: extra.cc,v 1.129 1999-12-08 16:49:06 obachman Exp $ */
     4/* $Id: extra.cc,v 1.130 1999-12-13 15:33:43 obachman Exp $ */
    55/*
    66* ABSTRACT: general interface to internals of Singular ("system" command)
    … …  
    11611161    else
    11621162#endif
    1163 /*==================== thomas =================*/
    1164     if (strcmp(sys_cmd, "thomas") == 0)
    1165     {
    1166       ideal id = (ideal) h->Data();
    1167       id = idCopy(id);
    1168       ring cr = currRing;
    1169       ring r = rCurrRingAssure_C_dp();
    1170       ideal id_r = idrMoveR(id, cr);
    1171       idTest(id_r);
    1172       idPrint(id_r);
    1173       if (r != cr)
    1174       {
    1175         rChangeCurrRing(cr, TRUE);
    1176         id_r = idrMoveR(id_r, r);
    1177         idTest(id_r);
    1178         idPrint(id_r);
    1179         idDelete(&id_r);
    1180         rKill(r);
    1181       }
    1182       return FALSE;
     1163/*==================== test =================*/
     1164    if (strcmp(sys_cmd, "test") == 0)
     1165    {
     1166      intvec v(3);
     1167     
     1168      v[4] = 1;
     1169     
    11831170    }
    11841171/*==================== Error =================*/

  • doc/pl2doc.pl

    r925cab r0b59f5  
    11#!/usr/local/bin/perl
    2 # $Id: pl2doc.pl,v 1.12 1999-12-10 16:41:50 obachman Exp $
     2# $Id: pl2doc.pl,v 1.13 1999-12-13 15:32:46 obachman Exp $
    33###################################################################
    44#  Computer Algebra System SINGULAR
    … …  
    392392    {
    393393      print $FH '@item @strong{Purpose:'."}\n";
    394       print $FH lc $text;
     394      if ($text !~ /[a-z]*/)
     395      {
     396        print $FH lc $text;
     397      }
     398      else
     399      {
     400        print $FH $text;
     401      }
    395402    }
    396403  }
Note: See TracChangeset for help on using the changeset viewer.