### 5.1.151 std

`Syntax:`
  `std (` ideal_expression`)`
  `std (` module_expression`)`
  `std (` smatrix_expression`)`
  `std (` ideal_expression`,` bigintvec_expression `)`
  `std (` module_expression`,` bigintvec_expression `)`
  `std (` ideal_expression`,` bigintvec_expression`,` intvec_expression `)`
  `std (` module_expression`,` bigintvec_expression`,` intvec_expression `)`
  `std (` ideal_expression`,` poly_expression `)`
  `std (` module_expression`,` vector_expression `)`
  `std (` ideal_expression`,` ideal_expression `)`
  `std (` module_expression`,` module_expression `)`
  `std (` ideal_expression`,` poly_expression`,` intvec_expression`,` intvec_expression `)`
  `std (` module_expression`,` poly_expression`,` intvec_expression`,` intvec_expression `)`
`Type:`
  ideal, module or smatrix
`Purpose:`
  returns a standard basis of an ideal or module with respect to the monomial ordering of the basering. For Letterplace rings, a twosided Groebner basis is computed. A standard basis is a set of generators such that the leading terms generate the leading ideal, resp. module.
  Use an optional second argument of type bigintvec as Hilbert series (result of `hilb(i,1)`, see hilb), if the ideal, resp. module, is homogeneous (Hilbert driven standard basis computation, stdhilb). If the ideal is quasihomogeneous with some weights w and if the Hilbert series is computed w.r.t. to these weights, then use w as third argument.
  Use an optional second argument of type poly/vector/ideal, resp. module, to construct the standard basis from an already computed one (given as the first argument) and additional generator(s) (the second argument).
  4 arguments `G,p,hv,w` are the combination of the above: standard basis `G`, additional generator `p`, hilbert function `hv` w.r.t. weights `w`.

`Warning:`
  Groebner basis computations with inexact coefficients can not be trusted due to rounding errors.
`Note:`
  The standard basis is computed with a (more or less) straight-forward implementation of the classical Buchberger (resp. Mora) algorithm. For global orderings, use the `groebner` command instead (see groebner), which heuristically chooses the "best" algorithm to compute a Groebner basis.
  To view the progress of long running computations, use `option(prot)` (see option(prot)).

`Note:`
  For standard basis computations of 0-dim ideals in local rings and characteristic 0, we recommend std with ordering ds (or Ds), due to the implementation of the new algorithm described in ‘Using Semicontinuity for Standard Bases Computations’ (arXiv:2108.09735), as of Singular 4.4.0 (Sept 2024).
  The new algorithm can be switched off by `option(pure_gb);`. See option.

`Note:`
  Uses a hilbert driven Groebner algorithm in the case of a block ordering and ideal over `QQ`.
  The new algorithm can be switched off by `option(pure_gb);`. See option.

`Example:`

        // local computation
        ring r=32003,(x,y,z),ds;
        poly s1=1x2y+151xyz10+169y21;
        poly s2=1xz14+6x2y4+3z24;
        poly s3=5y10z10x+2y20z10+y10z20+11x3;
        ideal i=s1,s2,s3;
        ideal j=std(i);
        degree(j);
      ==> // dimension (local)   = 0
      ==> // multiplicity = 1512
        // Hilbert driven elimination (standard)
        ring rhom=32003,(x,y,z,h),dp;
        ideal i=homog(imap(r,i),h);
        ideal j=std(i);
        bigintvec iv=hilb(j,1);
        ring rlex=32003,(x,y,z,h),lp;
        ideal i=fetch(rhom,i);
        ideal j=std(i,iv);
        j=subst(j,h,1);
        j[1];
      ==> z64
        // Hilbert driven elimination (ideal is quasihomogeneous)
        intvec w=10,1,1;
        ring whom=32003,(x,y,z),wp(w);
        ideal i=fetch(r,i);
        ideal j=std(i);
        bigintvec iw=hilb(j,1,w);
        ring wlex=32003,(x,y,z),lp;
        ideal i=fetch(whom,i);
        ideal j=std(i,iw,w);
        j[1];
      ==> z64

See facstd; fglm; groebner; ideal; module; mstd; option; ring; smatrix; stdfglm; stdhilb.

User manual for Singular version 4.4.1, 2025, generated by texi2html.