Changeset 20f2239 in git for Singular


Ignore:
Timestamp:
May 15, 2020, 9:38:32 PM (4 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'c5facdfddea2addfd91babd8b9019161dea4b695')
Children:
417a505a76f1137fb518b138cd109cc196892108
Parents:
1891fdca7cd3ff90403d60c1fe5e78ea9219f02c
Message:
spelling p7
Location:
Singular/LIB
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/brnoeth.lib

    r1891fd r20f2239  
    405405  // computes : (closed affine non-singular) points over an extension of
    406406  //            degree d
    407   // remark(1) : singular points are supposed to be listed appart
     407  // remark(1) : singular points are supposed to be listed apart
    408408  // remark(2) : std SL=s_locus(f) is supposed to be computed in advance
    409409  // remark(3) : ideal SL is used to remove those points which are singular
    … …  
    489489{
    490490  // computes : (closed affine non-singular) points of degree d
    491   // remark(1) : singular points are supposed to be listed appart
     491  // remark(1) : singular points are supposed to be listed apart
    492492  // remark(2) : std SL=s_locus(f) is supposed to be computed in advance
    493493  list L=closed_points_ext(f,d,SL);
    … …  
    508508static proc idealSubset (ideal I,ideal J)
    509509{
    510   // checks wether I is contained in J and returns a boolean
     510  // checks whether I is contained in J and returns a boolean
    511511  // remark : J is assumed to be given by a standard basis
    512512  int s=ncols(I);
    … …  
    712712{
    713713  // computes the degree of a list of type HNE which is actually defined over
    714   //    F_{p^r} eventhough it is given in an extension of such field
     714  //    F_{p^r} even though it is given in an extension of such field
    715715  int gr=1;
    716716  int rd=res_deg() div r;
    … …  
    860860static proc importdatum (def sf,string datum,string rel)
    861861{
    862   // fetchs a poly with name "datum" to the current basering from the ring sf
     862  // fetches a poly with name "datum" to the current basering from the ring sf
    863863  //   such that the generator is given by string "rel"
    864864  // warning : ring sf must have only variables (x,y) and basering must have
    … …  
    893893static proc rationalize (def lf,string datum,string rel)
    894894{
    895   // fetchs a poly with name "datum" to the current basering from the ring lf
     895  // fetches a poly with name "datum" to the current basering from the ring lf
    896896  //   and larger coefficients field, where the generator of current ring is
    897897  //   given by string "rel" and "datum" is actually defined over the small
    … …  
    32643264  // computes a local equation of polynomial H in the ring SS related to the place
    32653265  //     "m"
    3266   // list POINT/POINTS is searched depending on wether m=0 or m>0 respectively
     3266  // list POINT/POINTS is searched depending on whether m=0 or m>0 respectively
    32673267  // warning : the procedure must be called from ring "Proj_R" and returns a
    32683268  //     string
    … …  
    34763476  // simplifies a rational function f/g extracting the gcd(f,g)
    34773477  // maybe add a "restriction" to the curve "CHI" but it is not easy to
    3478   // programm
     3478  // program
    34793479  poly auxp=gcd(F[1],F[2]);
    34803480  return(ideal(division(F,auxp)[1]));
    … …  
    36113611  //   Brill-Noether
    36123612  // returns 2 lists : the first consists of all the poles up to m in
    3613   //   increasing order and the second consists of the corresponging rational
     3613  //   increasing order and the second consists of the corresponding rational
    36143614  //   functions
    36153615  list Places=CURVE[3];
    … …  
    41914191        {
    41924192          def S(i)=CURVE[5][i][1];
    4193           // embedd S(i) inside basering == RatPl " ==S(d) "
     4193          // embed S(i) inside basering == RatPl " ==S(d) "
    41944194          olda=subfield(S(i));
    41954195          setring S(i);
    … …  
    45574557        sol=(number(1)/number(pivote))*sol;
    45584558      }
    4559       // check at least that the number of comitted errors is less than half
     4559      // check at least that the number of committed errors is less than half
    45604560      //     the Goppa distance
    45614561      // imposing Hamming_wt(sol)<=K[n+3][1] would be more correct, but maybe

  • Singular/LIB/chern.lib

    r1891fd r20f2239  
    7272  tdCf(n);                  the coefficients of the Todd class of a line bundle
    7373  tdTerms(n, f);            the terms of the Todd class of a line bundle
    74                             coresponding to the Chern root t
    75   tdFactor(n, t);           the Todd class of a line bundle coresponding
     74                            corresponding to the Chern root t
     75  tdFactor(n, t);           the Todd class of a line bundle corresponding
    7676                            to the Chern root t
    7777  cProj(n);                 the total Chern class of (the tangent bundle on)
    … …  
    275275  int sign;
    276276  poly f;
    277   for(i=1; i<=N; i++) // use the resursive formula
     277  for(i=1; i<=N; i++) // use the recursive formula
    278278  {
    279279    f=0;
    … …  
    327327  int i, j;
    328328  poly f;
    329   for(i=1; i<=N; i++) // use the resursive formula
     329  for(i=1; i<=N; i++) // use the recursive formula
    330330  {
    331331    f=0;
    … …  
    514514EXAMPLE:  example powSumSym; shows an example
    515515NOTE:     returns the terms of the Chern character
    516           multiplied by the correspoding factorials
     516          multiplied by the corresponding factorials
    517517"
    518518{
    … …  
    535535    else // if the optional parameter is not an integer, then
    536536    {
    537       n=size(c); // ingore it and set n to be the length of c
     537      n=size(c); // ignore it and set n to be the length of c
    538538    }
    539539  }
    … …  
    934934  else // otherwise define the rank of the product vector bundle by
    935935  {
    936     n=size(c)*size(C); // looking at the lenghts of c and C
     936    n=size(c)*size(C); // looking at the lengths of c and C
    937937  }
    938938  if( size(#) != 0 ) // if there is an optional parameter
    … …  
    15911591  // the higher classes are assumed to be zero and the list is appended by zeroes up to length r
    15921592  c=append_by_zeroes(r, c);
    1593   // if the lenght of the list of the Chern classes is greater than the rank
     1593  // if the length of the list of the Chern classes is greater than the rank
    15941594    c=c[1..r]; // throw away the redundant data
    15951595  //-----------------------------------
    1596   // from now on the lenght of c is r>0
     1596  // from now on the length of c is r>0
    15971597  //-----------------------------------
    15981598  if(k<0)
    … …  
    16701670    for(j=1; j <= NN; j++) // process the optional parameters
    16711671    {
    1672       // process the optional parameters only untill they are not bigger than N;
     1672      // process the optional parameters only until they are not bigger than N;
    16731673      // notice they are positive anyway after integer_list(...)
    16741674      if( #[j]<=N  )
    … …  
    19761976    for(j=1; j <= NN; j++) // process the optional parameters
    19771977    {
    1978       // process the optional parameters only untill they are not bigger than N;
     1978      // process the optional parameters only until they are not bigger than N;
    19791979      // notice they are positive anyway after integer_list(...)
    19801980      if( #[j]<=N  )
    … …  
    24252425RETURN:   polynomial
    24262426PURPOSE:  computes up to degree n the Todd class
    2427           of the line bundle coresponding to the Chern root t
     2427          of the line bundle corresponding to the Chern root t
    24282428EXAMPLE:  example tdFactor; shows an example
    24292429NOTE:     returns 0 if n is negative
    … …  
    25812581RETURN:   polynomial
    25822582PURPOSE:  computes the Euler characteristic of a vector bundle on P_n
    2583           in terms of its rank and Chern classses
     2583          in terms of its rank and Chern classes
    25842584EXAMPLE:  example eulerChProj; shows an example
    25852585NOTE:
    … …  
    29872987"USAGE:   PartC( I, m);  I list of integers, m integer
    29882988RETURN:   list of integers
    2989 PURPOSE:  commputes the complement of a partition with respect to m
     2989PURPOSE:  computes the complement of a partition with respect to m
    29902990EXAMPLE:  example PartC; shows an example
    29912991NOTE:     returns the zero partition if the maximal element of the partition is smaller than m
    … …  
    30313031    // give a warning
    30323032    print("You are trying to compute partitions over an empty partition!");
    3033     return( list() ); // and return the emty list
     3033    return( list() ); // and return the empty list
    30343034  }
    30353035  if( J[m] > n ) // if the biggest summand of the partition is bigger than n
    30363036  {
    3037     return( list( ) ); // return the emty list
     3037    return( list( ) ); // return the empty list
    30383038  }
    30393039  if( J[m] == 0 ) // if J consists of zeroes
    … …  
    30623062    P=rez[i]; // for each partition P of this type
    30633063    last = max( P[size(P)], J[m] );
    3064     for(j = last;j<= n;j++) // run through the integers exceding the last summands of P and J
     3064    for(j = last;j<= n;j++) // run through the integers exceeding the last summands of P and J
    30653065    {
    30663066      // append them to P at the end and add the resulting partition to the result
    … …  
    34833483  ring r = 0, (x, y, z), dp;
    34843484  list l=(x, y, z);
    3485   //append the list by two zeroes and get a list of lenght 5
     3485  //append the list by two zeroes and get a list of length 5
    34863486  print( append_by_zeroes(5, l) );
    34873487}
    … …  
    35233523RETURN:   list
    35243524PURPOSE:  gets the first positive ingerer entries of l, computes their maximum;
    3525           used for adjusting the lists of optional parameters that are suposed to be integers
     3525          used for adjusting the lists of optional parameters that are supposed to be integers
    35263526EXAMPLE:  example integer_list; shows an example
    35273527NOTE:     used in chWedge(...) and chSymm(...)
    … …  
    37793779  ring r = 0, (x, y, z), dp;
    37803780  list l=(1, 2, 3);
    3781   //append the list by two zeroes and get a list of lenght 5
     3781  //append the list by two zeroes and get a list of length 5
    37823782  print( apn0_int(5, l) );
    37833783}
    … …  
    39433943  print(I);
    39443944  ideal J=equal_deg(I);
    3945   // now the ideal is generated by elemets of degree 2
     3945  // now the ideal is generated by elements of degree 2
    39463946  // and defines the same subscheme in the projective plane
    39473947  J;

  • Singular/LIB/cisimplicial.lib

    r1891fd r20f2239  
    2727                                      nonnegative integral solution
    2828 cardGroup(A);           computes the cardinal of Z^m / ZA
    29  isCI(A);     checks wether I(A) is a complete intersection
     29 isCI(A);     checks whether I(A) is a complete intersection
    3030";
    3131
    … …  
    417417         If a third parameter k is introduced, it will only consider the
    418418         first k columns of A.
    419 ASSUME:  A is a matrix with nonnegative entries, nonzero colums,
     419ASSUME:  A is a matrix with nonnegative entries, nonzero columns,
    420420         v is a nonnegative vector and nrows(v) = nrows(A).
    421421EXAMPLE: example belongSemigroup; shows some examples.
    … …  
    700700   control[a + max] = 0;   // Ending node
    701701   int current = 1;        // Current node
    702    int next;               // Node connected to corrent by arc (current, next)
     702   int next;               // Node connected to current by arc (current, next)
    703703
    704704   int ElemQueue, ElemQueue2;
    … …  
    774774USAGE:  CheckMin(posiblemin,A,column[,n]); posiblemin is an integer,
    775775        A is an integral matrix and column and last are integers.
    776 RETURN: 1 if posiblemin is the minimum value x such that x * (column-th colum of A)
     776RETURN: 1 if posiblemin is the minimum value x such that x * (column-th column of A)
    777777        belongs to the semigroup generated by all the columns of A except
    778778        A_column. It returns 0 otherwise. If an extra parameter n is
    … …  
    783783
    784784   // If one can write (posiblemin-1)*A_column as a non-trivial combination of the
    785    // colums of A, then posiblemin is > to the real minimum
     785   // columns of A, then posiblemin is > to the real minimum
    786786   intvec counters, multip;
    787787   counters[ncols(A)] = 0;
    … …  
    893893{
    894894   // If one can write (posiblemin-1)*A_column as a non-trivial combination of the
    895    // colums of A, then posiblemin is > than the real minimum
     895   // columns of A, then posiblemin is > than the real minimum
    896896
    897897   int last;
    … …  
    11011101        returns 0 if it is not necessary to compute for the main program.
    11021102        If an extra parameter n is introuduced it considers the first n
    1103         colums of A.
     1103        columns of A.
    11041104ASSUME: 1 <= column [<= n] <= ncols(A), A has nonnegative entries, line is
    11051105        a vector such that line[i] = line[j] if and only if the i-th and
    … …  
    11321132   }
    11331133
    1134    // We will only consider those colums A_j such that line[j] = line[column]
     1134   // We will only consider those columns A_j such that line[j] = line[column]
    11351135   intvec prop, jthcolumn;
    11361136   for (j = 1; j <= last; j++)
    … …  
    14941494                     else
    14951495                     {
    1496                         // We check wether m_i b_i belongs to the semigroup generated by V_k
     1496                        // We check whether m_i b_i belongs to the semigroup generated by V_k
    14971497                        // where k = swap[i]. All vectors in V_k are proportional to b_i
    14981498                        intvec checkbelong;
    … …  
    15421542                     else
    15431543                     {
    1544                         // We check wether m_j b_j belongs to the semigroup generated by V_k
     1544                        // We check whether m_j b_j belongs to the semigroup generated by V_k
    15451545                        // where k = swap[j]. All vectors in V_k are proportional to b_j
    15461546                        intvec checkbelong;

  • Singular/LIB/classify.lib

    r1891fd r20f2239  
    1616 classify(f);        normal form of polynomial f determined with Arnold's method
    1717 corank(f);          computes the corank of f (i.e. of the Hessian of f)
    18  Hcode(v);           coding of intvec v acoording to the number repetitions
     18 Hcode(v);           coding of intvec v according to the number repetitions
    1919 init_debug([n]);    print trace and debugging information depending on int n
    2020 internalfunctions();display names of internal procedures of this library
    … …  
    17441744  if( ShowPhi > 1) { PhiG; }
    17451745
    1746 //------------------------ compute spliting lemma -----------------------------
     1746//------------------------ compute splitting lemma -----------------------------
    17471747  fc = fi;
    17481748  i  = 1;              // Index fuer Variablen wird bearbeitet
    … …  
    20622062  {
    20632063    if(Mult == 1) { return("V:doubleline + line"); }    // x2y
    2064     if(Mult == 2) { return("V': tripple line"); }       // x3
     2064    if(Mult == 2) { return("V': triple line"); }       // x3
    20652065  }
    20662066  if(Dim == 3) { return("P[9]:nodal cubic"); }  // x3 + y3 + xyz
    … …  
    24552455proc singularity(string typ, list #)
    24562456"USAGE:    singularity(t, l); t=string (name of singularity),
    2457           l=list of integers/polynomials (indices/parmeters of singularity)
     2457          l=list of integers/polynomials (indices/parameters of singularity)
    24582458COMPUTE:  get the singularity named by type t from the database.
    24592459          list l is as follows: @*
    … …  
    26582658          when to print the list of strings. init_debug() reports only
    26592659          changes of @DeBug.
    2660 NOTE:     The procedure init_debug(n); is usefull as trace-mode. n may
     2660NOTE:     The procedure init_debug(n); is useful as trace-mode. n may
    26612661          range from 0 to 10, higher values of n give more information.
    26622662EXAMPLE:  example init_debug; shows an example"
    … …  
    27372737"USAGE:    corank(f);   f=poly
    27382738RETURN:   the corank of the Hessian matrix of f, of type int
    2739 REMARK:   corank(f) is the number of variables occuring in the residual
     2739REMARK:   corank(f) is the number of variables occurring in the residual
    27402740          singularity after applying 'morsesplit' to f
    27412741EXAMPLE:  example corank; shows an example"

  • Singular/LIB/classify2.lib

    r1891fd r20f2239  
    965965  poly equ;
    966966  for (int i=2;i<=size(L[1]);i++){if (deg(L[1][i])==1){equ=L[1][i];break;}}
    967   if (equ==0){ERROR("There should be a tranformation on the diagonal defined over the current field");}
     967  if (equ==0){ERROR("There should be a transformation on the diagonal defined over the current field");}
    968968  number a1=number(subst(equ,aa,0));
    969969  number a2=number(diff(equ,aa));

  • Singular/LIB/classifyMapGerms.lib

    r1891fd r20f2239  
    7979"USAGE:   coDim(module M, module N, ideal I,int bound, list #); M is a submodule
    8080          in A^r over the basering=:A, N is a submodule in R^r over the subring
    81           R of the basering genrated by the entries of I
     81          R of the basering generated by the entries of I
    8282COMPUTE:  computes the K-vectorspace dimension of A^r/M+N+maxideal(bound)*A^r
    8383RETURN:   an integer
    … …  
    139139proc vStd(module M, module N, ideal I,int bound)
    140140"USAGE:    vStd(M, N, I, bound);M is a submodule  in A^r over the basering=:A,
    141            N ist a submodule in R^r over the subring R of the basering genrated
     141           N ist a submodule in R^r over the subring R of the basering generated
    142142           by the entries of I
    143143COMPUTE:  a standard basis of M+N+maxideal(bound)*A^r
    … …  
    184184"USAGE:    vStd(M, N, I, bound);M is a submodule generated by one element in A^r over the
    185185           basering=:A, N ist a submodule in R^r over the subring R of the basering
    186            genrated by the entries of I
     186           generated by the entries of I
    187187COMPUTE:  a standard basis of M+N+maxideal(bound)*A^r
    188188RETURN:   a list whose ist entry gives a list where each entry is a  genrator of
    … …  
    321321"USAGE:   computeN(M, N, I, bound) M is a submodule  in A^r over the basering=:A
    322322          N ist a submodule in R^r over the subring R of the basering
    323           genrated by the entries of I
     323          generated by the entries of I
    324324COMPUTE:  all products of powers of generators of I with N
    325325"
    … …  
    363363"USAGE:   myReduceM(N, M, bound) M is a submodule  in A^r over the basering=:A
    364364          N ist a submodule in R^r over the subring R of the basering
    365           genrated by the entries of I
     365          generated by the entries of I
    366366COMPUTE:  myReduce for ideals
    367367"
    … …  
    644644"USAGE:   modVStd0((M, N, I,bound, #); M is a submodule
    645645          in A^r over the basering=:A, N ist a submodule in R^r over the subring
    646           R of the basering genrated by the entries of I
     646          R of the basering generated by the entries of I
    647647COMPUTE:  a standard basis of M+N+maxideal(bound)*A^r using the parallel modular
    648648          version
    … …  
    691691"USAGE:   modVStd((M, N, I,bound, #); M is a submodule
    692692          in A^r over the basering=:A, N ist a submodule in R^r over the subring
    693           R of the basering genrated by the entries of I
     693          R of the basering generated by the entries of I
    694694COMPUTE:  a standard basis of A^r/M+N+maxideal(bound)*A^r using modular version
    695695RETURN:   a list whose ist entry gives a list where each entry is a  genrator of

  • Singular/LIB/classifyceq.lib

    r1891fd r20f2239  
    560560{
    561561       //    input    poly p
    562        //    output   The normal form to which f is contact equvalent or the function is not simple.
     562       //    output   The normal form to which f is contact equivalent or the function is not simple.
    563563       def R=basering;
    564564       int t=tjurina(p);
    … …  
    822822                              if(size(lengthBL(f))==4)
    823823                              {
    824                                      retrun("The given function defines an isolated Singularity.
     824                                     return("The given function defines an isolated Singularity.
    825825The Tjurina number is "+string(tjurina(f))+".
    826826E^0[7]:z2+x3+xy3.");
    … …  
    11131113///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    11141114static proc whichSUR(poly f)
    1115 //====This procedure is required to separate the Surface Case D_2m from D_2m+1 as discribes in [2].
     1115//====This procedure is required to separate the Surface Case D_2m from D_2m+1 as describes in [2].
    11161116{
    11171117   int d=tjurina(f);

  • Singular/LIB/classifyci.lib

    r1891fd r20f2239  
    669669static  proc typejet2(poly g1,poly g2)
    670670"USAGE:  typejet2(g1,g2);  g1,g2 are polynomials
    671 ASSUME: g1,g2 are homogenous polynomials of degree 2
     671ASSUME: g1,g2 are homogeneous polynomials of degree 2
    672672PURPOSE: Check whether (g1,g2) is a quadratic form in the list of Guisti or not
    673673RETURN: string  type for the quadratic forms appearing in Guist's list
    … …  
    10191019       {
    10201020         T=WSemigroup(TTT,w);
    1021          A[e]=T[1];       //  intersted only in semigroup
     1021         A[e]=T[1];       //  interested only in semigroup
    10221022         e++;
    10231023       }

  • Singular/LIB/control.lib

    r1891fd r20f2239  
    900900    {
    901901      M[i] = std(M[i]);
    902       //      M[i] = prune(M[i]); // mimimal embedding: no need yet
     902      //      M[i] = prune(M[i]); // minimal embedding: no need yet
    903903      //      M[i] = std(M[i]);
    904904    }
    … …  
    14171417"USAGE:  controlExample(s);   s a string
    14181418RETURN:  ring
    1419 PURPOSE: set up an example from the mini database by initalizing a ring and a module in a ring
     1419PURPOSE: set up an example from the mini database by initializing a ring and a module in a ring
    14201420NOTE: in order to see the list of available examples, execute @code{controlExample(\"show\");}
    14211421@* To use an example, one has to do the following. Suppose one calls the ring, where the example will be activated, A. Then, by executing

  • Singular/LIB/crypto.lib

    r1891fd r20f2239  
    867867    if(n==1){return(re);}
    868868
    869 //this is optional: test whether a prime of the list # devides n
     869//this is optional: test whether a prime of the list # divides n
    870870    if(size(#)>0)
    871871    {
    … …  
    18461846RETURN: a factor of N or the message no factor found
    18471847NOTE: - computes a factor of N using Lenstra's ECM factorization@*
    1848       - the idea is that the fact that N is not prime is dedected using
     1848      - the idea is that the fact that N is not prime is detected using
    18491849        the operations on the elliptic curve
    18501850      - is similarly to Pollard's p-1-factorization
    … …  
    18791879         M=M*w;
    18801880         P=ellipticMult(N,L[1],L[2]^2,P,w);
    1881          if(size(P)==4){return(P[4]);}  //some inverse did not exsist
     1881         if(size(P)==4){return(P[4]);}  //some inverse did not exist
    18821882         if(P[3]==0){break;}            //the case M*P=0
    18831883      }
    … …  
    27602760  while((counter<=size(worksack))&&(sol>0))
    27612761  {
    2762     //Try to substract an element of the knapsack from the capacity. Create a list with all the summands used
     2762    //Try to subtract an element of the knapsack from the capacity. Create a list with all the summands used
    27632763    calcu = sol-worksack[counter];
    27642764    if (calcu>=0)
    … …  
    27742774  }
    27752775
    2776   //Get the index of the summands of the original knapsack and change the bits in the binary list wich will be the solution
     2776  //Get the index of the summands of the original knapsack and change the bits in the binary list which will be the solution
    27772777  list binary_list;
    27782778  for (i=1;i<=size(knapsack);i++)
    … …  
    28782878      minmax_list = bubblesort(minmax_list);
    28792879
    2880       //insert Element y_i into y_list, wich is the smallest of (b_i/w_ij) like in the PECH algorithm description.
     2880      //insert Element y_i into y_list, which is the smallest of (b_i/w_ij) like in the PECH algorithm description.
    28812881      y_list = insert(y_list,minmax_list[size(minmax_list)],size(y_list));
    28822882
    … …  
    29092909    output_list[E[index]]=1;
    29102910
    2911     //Update the capacities by substracting the weights of the selection
     2911    //Update the capacities by subtracting the weights of the selection
    29122912    for (i=1;i<=size(capacities);i++)
    29132913    {
    … …  
    34913491  int set_destination;
    34923492
    3493   //create list of lists wich contain the lists of a certain length as elements
     3493  //create list of lists which contain the lists of a certain length as elements
    34943494  for (i = 1; i<= size(subsetlist); i++)
    34953495  {
    3496     //Determine the size of the acutal list to choose where to insert it in the listoflists
     3496    //Determine the size of the actual list to choose where to insert it in the listoflists
    34973497    set_destination = size(subsetlist[i]);
    34983498    if (set_contains(alreadycreatedlist,set_destination)==1)
    … …  
    35093509  }
    35103510
    3511   //Check for injectivity of each seperate list. Works as in injectivity or h-injectivity
     3511  //Check for injectivity of each separate list. Works as in injectivity or h-injectivity
    35123512  for (v=1; v<=size(listoflists); v++)
    35133513  {
    … …  
    36333633number s=ki*(h+a*r) mod q;       //2065
    36343634
    3635 //========== signatur is (r,s)=(76646,2065) =====================
     3635//========== signature is (r,s)=(76646,2065) ====================
    36363636//==================== verification  ============================
    36373637

  • Singular/LIB/curveInv.lib

    r1891fd r20f2239  
    430430ASSUME:     - the basering is the normalization of R/P, where P is a prime
    431431            - Der_P is the module of P-preserving derivations
    432             - U containts the generators of the normalization of R/P
     432            - U contains the generators of the normalization of R/P
    433433            - relid is the ideal of relations that hold in the normalization of R/P
    434434RETURN:     the colength of derivations of R/P
    … …  
    475475ASSUME:     - the basering is the normalization of R/P, where P is prime
    476476            - Der_P is the module of P-preserving derivations (with adjusted generators)
    477             - U containts the generators of the normalization of R/P
     477            - U contains the generators of the normalization of R/P
    478478            - relid is the ideal of relations that hold in the normalization of R/P
    479479RETURN:     The derivation module lifted to the normalization

  • Singular/LIB/curvepar.lib

    r1891fd r20f2239  
    10611061proc WSemigroup(list X,int b0)
    10621062"USAGE:    WSemigroup(X,b0);
    1063            X a list of polinomials in one vaiable, say t.
     1063           X a list of polynomials in one variable, say t.
    10641064           b0 an integer
    10651065COMPUTE:   Weierstrass semigroup of space curve C,which is given by a parametrization
    … …  
    10711071           M[2]=integer, conductor of the Weierstrass semigroup.
    10721072           M[3]=intvec, all elements of the Weierstrass semigroup till some bound b,
    1073            which is greather than conductor.
     1073           which is greater than conductor.
    10741074WARNING:   works only over the ring with one variable with ordering ds
    10751075EXAMPLE: example WSemigroup; shows an example"

  • Singular/LIB/deRham.lib

    r1891fd r20f2239  
    1414REFERENCES:
    1515[OT] Oaku, T.; Takayama, N.: Algorithms of D-modules - restriction, tensor product,
    16      localzation, and local cohomology groups}, J. Pure Appl. Algebra 156, 267-308
     16     localization, and local cohomology groups}, J. Pure Appl. Algebra 156, 267-308
    1717     (2001)
    1818[R]  Rottner, C.: Computing de Rham Cohomology,diploma thesis (2012)@*
    … …  
    5959        one of the strings@*
    6060        -'iterativeloc': compute localizations by factorizing the polynomials and
    61          sucessive localization of the factors @*
     61         successive localization of the factors @*
    6262        -'no iterativeloc': compute localizations by directly localizing the
    6363         product@*
    6464        and one of the strings
    65         -'onlybounds': computes bounds for the minimal and maximal interger roots
     65        -'onlybounds': computes bounds for the minimal and maximal integer roots
    6666         of the global b-function
    6767        -'exactroots' computes the minimal and maximal integer root of the global
    … …  
    18251825        }
    18261826    }
    1827   out[1]=list(list());//initalize our list
     1827  out[1]=list(list());//initialize our list
    18281828  C[1][2][5]=out[2][1][1][1];
    1829   /*Compute the last V_d-strict seqeunce*/
     1829  /*Compute the last V_d-strict sequence*/
    18301830  if (Syzstring=="Vdres")
    18311831    {
    … …  
    34183418          if (size(L[i][2][5][j])!=0)
    34193419            {
    3420               //horizonal differential P^i_j->P^(i-1)_j
     3420              //horizontal differential P^i_j->P^(i-1)_j
    34213421              nr=nrows(L[i][2][3][j])-nrows(L[i][2][5][j]);
    34223422              out[i][j+1][4]=(-1)^j*prodr(nr,nrows(L[i][2][5][j]));
    … …  
    34383438          for (k=1; k<=Min(list(oldj,newj)); k++)
    34393439            {
    3440               /*horizonal differential P^(i-1)_(k-1)->P^i_(k-1)*/
     3440              /*horizontal differential P^(i-1)_(k-1)->P^i_(k-1)*/
    34413441              nr=nrows(out[i-1][k][4]);
    34423442              out[i-1][k][4]=matrix(out[i-1][k][4],nr,out[i][k][1]);
    … …  
    45874587  setring Whom;
    45884588  matrix Mnew=imap(W,M);
    4589   list forMnew=homogenize(Mnew,d,v,1);//commputes homogenization of M;
     4589  list forMnew=homogenize(Mnew,d,v,1);//computes homogenization of M;
    45904590  Mnew=forMnew[1];
    45914591  int rightexp=forMnew[2];

  • Singular/LIB/decodegb.lib

    r1891fd r20f2239  
    101101@end format
    102102RETURN: the ring to work with the CRHT-ideal (with Sala's additions),
    103         containig an ideal with name 'crht'
     103        containing an ideal with name 'crht'
    104104THEORY:  Based on 'defset' of the given cyclic code, the procedure constructs
    105105         the corresponding Cooper-Reed-Heleseth-Truong ideal 'crht'. With its
    … …  
    477477          - odd is an additional parameter: if
    478478           set to 1, then the defining set is enlarged by odd elements,
    479            which are 2^(some power)*(some elment in the def.set) mod n
     479           which are 2^(some power)*(some element in the def.set) mod n
    480480@end format
    481481RETURN:    the ring with the resulting system called 'bin'
    … …  
    17371737     int i,j,k;
    17381738
    1739      //--------------- add vanishing realtions ---------------------
     1739     //--------------- add vanishing relations ---------------------
    17401740     for (i=1; i<=t; i++)
    17411741     {
    … …  
    17661766     result=simplify(result,8);
    17671767
    1768      //--------------- add check realtions --------------------
     1768     //--------------- add check relations --------------------
    17691769     poly sum;
    17701770     matrix syn[m][1]=syndrome(check,y);
    … …  
    19071907
    19081908///////////////////////////////////////////////////////////////////////////////
    1909 // imitating two indeces
     1909// imitating two indices
    19101910static proc x_var (int i, int j, int s)
    19111911{
    … …  
    19781978          - ncodes is the number of random codes to be processed,
    19791979          - ntrials is the number of received vectors per code to be corrected,
    1980           - minpol: due to some pecularities of SINGULAR one needs to provide
     1980          - minpol: due to some peculiarities of SINGULAR one needs to provide
    19811981          minimal polynomial for the extension explicitly
    19821982@end format

  • Singular/LIB/decomp.lib

    r1891fd r20f2239  
    153153        in the second case, it kills the user-defined control parameters and@*
    154154                            resets to the default setting which will then
    155                             be diplayed. @* @*
     155                            be displayed. @* @*
    156156        int DECMETH; Method for computing the univariate decomposition@*
    157157                 0 : (default) Kozen-Landau @*
    … …  
    270270  }
    271271  g = g + zeropart;
    272   dbprint("* Sucessfully multivariate decomposed by a monomial"+newline);
     272  dbprint("* Successfully multivariate decomposed by a monomial"+newline);
    273273  return(ideal(g,monomial(minv)));
    274274}
    … …  
    937937 }
    938938 else {
    939    dbprint("* Sucessfully multivariate decomposed"+newline);
     939   dbprint("* Successfully multivariate decomposed"+newline);
    940940  return(I);
    941941 }
    … …  
    10381038
    10391039   // Determine ord(f);
    1040    //cc  = coef(f,vvar);  // extract coefficents of f
     1040   //cc  = coef(f,vvar);  // extract coefficients of f
    10411041   //print(cc); read("");
    10421042
    … …  
    11211121  if (iscomposed)
    11221122  {
    1123    dbprint("** Sucessfully univariate decomposed with deg g = "+string(r)+newline);
     1123   dbprint("** Successfully univariate decomposed with deg g = "+string(r)+newline);
    11241124    I = g,h;
    11251125  } else {
    … …  
    15571557 // --  Example -------------
    15581558
    1559 //  Comparision Kozen-Landau vs. von zur Gathen
     1559//  Comparison Kozen-Landau vs. von zur Gathen
    15601560
    15611561 ring r02 = 0,(x,y),dp;

  • Singular/LIB/deflation.lib

    r1891fd r20f2239  
    132132static proc remove_constants(ideal H);
    133133{
    134    //remove contants and scalar multiples from H
     134   //remove constants and scalar multiples from H
    135135   H=1,H;
    136136   H=simplify(H,2+4+8);

  • Singular/LIB/difform.lib

    r1891fd r20f2239  
    516516            - a list of generators of a graded part of the differential algebra
    517517REMARKS:    In order to find all generators, they are counted 'binary': The generators are in
    518             1:1 - correspondance to the dual number representations of 1 up to (2^n-1)
     518            1:1 - correspondence to the dual number representations of 1 up to (2^n-1)
    519519NOTE:       - if all generators of the differential algebra are needed, apply the
    520520            procedure without input
    … …  
    676676
    677677// For the construction of more general differential forms,
    678 // the constructor difformFromPoly is used implicitely:
     678// the constructor difformFromPoly is used implicitly:
    679679
    680680difform dg = 3*x*dx - y*dy + dx*dy*dz + 1;
    … …  
    18491849
    18501850/////////////////////////////////////////////
    1851 // Sortation of list with strcture "Dlist" //
     1851// Sortation of list with structure "Dlist" //
    18521852/////////////////////////////////////////////
    18531853
    … …  
    18591859
    18601860/////////////////////////////////////////////
    1861 // Sortation of list with strcture "Llist" //
     1861// Sortation of list with structure "Llist" //
    18621862/////////////////////////////////////////////
    18631863
    … …  
    19251925NOTE:       - the differential is a map Omega_R^(p) -> Omega_R^(p+1) and this procedure applies
    19261926            the differential to all homogeneous parts of df
    1927             - this procedure can also be apllied to polynomials - in this case it is just the universal derivation
     1927            - this procedure can also be applied to polynomials - in this case it is just the universal derivation
    19281928KEYWORDS:   differential; universal; derivation
    19291929SEE ALSO:   difformUnivDer
    … …  
    19891989            then it is set as structure list of phi
    19901990NOTE:       the structure of L must follow the rules:
    1991                 - L[1] is a list of all degree-1 generators: all dx_i must occure once and no other
     1991                - L[1] is a list of all degree-1 generators: all dx_i must occur once and no other
    19921992                differential forms are allowed. The order of the list is not important
    19931993                - L[2] is the list of images of the dx_i: these must be polynomials
    … …  
    20462046                - Any degree-1 generator must occur once - this is checked via difformListCont
    20472047NOTE:       like in derivationFromList, the structure of L must follow the rules:
    2048                 - L[1] is a list of all degree-1 generators: all dx_i must occure once and no other
     2048                - L[1] is a list of all degree-1 generators: all dx_i must occur once and no other
    20492049                differential forms are allowed. The order of the list is not important
    20502050                - L[2] is the list of images of the dx_i: these must be polynomials
    … …  
    21092109RETURN:     a derivation which maps any degree-1 generator to f
    21102110REMARKS:    The degree-1 generators are returned by diffAlgebraListGen
    2111 NOTE:       the procedure allows to interprete polynomials as derivations
     2111NOTE:       the procedure allows to interpret polynomials as derivations
    21122112KEYWORDS:   constructor; derivation; polynomial
    21132113SEE ALSO:   derivationConstructor, derivationFromList
    … …  
    26752675            structure list of phi are sorted the same way
    26762676NOTE:       - the differential form 0 is allowed as input
    2677             - an error will occure if the given differential form is not of degree 1 or -1
     2677            - an error will occur if the given differential form is not of degree 1 or -1
    26782678KEYWORDS:   evaluation; derivation; application
    26792679SEE ALSO:   difformListSort, difformCoef

  • Singular/LIB/divisors.lib

    r1891fd r20f2239  
    3939makeDivisor(ideal,ideal)                        create a divisor
    4040divisorplus(divisor,divisor)                    add two divisors
    41 multdivisor(int,divisor)                        multiply a divisor by an interger
     41multdivisor(int,divisor)                        multiply a divisor by an integer
    4242negativedivisor(divisor)                        compute the negative of the divisor
    4343normalForm(divisor)                             normal form of a divisor
    … …  
    5050
    5151makeFormalDivisor(list)                         make a formal integer sum of divisors
    52 evaluateFormalDivisor(formaldivisor)            evalutate a formal sum of divisors to a divisor
     52evaluateFormalDivisor(formaldivisor)            evaluate a formal sum of divisors to a divisor
    5353formaldivisorplus(formaldivisor,formaldivisor)  add two formal divisors
    5454negativeformaldivisor(formaldivisor)            compute the negative of the formal divisor
    55 multformaldivisor(int,formaldivisor)            multiply a formal divisor by an interger
     55multformaldivisor(int,formaldivisor)            multiply a formal divisor by an integer
    5656degreeFormalDivisor(formaldivisor)              degree of a formal divisor
    5757

  • Singular/LIB/dmod.lib

    r1891fd r20f2239  
    442442  dbprint(ppl-1, I);
    443443  matrix M = syz(I);
    444   M = transpose(M);  // it is more usefull working with columns
     444  M = transpose(M);  // it is more useful working with columns
    445445  dbprint(ppl,"// -1-2- the module syz(-F,_Dx(F)) has been computed");
    446446  dbprint(ppl-1, M);
    … …  
    530530
    531531// alternative code for SannfsBM, renamed from annfsBM to ALTannfsBM
    532 // is superfluos - will not be included in the official documentation
     532// is superfluous - will not be included in the official documentation
    533533static proc ALTannfsBM (poly F, list #)
    534534"USAGE:  ALTannfsBM(f [,eng]);  f a poly, eng an optional int
    … …  
    851851  L[1] = RL[1];
    852852  L[4] = RL[4];  //char, minpoly
    853   // check whether vars hava admissible names -> done earlier
     853  // check whether vars have admissible names -> done earlier
    854854  // now, create the names for new var
    855855  tmp[1] = "s";
    … …  
    10811081  L[1] = RL[1];
    10821082  L[4] = RL[4];  //char, minpoly
    1083   // check whether vars hava admissible names -> done earlier
     1083  // check whether vars have admissible names -> done earlier
    10841084  // now, create the names for new var
    10851085  tmp[1] = "s";
    … …  
    17351735  L[1] = RL[1];
    17361736  L[4] = RL[4];  //char, minpoly
    1737   // check whether vars hava admissible names -> done earlier
     1737  // check whether vars have admissible names -> done earlier
    17381738  // now, create the names for new var
    17391739  tmp[1] = "s";
    … …  
    25182518  L[1] = RL[1];  //char
    25192519  L[4] = RL[4];  //char, minpoly
    2520   // check whether vars hava admissible names -> done earlier
     2520  // check whether vars have admissible names -> done earlier
    25212521  // now, create the names for new var
    25222522  for (j=1; j<=P; j++)
    … …  
    26492649  L[1] = RL[1];  //char
    26502650  L[4] = RL[4];  //char, minpoly
    2651   // check whether vars hava admissible names -> done earlier
     2651  // check whether vars have admissible names -> done earlier
    26522652  // now, create the names for new var
    26532653  for (j=1; j<=P; j++)
    … …  
    33213321  L[1] = RL[1];
    33223322  L[4] = RL[4];  // char, minpoly
    3323   // check whether vars hava admissible names -> done earlier
     3323  // check whether vars have admissible names -> done earlier
    33243324  // now, create the names for new var
    33253325  tmp[1] = "s";
    … …  
    35293529  L[1] = RL[1];
    35303530  L[4] = RL[4];  // char, minpoly
    3531   // check whether vars hava admissible names -> done earlier
     3531  // check whether vars have admissible names -> done earlier
    35323532  // now, create the names for new var
    35333533  tmp[1] = "s";
    … …  
    40454045  L[1] = RL[1];
    40464046  L[4] = RL[4];  // char, minpoly
    4047   // check whether vars hava admissible names -> done earlier
     4047  // check whether vars have admissible names -> done earlier
    40484048  // now, create the names for new var
    40494049  tmp[1] = "s";
    … …  
    42884288  L[1] = RL[1];
    42894289  L[4] = RL[4];  // char, minpoly
    4290   // check whether vars hava admissible names -> done earlier
     4290  // check whether vars have admissible names -> done earlier
    42914291  // now, create the names for new var
    42924292  tmp[1] = "s";
    … …  
    45134513  L[1] = RL[1];
    45144514  L[4] = RL[4];  // char, minpoly
    4515   // check whether vars hava admissible names -> done earlier
     4515  // check whether vars have admissible names -> done earlier
    45164516  // now, create the names for new var
    45174517  tmp[1] = "s";

  • Singular/LIB/dmodapp.lib

    r1891fd r20f2239  
    1717 F in R, it is proved that the localization of D/I with respect to the mult.
    1818 closed set of all powers of F is a holonomic D-module. Thus we aim to compute
    19  its cyclic representaion D/L for an ideal L in D. The procedures for the
     19 its cyclic representation D/L for an ideal L in D. The procedures for the
    2020 localization are DLoc, SDLoc and DLoc0.
    2121
    … …  
    375375  if (sl <> nrows(IV))
    376376  {
    377     ERROR("number of roots doesn't match number of multiplicites");
     377    ERROR("number of roots doesn't match number of multiplicities");
    378378  }
    379379  for(int i=1; i<=sl; i++)
    … …  
    14851485  L[1] = RL[1];
    14861486  L[4] = RL[4];  // char, minpoly
    1487   // check whether vars hava admissible names -> done earlier
     1487  // check whether vars have admissible names -> done earlier
    14881488  // now, create the names for new var
    14891489  tmp[1] = "s";

  • Singular/LIB/dmodideal.lib

    r1891fd r20f2239  
    272272          4 - elimination order for x and D, 'dp' in the parts
    273273              (used for the further work in the Bernstein-Sato ideal)
    274          n and r desribe the number of components x_i/Dx_i and s_j
     274         n and r describe the number of components x_i/Dx_i and s_j
    275275"
    276276{

  • Singular/LIB/dmodloc.lib

    r1891fd r20f2239  
    939939static proc orderedPartition(int n, list #)
    940940"
    941 USUAGE:  orderedPartition(n,a); n,a positive ints
     941USAGE:   orderedPartition(n,a); n,a positive ints
    942942         orderedPartition(n,w); n positive int, w positive intvec
    943943RETURN:  list of intvecs

  • Singular/LIB/dmodvar.lib

    r1891fd r20f2239  
    648648  dbprint(ppl-1,"// Computing in " + string(n+r) + "-th Weyl algebra:", D);
    649649  dbprint(ppl-1,"// The Malgrange ideal: ", IF);
    650   // step 2: compute the b-function of the Malgrange ideal w.r.t. approriate weights
     650  // step 2: compute the b-function of the Malgrange ideal w.r.t. appropriate weights
    651651  intvec w = 1:r;
    652652  w[r+n] = 0;

  • Singular/LIB/elim.lib

    r1891fd r20f2239  
    3939@*       such that B/bR is isomorphic to the blowup ring BC.
    4040PURPOSE: compute the projective blowup of the basering in the center C, the
    41          exceptional locus, the total and strict tranform of J,
     41         exceptional locus, the total and strict transform of J,
    4242         and the blowup map.
    4343         The projective blowup is a presentation of the blowup ring
    … …  
    108108   l[3][s+1] = l[3][s];         // save the module ordering of the basering
    109109   intvec w=1:k;
    110    intvec v;                    // containing the weights for the varibale
     110   intvec v;                    // containing the weights for the variable
    111111   if( homog(C) )
    112112   {
    … …  
    202202@*       The intvec L[2] is the intvec of variable weights (or the given w)
    203203         with weights <= 0 replaced by 1.
    204 PURPOSE: Prepare a ring for eliminating vars from an ideal/moduel by
     204PURPOSE: Prepare a ring for eliminating vars from an ideal/module by
    205205         computing a standard basis in R with a fast monomial ordering.
    206206         This procedure is used by the procedure elim.
    … …  
    296296  //Then, in case of an a-ordering (default), the new ring ordering will be
    297297  //of the form (a(1..1,0..0),dp) with r 1's and n-r 0's or (a(w1,0..0),wp(@w))
    298   //if there are varaible weights which are not 1.
     298  //if there are variable weights which are not 1.
    299299  //In the case of a b-ordering the ordering will be a block ordering with two
    300300  //blocks of the form (dp(r),dp(n-r))  resp. (wp(w1),dp(w2))
Note: See TracChangeset for help on using the changeset viewer.