Home Online Manual
Top
Back: open
Forward: ord
FastBack: Functions and system variables
FastForward: Control structures
Up: Functions
Top: Singular Manual
Contents: Table of Contents
Index: Index
About: About this document

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 zero-dimensional 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 2-0 (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 memory-critical 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 non-constant 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 non-zero 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 d-th syzygy module
all other characters: like the output of std
minres [d] minimizing of the d-th syzygy module
mstd all characters: like the output of std
reduce r reduced a leading term
t reduced a non-leading term
res [d] computations of the d-th syzygy module
all other characters: like the output of std
slimgb M[n,m] parallel reduction of n elements with m non-zero output elements
v candidate for postponing, need to canonicalize
. postponed a reduction of a pair/S-polynomial
b exchange of a reductor by a 'better' one
e a new reductor with non-minimal 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/S-polynomial to 0
. postponed a reduction of a pair/S-polynomial
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.