|
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.
|