
5.1.108 option
Syntax:
option ()
Type:
 string
Purpose:
 lists all defined options.
Syntax:
option ( option_name )
Type:
 none
Purpose:
 sets an option.
Note:
 To disable an option, use the prefix
no .
Syntax:
option ( get )
Type:
 intvec
Purpose:
 dumps the state of all options to an intvec.
Syntax:
option ( set, intvec_expression )
Type:
 none
Purpose:
 restores the state of all options from an intvec (produced by
option(get) ).
Values:
 The following options are used to manipulate the behavior of
computations and act like boolean switches. Use the prefix
no to
disable an option. Notice that some options are ring dependent and reset
to their default values on a change of the current basering.
none

turns off all options (including the
prompt option).
warn

be aware of pitfalls.
See option(warn).
returnSB

the functions
syz , intersect (2 arguments), quotient
return a standard base instead of a generating set if
returnSB is set. This option should not be used for lift .
fastHC

tries to find the highest corner of the staircase (HC) as fast as
possible during a standard basis computation (only used for local
orderings).
infRedTail

local normal form computations will not use the ecart
to avoid possibly infinite tail reductions: should only be used
with extreme care.
By default, it is only set in the case of a zerodimensional ideal.
intStrategy

avoids division of coefficients during standard basis
computations. This option is ring dependent. By default, it is set for
rings with characteristic 0 and not set for all other rings.
lazy

uses a more lazy approach in std computations,
which was used in SINGULAR version before 20
(and which may lead to faster or slower computations, depending on the example)
length

select shorter reducers in std computations,
notRegularity

disables the regularity bound for
res and mres (see
regularity).
notSugar

turns off sugar strategy during standard basis computation and reduction.
notBuckets

disables the bucket representation of polynomials during standard basis
computations. This option usually decreases the memory consumption but
increases the computation time. It should only be set for
memorycritical standard basis computations.
prot

shows protocol information indicating the
progress during the following computations:
facstd ,
fglm ,
groebner ,
intersect ,
lres ,
mres ,
minres ,
mstd ,
res ,
slimgb ,
sres ,
std ,
stdfglm ,
stdhilb ,
syz .
See below for more details.
qringNF

simplifies modulo the current
qring in all assignments.
redSB

computes a reduced standard basis in any standard basis computation
(in rings with global ior local orderings, See interred for the discussion
of reduced for local orderings))
redTail

reduction of the tails of polynomials during standard basis
computations. This option is ring dependent. By default, it is set for
rings with global degree orderings and not set for all other rings.
This option changes the reduction strategy and may decrease/increase time
and memory consumption  it does not ensure tail reduction on the result  use redSB for that.
redThrough

for inhomogenous input, polynomial reductions during standard basis
computations are never postponed, but always finished through. This option
is ring dependent. By default, it is set for rings with global degree
orderings and not set for all other rings.
This option changes the reduction strategy and may decrease/increase time
and memory consumption.
sugarCrit

uses criteria similar to the homogeneous case to keep more pairs which would be
excluded by other criteria but which may be useful for downstream computations.
This option changes the strategy for criteria and selection and may decrease/increase time
and memory consumption.
weightM

automatically computes suitable weights for the weighted ecart and the
weighted sugar method.
cancelunit

avoids to divide polynomials by nonconstant units in
std in the local case. Should usually not be used.
contentSB

avoids to divide by the content of a polynomial in
std and related
algorithms. Should usually not be used.
intersectElim

prefers elimination to compute intersections (experimental, will be removed in the next release).
Should usually not be used.
intersectSyz

prefers syzygy methods to compute intersections (experimental, will be removed in the next release).
Should usually not be used.
The following options, which also control computations, are special,
since they are not manipulated by the option command but by a
direct assignment of a value. Reset the option by assigning the value 0;
the command option(none) will not reset them! If there is a
nonzero value assigned, the command option() prints the option.
multBound
 a multiplicity bound is set (see multBound).
degBound
 a degree bound is set (see degBound).
The last set of options controls the output of SINGULAR:
Imap

shows the mapping of variables with the fetch and imap commands.
debugLib

warns about syntax errors when loading a library.
defRes

shows the names of the syzygy modules while converting
resolution to list
loadLib

shows loading of libraries (set by default).
loadProc

shows loading of procedures from libraries.
mem

shows memory usage in square brackets (see memory).
notWarnSB

do not warn about using a generating set instead of a standard basis.
prompt

shows prompt (
> , resp. . ) if ready for input (default).
reading

shows the number of characters read from a file.
redefine

warns about variable redefinitions (set by default).
usage

shows correct usage in error messages (set by default).
Example:
 option(prot);
option();
==> //options: prot redefine usage prompt
option(notSugar);
option();
==> //options: prot notSugar redefine usage prompt
option(noprot);
option();
==> //options: notSugar redefine usage prompt
option(none);
option();
==> //options: none
ring r=0,x,dp;
degBound=22;
option();
==> //options: degBound redTail redThrough intStrategy
intvec i=option(get);
option(none);
option(set,i);
option();
==> //options: degBound redTail redThrough intStrategy

The output reported on option(prot) has the following meaning:
 (command) 
(character)  (meaning)

 facstd 
F  found a new factor

   all other characters: like the output of std and reduce 
   
 fglm 
.  basis monomial found

  +  edge monomial found 
    border monomial found 
   
 groebner   all characters: like the output of std /slimgb 
   
 lres 
.  minimal syzygy found

  n  slanted degree, i.e., row of Betti matrix 
  (mn)  calculate in module n 
  g  pair found giving reductum and syzygy 
   
 mres 
[d]
 computations of the dth syzygy module

   all other characters: like the output of std 
   
 minres 
[d]
 minimizing of the dth syzygy module

   
 mstd   all characters: like the output of std 
   
 reduce 
r  reduced a leading term

  t  reduced a nonleading term 
 res 
[d]
 computations of the dth syzygy module

   all other characters: like the output of std 
   
 slimgb 
M[n,m]  parallel reduction of n elements with m nonzero output elements

  v  candidate for postponing, need to canonicalize 
  .  postponed a reduction of a pair/Spolynomial 
  b  exchange of a reductor by a 'better' one 
  e  a new reductor with nonminimal leading term 
  r  redTail reduction 
  n  no redTail reduction 
  B  resort pairs 
  C  slimgb_alg::cleanDegs 
  (n)  n critical pairs are still to be reduced 
  d  the maximal degree of the leading terms is currently d 
   
 sres 
.  syzygy found

  (n)  n elements remaining 
  [n]  finished module n 
   
 std 
[m:n]
 internal ring change to polynomial representation with exponent bound
m and n words in exponent vector

  s  found a new element of the standard basis 
    reduced a pair/Spolynomial to 0 
  .  postponed a reduction of a pair/Spolynomial 
  h  used Hilbert series criterion 
  H(d)  found a 'highest corner' of degree d, no need to consider higher degrees 
  (n)  n critical pairs are still to be reduced 
  (S:n)  doing complete reduction of n elements 
  d  the degree of the leading terms is currently d 
   
 stdfglm   all characters in first part: like the output of std 
   all characters in second part: like the output of fglm 
   
 stdhilb   all characters: like the output of std 
   
 syz   all characters: like the output of std 
See
degBound;
multBound;
std.
