### 5.1.105 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
|  | `.` | 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
|  | `(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.

User manual for Singular version 4-0-3, 2016, generated by texi2html.