| 1 |
NIL |
| 2 |
NIL is the Lisp general 'null entity', interpreted as 'the |
| 3 |
empty list', or as 'false', when Lisp expressions are |
| 4 |
considered as boolean expressions. Often used to stand for a |
| 5 |
'null object' in Lisp programming. |
| 6 |
^LNIL Updated 2004-05-02:^L |
| 7 |
mode |
| 8 |
Bergman operates under certain assumptions on the mathematical |
| 9 |
objects, input and output behaviour, and preferred algorithmic |
| 10 |
behaviour. These may be changed by the user, by modifying the |
| 11 |
corresponding 'modes'. The totality of all mode settings is |
| 12 |
called the 'setup'. |
| 13 |
You may inspect the mode setup by the procedure call |
| 14 |
(PRINTSETUP), or get a lisp list representation of it as the |
| 15 |
return value of (GETSETUP). Many modes may be set at once by |
| 16 |
means of the procedure SETSETUP, which should be given a lisp |
| 17 |
list similar to those returned by (GETSETUP) as argument. |
| 18 |
Alternatively, you could use a specific mode setting procedure |
| 19 |
for changing just one mode. |
| 20 |
Note that the bergman mode concept is rather general. E. g., |
| 21 |
a specification of a list of input variables (specifying the |
| 22 |
polynomial ring) is considered as a mode setting. |
| 23 |
You may get a survey of the modes and of the corresponding |
| 24 |
mode setting procedures at [allmodes]. |
| 25 |
^LNIL Updated 2005-02-04:^L |
| 26 |
allmodes |
| 27 |
Here is a list (hopefully complete) of all modes, with submodes |
| 28 |
and mode changing procedures; except the submodes to the |
| 29 |
resolution mode ANICK. |
| 30 |
|
| 31 |
Object type: |
| 32 |
Ring (default) SETRINGOBJECT() |
| 33 |
Module SETMODULEOBJECT() |
| 34 |
Two modules (for calculating Tor(*,*)) SETTWOMODULESOBJECT() |
| 35 |
Factor Algebra ( = Residue class ring) SETFACTALGOBJECT() |
| 36 |
Minor variants: |
| 37 |
Right, Left, 2-sided module? |
| 38 |
Autoadding of relations? SETAUTOADDRELATIONSTATE(state) |
| 39 |
Yes! AUTOADDRELATIONS() |
| 40 |
No, absolutely not! NOAUTOADDRELATIONS() |
| 41 |
Perhaps, but not right now! CANCELAUTOADDRELATIONSSETTINGS() |
| 42 |
Permit linear or constant terms? LOWTERMSHANDLING(state) |
| 43 |
Yes! state := SAFE |
| 44 |
No, since using fast tricks state := QUICK |
| 45 |
|
| 46 |
Resolution calculations type: |
| 47 |
None (default) SETRESOLUTIONTYPE(NIL) |
| 48 |
Anick SETRESOLUTIONTYPE(ANICK) |
| 49 |
|
| 50 |
Anick minor modes (only present when the module anick is loaded): |
| 51 |
In what form is tenspols (Anick resolution elements) printed? |
| 52 |
Semidistributed PRINTTENSORPOLSSEMIDISTRIBUTED() |
| 53 |
(Fully) distributed PRINTTENSORPOLSDISTRIBUTED() |
| 54 |
The beginning, tensor sign, and end of a tensor product term: |
| 55 |
SETTENSPOLPRTSTRINGS(string,string,string) |
| 56 |
The chain link demarkation string SETEDGESTRING(string) |
| 57 |
Should this string be printed? SETEDGESTRINGPRINTING(boole) |
| 58 |
Should the Betti numbers of the homology be calculated at each degree end? |
| 59 |
Yes, and immediately displayed! ONFLYBETTI(T) |
| 60 |
Yes, but not automatically displayed CALCBETTI(T) + ONFLYBETTI(NIL) |
| 61 |
No CALCBETTI(NIL) |
| 62 |
|
| 63 |
Polynomial ring (or correspondingly for other objects) set-up: |
| 64 |
Type of ring (or correpondingly); SETRINGTYPE(),COMMIFY(), |
| 65 |
NONCOMMIFY() |
| 66 |
Commutative DEG-REVLEX (default); COMMIFY(),DEGREVLEXIFY() |
| 67 |
Commutative DEG-LEX; - " - ,DEGLEXIFY() |
| 68 |
Non-commutative DEG-LEFTLEX (default); NONCOMMIFY(),DEGLEFTLEXIFY() |
| 69 |
Non-commutative ELIM-DEG-LEFTLEX NONCOMMIFY(),ELIMORDER() |
| 70 |
Minor variants: |
| 71 |
Ordinary ( = unit) weights CLEARWEIGHTS(),SETWEIGHTS() |
| 72 |
Alternative weights SETWEIGHTS() |
| 73 |
Homogenising variable: SETHOMOGVARIABLE() |
| 74 |
|
| 75 |
Coefficient arithmetics: |
| 76 |
Characteristic 0, arbitrary integers (default); SETMODULUS(0) |
| 77 |
Characteristic 0, only inums; NOBIGNUMS, - " - |
| 78 |
Characteristic 2; SETMODULUS(2) |
| 79 |
Odd characteristic, ordinary inum arithmetics; SETMODULUS(pr) |
| 80 |
Odd characteristic, ordinary bignum arithmetics; - " - |
| 81 |
Odd characteristic, logarithm table inum arithmetics; - " -, |
| 82 |
MODLOGARITHMS |
| 83 |
(Arbitrary Reduce Standard Forms; SETREDUCESFCOEFFS() |
| 84 |
only available in bergman-under-reduce) |
| 85 |
|
| 86 |
Fundamental strategy: SETSTRATEGY(clause) |
| 87 |
Default, ordinary (Buchberger, Bergman) (with degree first) |
| 88 |
SETDEFAULTSTRATEGY() |
| 89 |
Rabbit (jumping back to lower degrees) SETRABBITSTRATEGY() |
| 90 |
Staggered with substance (SAWS). SETSAWSSTRATEGY() |
| 91 |
Ordinary (Buchberger, Bergman) (with degree first) (default); |
| 92 |
Minor variants: |
| 93 |
with immediate full autoreduction (default); |
| 94 |
IMMEDIATEFULLREDUCTION |
| 95 |
without immediate full autoreduction; - " - |
| 96 |
Staggered with substance (SAWS). Various. |
| 97 |
Densely or sparsely performed factoring out of contents: |
| 98 |
DENSECONTENTS(), |
| 99 |
SPARSECONTENTS() |
| 100 |
Ordinary or Hilbert series limit interruption strategy: |
| 101 |
ORDNGBESTRATEGY(), |
| 102 |
MINHILBLIMITSTRATEGY() |
| 103 |
(or use SETINTERRUPTSTRATEGY) |
| 104 |
Calculation start and end points: SETMINDEG(), |
| 105 |
GETMINDEG(), |
| 106 |
SETMAXDEG(), |
| 107 |
GETMAXDEG(). |
| 108 |
|
| 109 |
Input mode minor modification: |
| 110 |
(No) case sensitivity in algebraic input SETCASESENSALGIN (NIL/T) |
| 111 |
|
| 112 |
Output mode: |
| 113 |
Lisp form (default): SETALGOUTMODE(LISP) |
| 114 |
Ordinary algebraic form: SETALGOUTMODE(ALG) |
| 115 |
Macaulay-like algebraic form: SETALGOUTMODE(MACAULAY) |
| 116 |
|
| 117 |
Minor mode modifications: |
| 118 |
Collect common factors to exponents (default): |
| 119 |
EXPTSPRINTMODE() |
| 120 |
Print each factor separately: NOEXPTSPRINTMODE() |
| 121 |
|
| 122 |
If the associated monomial ring Poincare-Betti series is calculated |
| 123 |
degree by degree, should it be printed automatically or not: |
| 124 |
SETIMMEDIATEASSOCRINGPBDISPLAY (NIL/T) |
| 125 |
|
| 126 |
Mode influencing user available switches - hopefully a |
| 127 |
complete list, except for ANICK switches. |
| 128 |
(However, note that we plan to replace them by mode changers!) |
| 129 |
|
| 130 |
CUSTSHOW, CUSTSTRATEGY, DEGREEPRINTOUTPUT, DYNAMICLOGTABLES, |
| 131 |
HOMOGENISED, IMMEDIATECRIT, IMMEDIATEFULLREDUCTION, |
| 132 |
IMMEDIATERECDEFINE, NOBIGNUM, OBSOLETENAMESINFORM, |
| 133 |
OLDPRINTMODES1, OLDSERIESMODES1, PBSERIES, REDUCTIVITY, |
| 134 |
SAVEDEGREE, SAVERECVALUES, STANDARDANICKMODES. |
| 135 |
^LNIL Updated 2004-04-17:^L |
| 136 |
object |
| 137 |
An object is one or more mathematical structures, for |
| 138 |
which bergman is performing calculations. Presently, |
| 139 |
the choices are: |
| 140 |
Ring, module, two modules [twomodules], or factor algebra |
| 141 |
[factoralgebra]. |
| 142 |
Investigating a (two-sided) ideal in a polynomial ring is |
| 143 |
regarded as investigating the residue class factor algebra, |
| 144 |
and thus headed under "ring". |
| 145 |
^L |
| 146 |
NIL |
| 147 |
type: |
| 148 |
Ring (default) SETRINGOBJECT() |
| 149 |
Module SETMODULEOBJECT() |
| 150 |
Two modules (for calculating Tor(*,*)) SETTWOMODULESOBJECT() |
| 151 |
Factor Algebra ( = Residue class ring) SETFACTALGOBJECT() |
| 152 |
Minor variants: |
| 153 |
Right, Left, 2-sided module? |
| 154 |
Autoadding of relations? SETAUTOADDRELATIONSTATE(state) |
| 155 |
Yes! AUTOADDRELATIONS() |
| 156 |
No, absolutely not! NOAUTOADDRELATIONS() |
| 157 |
Perhaps, but not right now! CANCELAUTOADDRELATIONSSETTINGS() |
| 158 |
Permit linear or constant terms? LOWTERMSHANDLING(state) |
| 159 |
Yes! state := SAFE |
| 160 |
No, since using fast tricks state := QUICK |
| 161 |
|
| 162 |
Resolution calculations type: |
| 163 |
None (default) SETRESOLUTIONTYPE(NIL) |
| 164 |
Anick SETRESOLUTIONTYPE(ANICK) |
| 165 |
|
| 166 |
Anick minor modes (only present when the module anick is loaded): |
| 167 |
In what form is tenspols (Anick resolution elements) printed? |
| 168 |
Semidistributed PRINTTENSORPOLSSEMIDISTRIBUTED() |
| 169 |
(Fully) distributed PRINTTENSORPOLSDISTRIBUTED() |
| 170 |
The beginning, tensor sign, and end of a tensor product term: |
| 171 |
SETTENSPOLPRTSTRINGS(string,string,string) |
| 172 |
The chain link demarkation string SETEDGESTRING(string) |
| 173 |
Should this string be printed? SETEDGESTRINGPRINTING(boole) |
| 174 |
Should the Betti numbers of the homology be calculated at each degree end? |
| 175 |
Yes, and immediately displayed! ONFLYBETTI(T) |
| 176 |
Yes, but not automatically displayed CALCBETTI(T) + ONFLYBETTI(NIL) |
| 177 |
No CALCBETTI(NIL) |
| 178 |
|
| 179 |
Polynomial ring (or correspondingly for other objects) set-up: |
| 180 |
Type of ring (or correpondingly); SETRINGTYPE(),COMMIFY(), |
| 181 |
NONCOMMIFY() |
| 182 |
Commutative DEG-REVLEX (default); COMMIFY(),DEGREVLEXIFY() |
| 183 |
Commutative DEG-LEX; - " - ,DEGLEXIFY() |
| 184 |
Non-commutative DEG-LEFTLEX (default); NONCOMMIFY(),DEGLEFTLEXIFY() |
| 185 |
Non-commutative ELIM-DEG-LEFTLEX NONCOMMIFY(),ELIMORDER() |
| 186 |
Minor variants: |
| 187 |
Ordinary ( = unit) weights CLEARWEIGHTS(),SETWEIGHTS() |
| 188 |
Alternative weights SETWEIGHTS() |
| 189 |
Homogenising variable: SETHOMOGVARIABLE() |
| 190 |
|
| 191 |
Coefficient arithmetics: |
| 192 |
Characteristic 0, arbitrary integers (default); SETMODULUS(0) |
| 193 |
Characteristic 0, only inums; NOBIGNUMS, - " - |
| 194 |
Characteristic 2; SETMODULUS(2) |
| 195 |
Odd characteristic, ordinary inum arithmetics; SETMODULUS(pr) |
| 196 |
Odd characteristic, ordinary bignum arithmetics; - " - |
| 197 |
Odd characteristic, logarithm table inum arithmetics; - " -, |
| 198 |
MODLOGARITHMS |
| 199 |
(Arbitrary Reduce Standard Forms; SETREDUCESFCOEFFS() |
| 200 |
only available in bergman-under-reduce) |
| 201 |
|
| 202 |
Fundamental strategy: SETSTRATEGY(clause) |
| 203 |
Default, ordinary (Buchberger, Bergman) (with degree first) |
| 204 |
SETDEFAULTSTRATEGY() |
| 205 |
Rabbit (jumping back to lower degrees) SETRABBITSTRATEGY() |
| 206 |
Staggered with substance (SAWS). SETSAWSSTRATEGY() |
| 207 |
Minor variants: |
| 208 |
with immediate full autoreduction (default); |
| 209 |
IMMEDIATEFULLREDUCTION |
| 210 |
without immediate full autoreduction; - " - |
| 211 |
Densely or sparsely performed factoring out of contents: |
| 212 |
DENSECONTENTS(), |
| 213 |
SPARSECONTENTS() |
| 214 |
Ordinary or Hilbert series limit interruption strategy: |
| 215 |
ORDNGBESTRATEGY(), |
| 216 |
MINHILBLIMITSTRATEGY() |
| 217 |
(or use SETINTERRUPTSTRATEGY) |
| 218 |
Calculation start and end points: SETMINDEG(), |
| 219 |
GETMINDEG(), |
| 220 |
SETMAXDEG(), |
| 221 |
GETMAXDEG(). |
| 222 |
|
| 223 |
Input mode minor modification: |
| 224 |
(No) case sensitivity in algebraic input SETCASESENSALGIN (NIL/T) |
| 225 |
|
| 226 |
Output mode: |
| 227 |
Lisp form (default): SETALGOUTMODE(LISP) |
| 228 |
Ordinary algebraic form: SETALGOUTMODE(ALG) |
| 229 |
Macaulay-like algebraic form: SETALGOUTMODE(MACAULAY) |
| 230 |
|
| 231 |
Minor mode modifications: |
| 232 |
Collect common factors to exponents (default): |
| 233 |
EXPTSPRINTMODE() |
| 234 |
Print each factor separately: NOEXPTSPRINTMODE() |
| 235 |
|
| 236 |
If the associated monomial ring Poincare-Betti series is calculated |
| 237 |
degree by degree, should it be printed automatically or not: |
| 238 |
SETIMMEDIATEASSOCRINGPBDISPLAY (NIL/T) |
| 239 |
|
| 240 |
|
| 241 |
MODES DESCRIPTION |
| 242 |
The following modes are used in anick module to configure printings |
| 243 |
and calculations: |
| 244 |
|
| 245 |
Keyword Description |
| 246 |
------------------------------------------------------------------- |
| 247 |
TENSPOL!-PRINTMODE Either DISTRIBUTED or SEMIDISTRIBUTED |
| 248 |
keyword, meaning the mode for printing |
| 249 |
tensor polynomials. |
| 250 |
|
| 251 |
TENSTERM!-PRINTMODE A list of three strings which are beginning, |
| 252 |
middle, and ending in printing of tensor |
| 253 |
term. |
| 254 |
EDGE!-STRING Equals a string which is printed between |
| 255 |
edges while chain is printed. |
| 256 |
|
| 257 |
EDGE!-STRING!-PRINTING Bolean, meaning whether to use EDGE!-STRING |
| 258 |
in chain printings |
| 259 |
|
| 260 |
BETTI True, when Betti numbers are to be calculated |
| 261 |
BETTI-FOREACHDEGREE True, when Betti numbers are allowed to |
| 262 |
be calculated and they are updated every |
| 263 |
time the Groebner basis element is found. |
| 264 |
------------------------------------------------------------------- |
| 265 |
|
| 266 |
^LNIL Updated 2004-04-24^L |
| 267 |
coefficients |
| 268 |
There are two fundamental mathematical concepts for the polynomials, |
| 269 |
the coefficient field and the coefficient domain. We always assume |
| 270 |
that the polynomial base ring is a (commutative) field. The |
| 271 |
coefficient domain may consist of the entire field, or of a proper |
| 272 |
subring such that the coefficient field is its field of fractions. |
| 273 |
In either case, the normal forms of S-polynomials are only assumed |
| 274 |
to be used for testing whether or not they are zero, and as reductor |
| 275 |
polynomials; thus they may be replaced with associated polynomials; |
| 276 |
and indeed, ordinarily they are. Therefore it is sufficient to use |
| 277 |
coefficient domain elements in the calculation of such normal forms. |
| 278 |
|
| 279 |
On the other hand, if you really need the normal form of a |
| 280 |
polynomial, then there may appear denominators. Therefore we added |
| 281 |
'ratio' (or rate) coefficients and polynomials with a ratio |
| 282 |
coefficient factor as structures, but use them only in connection |
| 283 |
with such 'absolute' normal forms. |
| 284 |
|
| 285 |
A principal example is the default case, where the coefficient field |
| 286 |
(Q) consists of the rational numbers, and the coefficient domain (Z) |
| 287 |
of the integers. The 'ratio coefficients' are just the (non-zero) |
| 288 |
rational numbers. (Recall that here 'rational' refers to the 'ratio' |
| 289 |
or proportion of two integers; which we consider as their quotient.) |
| 290 |
|
| 291 |
Input, LispForm, Output coefficients are either integers or |
| 292 |
Reduce standard forms (as yet). |
| 293 |
|
| 294 |
|
| 295 |
There are two internal representations of (non-zero) domain elements: |
| 296 |
redandcoeffs (reductand coefficients) and redorcoeffs (reductor |
| 297 |
coefficients). (See [polynomials] for an explanation of the difference.) |
| 298 |
|
| 299 |
Redandcoeffs represent non-zero coefficients in reductand polynomials. |
| 300 |
|
| 301 |
Redorcoeffs represent non-zero coefficients in reductor polynomials. |
| 302 |
|
| 303 |
Ratcoeffs ('ratio' coefficients) represent non-zero quotients of |
| 304 |
coefficient domain elements. A ratcoeff has a numerator and a |
| 305 |
denominator part; they are redandcoeffs. |
| 306 |
^LNIL Updated 2004-04-24^L |
| 307 |
setmodulus |
| 308 |
SETMODULUS (name:field-descriptor) : field-descriptor ; !! HAS CHANGED; DOCUMENT THIS !! |
| 309 |
name should be some way to denote what to use for the new |
| 310 |
coefficient field. Legal values right now are: NIl or |
| 311 |
0 (denoting the field Q of rational numbers); and a |
| 312 |
prime p (denoting the Galois field with p elements). |
| 313 |
If bergman is running under Reduce, the identifier SF |
| 314 |
also is a legal value; denoting that Reduce "Standard |
| 315 |
Forms" be considered as representing the coefficient |
| 316 |
domain elements. (The correctness of the input need not be |
| 317 |
checked. Likewise, if the SF alternative is used, there need |
| 318 |
not be a check of the Reduce set-up.) The coefficient field |
| 319 |
is set to name. If name is an odd prime, then the field may |
| 320 |
or may not be of `logarithmic' type, depending on whether |
| 321 |
the switch MODLOGARITHMS was on or off. |
| 322 |
^LNIL Updated 2004-04-24^L |
| 323 |
setmodulus2 |
| 324 |
SETMODULUS2 : - ; |
| 325 |
The same effects as with (SETMODULUS 2). |
| 326 |
^LNIL Updated 2004-04-24^L |
| 327 |
restorechar0 |
| 328 |
RESTORECHAR0 : - ; |
| 329 |
The same effects as with (SETMODULUS 0). |
| 330 |
^LNIL Updated 2004-04-24^L |
| 331 |
setreducesfcoeffs |
| 332 |
SETREDUCESFCOEFFS ( ) : - ; |
| 333 |
The same effects as with (SETMODULUS SF). |
| 334 |
(Only active for bergman under Reduce.) |
| 335 |
^LNIL Updated 2004-04-24^L |
| 336 |
getmodulus |
| 337 |
GETMODULUS ( ) : field-descriptor ; |
| 338 |
Returns the characteristic of the coefficient field, or SF |
| 339 |
if the coefficients are standard forms. (Characteristic 0 |
| 340 |
may be represented by NIL.) |
| 341 |
^LNIL Updated 2004-04-24^L |
| 342 |
densecontents |
| 343 |
DENSECONTENTS ( ) : - ; |
| 344 |
In coefficient modes where the coefficient domain differs |
| 345 |
from the coefficient field, search for the content of a |
| 346 |
polynomial (and factor out this content if it is non unit) |
| 347 |
rather often. |
| 348 |
Not only may affect the current coefficient mode, but |
| 349 |
also any coefficient mode with domain different from field |
| 350 |
which is set later in this bergman session. |
| 351 |
^LNIL Updated 2004-04-24^L |
| 352 |
sparsecontents |
| 353 |
SPARSECONTENTS ( ) : - ; |
| 354 |
In coefficient modes where the coefficient domain differs |
| 355 |
from the coefficient field, search for the content of a |
| 356 |
polynomial (and factor out this content if it is non unit) |
| 357 |
rather seldom. |
| 358 |
Not only may affect the current coefficient mode, but |
| 359 |
also any coefficient mode with domain different from field |
| 360 |
which is set later in this bergman session. |
| 361 |
^LNIL |
| 362 |
Coefficient domain dependent (all of whom may be RESET): |
| 363 |
|
| 364 |
REDANDCF!+ (Cf1:redandcoeff, Cf2:redandcoeff) : redandcoeff ; |
| 365 |
REDANDCF!- (Cf1:redandcoeff) : redandcoeff ; |
| 366 |
REDANDCF!-!- (Cf1:redandcoeff, Cf2:redandcoeff) : redandcoeff ; |
| 367 |
REDANDCF!* (Cf1:redandcoeff, Cf2:redandcoeff) : redandcoeff ; |
| 368 |
REDANDCF!/ (Cf1:redandcoeff, Cf2:redandcoeff) : redandcoeff ; |
| 369 |
REDANDCFREMAINDER (Cf1:redandcoeff, Cf2:redandcoeff) : redandcoeff ; |
| 370 |
REDANDCFDIVISION (Cf1:redandcoeff, Cf2:redandcoeff) : dpredandcoeff ; |
| 371 |
Perform the operations addition, negation ( = "unary minus"), |
| 372 |
subtraction, multiplication, truncated division, taking of |
| 373 |
remainder with respect to truncated division, and lastly |
| 374 |
performing both these operations at once, yielding an output |
| 375 |
(Cf3 . Cf4) (where Cf3 is the resulting truncated quotient and |
| 376 |
Cf4 the remainder). As always, NIL represents zero in the output. |
| 377 |
Zero input is not permitted. |
| 378 |
The 'truncated division' and 'taking remainder' operations should |
| 379 |
be compatible in the sense that |
| 380 |
Cf1 = Cf2 * Cf3 + Cf4, |
| 381 |
and the division should be exact (whence the remainder should |
| 382 |
be zero) whenever possible. |
| 383 |
^LNIL Updated 2004-04-24^L |
| 384 |
redandcfnegative |
| 385 |
REDANDCFNEGATIVE (Cf:redandcoeff) : boolean ; |
| 386 |
Returns T if there is a meaningful concept of "negativity" in the |
| 387 |
coefficient domain and Cf is negative; NIL else. |
| 388 |
^LNIL |
| 389 |
RATCF2NUMERATOR (Cf:ratcoeff) : redandcoeff ; |
| 390 |
RATCF2DENOMINATOR (Cf:ratcoeff) : redandcoeff ; |
| 391 |
REDANDCF2RATCF (Cf:redandcoeff) : ratcoeff ; |
| 392 |
REDANDCFS2RATCF (Cf1:redandcoeff, Cf2:redandcoeff) : ratcoeff ; |
| 393 |
Converters between ratcoeffs and redandcoeffs. The first two |
| 394 |
return the numerator and denominator parts of their argument. |
| 395 |
REDANDCFS2RATCF constructs and returns a ratcoeff corresponding |
| 396 |
to the quotient of the coefficient domain elements represented |
| 397 |
by the arguments. REDANDCF2RATCF constructs and returns a |
| 398 |
ratcoeff representing the same element as does its argument. |
| 399 |
The procedures in general are NOT reversible: e.g., |
| 400 |
RATCF2NUMERATOR (REDANDS2RATCF (Cf1,Cf2)) need not represent the |
| 401 |
same element as Cf1 does. |
| 402 |
^LNIL Updated 2004-04-24^L |
| 403 |
ratcf |
| 404 |
RATCF!- (Cf:ratcoeff) : ratcoeff ; |
| 405 |
Perform negation ( = unary minus). |
| 406 |
^LNIL Updated 2004-04-24^L |
| 407 |
shortenratcf |
| 408 |
SHORTENRATCF (Cf:ratcoeff) : ratcoeff ; DESTRUCTIVE |
| 409 |
Changes Cf to a "simple" representative for the same coefficient |
| 410 |
field element, and returns this changed input. (Thus destructive.) |
| 411 |
If the coefficient domain comprises an algorithm for calculating greatest |
| 412 |
common divisors, the "simple" representative may be achieved by factoring |
| 413 |
out the GCD of the numerator and the denominator parts from both. |
| 414 |
^LNIL Updated 2004-04-24^L |
| 415 |
integerise |
| 416 |
INTEGERISE (Line:lgenratcoeff) : ratcoeff ; DESTRUCTIVE |
| 417 |
Each (non-NIL) ratcoeff in Line is replaced by a redandcoeff, |
| 418 |
representing some c times the element which the ratcoeff |
| 419 |
represents, using the same c for the whole list. Returns c. |
| 420 |
(Should not be called if Line does not contain some non-NIL |
| 421 |
entry.?) |
| 422 |
^LNIL Updated 2004-04-24^L |
| 423 |
cfmonredandmult |
| 424 |
CFMONREDANDMULT (Cf:redandcoeff, Mon:puremon, Pol:augredand) : augredand ; |
| 425 |
augredand := Cf*Mon*Pol (non-destructively and in this order). |
| 426 |
^LNIL Updated 2004-04-24^L |
| 427 |
redandcoeffone |
| 428 |
A global variable. The reductand representation of the unit in the |
| 429 |
coefficient domain. |
| 430 |
^LNIL Updated 2004-04-24^L |
| 431 |
monomial |
| 432 |
In bergman, "monomial" always refers to "monic" (coefficient free) |
| 433 |
monomials. |
| 434 |
|
| 435 |
LispForm monomials are lists of exponents / of variable indices |
| 436 |
in the commutative / non-commutative case. |
| 437 |
|
| 438 |
Internally, there are two representations, puremons ("pure monomials") |
| 439 |
and augmons ("augmented monomials", which hold some extra information). |
| 440 |
This rarely should concern the ordinary user; except that the augmons |
| 441 |
normally are non-printable objects. If you create an augmon, e.g. by |
| 442 |
means of [MONINTERN], then this should not be done in such a manner |
| 443 |
that an automatic attempt to print it results. |
| 444 |
|
| 445 |
The augmons have a unique representation property: They are different |
| 446 |
as lisp object if and only if they represent different mathematical |
| 447 |
objects. This may be tested by means of the lisp procedure EQ. |
| 448 |
^LNIL Updated 2004-04-24^L |
| 449 |
monintern |
| 450 |
MONINTERN (lispform_monomial) : augmon ; |
| 451 |
Returns the unique augmon ('augmented [monomial]') representing the |
| 452 |
same mathematical object as does the input lisp form monomial. |
| 453 |
|
| 454 |
WARNING: Augmons in general are unprintable lisp objects. If you |
| 455 |
call MONLISP at lisp top level, or in some subordinate read-eval-print |
| 456 |
loop, then lisp may try to print the output, resulting in a chrash. |
| 457 |
^LNIL Updated 2004-04-24^L |
| 458 |
monlispout |
| 459 |
MONLISPOUT (puremon) : lispform_monomial ; |
| 460 |
Returns the Lispform monomial representing the same mathematical object |
| 461 |
as does the input puremon ('pure [monomial']). |
| 462 |
^LNIL Updated 2004-04-24^L |
| 463 |
monlessp |
| 464 |
MONLESSP (Mon1:puremon, Mon2:puremon) : bool ; |
| 465 |
Undefined (possibly erroneous) if Mon1 and Mon2 represent the |
| 466 |
same monomial or are of different total-degrees. Else, non-NIL |
| 467 |
iff Mon1 is less than Mon2 with respect to the active monoid order. |
| 468 |
^LNIL Updated 2004-04-24^L |
| 469 |
montimes2 |
| 470 |
MONTIMES2 (Mon1:puremon, Mon2:puremon) : augmon ; |
| 471 |
The output represents the product Mon1 * Mon2 (in the given order). |
| 472 |
NOTE: In the non-commutative case, this is mostly NOT what we need. |
| 473 |
^LNIL Updated 2004-04-24^L |
| 474 |
monfactorp |
| 475 |
MONFACTORP (Mon1:puremon, Mon2:puremon) : mon_factor_data ; |
| 476 |
Decides whether or not the first puremon ('pure [monomial]') is a |
| 477 |
factor of the second one. In the latter case, the output is non-nil, |
| 478 |
and may contain enough information for deciding in what manner the |
| 479 |
first one is a factor in the second. (In the non-commutative, there |
| 480 |
indeed may be several such ways.) |
| 481 |
^LNIL Updated 2004-04-24^L |
| 482 |
totaldegree |
| 483 |
TOTALDEGREE (Mon:puremon) : degree ; |
| 484 |
Returns the total degree of the puremon ('pure [monomial]'), calculated |
| 485 |
with respect to the setting of [weights]. |
| 486 |
^LNIL Updated 2004-04-24^L |
| 487 |
redandmonmult |
| 488 |
REDANDMONMULT (Pol:augredand, Mon:puremon) : augredand ; |
| 489 |
Returns the product of Pol and Mon (in this order). |
| 490 |
Non-destructive. |
| 491 |
^LNIL Updated 2004-04-24^L |
| 492 |
qpolmonmult |
| 493 |
QPOLMONMULT (Pol:qpol, puremon) : qpol ; |
| 494 |
Returns the product of Pol and Mon (in this order). |
| 495 |
Non-destructive. |
| 496 |
^LNIL Updated 2004-04-24^L |
| 497 |
printratcf |
| 498 |
PRINTRATCF (Cf:ratcoeff) : boole ; |
| 499 |
If Cf is a/b (with a and b relatively prime as they should), |
| 500 |
the procedure does one of the following |
| 501 |
Prints a/b and returns T if b <> 0; |
| 502 |
Prints a and returns T if b = 1 but a <> 1; |
| 503 |
Doesn't print and returns NIL if a = b = 1. |
| 504 |
The procedure may or may not surround the print form of a |
| 505 |
(and b) with parentheses, depending on the domain and |
| 506 |
other mode settings. |
| 507 |
^LNIL Updated 2004-04-24^L |
| 508 |
printqpolratfactor |
| 509 |
PRINTQPOLRATFACTOR (Pol:qpol) : bool ; |
| 510 |
If the rational factor or "quotient" of Pol is a/b (with |
| 511 |
a and b relatively prime as they should), the procedure does |
| 512 |
one of the following |
| 513 |
Prints a/b and returns T if b <> 0; |
| 514 |
Prints a and returns T if b = 1 but a <> 1; |
| 515 |
Doesn't print and returns NIL if a = b = 1. |
| 516 |
The procedure may or may not surround the print form of a |
| 517 |
(and b) with parentheses, depending on the domain and |
| 518 |
other mode settings. |
| 519 |
^LNIL Updated 2004-04-24^L |
| 520 |
normalform |
| 521 |
NORMALFORM (Pol:qpol) : genqpol ; DESTRUCTIVE |
| 522 |
Changes Pol to the normal form of its input (with respect |
| 523 |
to GBasis). Returns NIL if the normal form is zero, its changed |
| 524 |
argument else. |
| 525 |
^LNIL |
| 526 |
(THE PAD |
| 527 |
|
| 528 |
Under development. Should contain: |
| 529 |
|
| 530 |
READLISPINPUT (FileIndex/NIL/T); |
| 531 |
|
| 532 |
SETINVARS, SETOUTVARS, SETVARS; PRINTINVARS, PRINTOUTVARS, |
| 533 |
PRINTVARS. Intended to improve the user and window system |
| 534 |
interfaces. Similarly, there are Reduce interface procedures |
| 535 |
planned, which should benefit from the above.) |
| 536 |
|
| 537 |
|
| 538 |
^L |
| 539 |
NIL |
| 540 |
TENSPOL!-PRINTMODE Either DISTRIBUTED or SEMIDISTRIBUTED |
| 541 |
keyword, meaning the mode for printing |
| 542 |
tensor polynomials. |
| 543 |
|
| 544 |
TENSTERM!-PRINTMODE A list of three strings which are beginning, |
| 545 |
middle, and ending in printing of tensor |
| 546 |
term. |
| 547 |
EDGE!-STRING Equals a string which is printed between |
| 548 |
edges while chain is printed. |
| 549 |
|
| 550 |
EDGE!-STRING!-PRINTING Bolean, meaning whether to use EDGE!-STRING |
| 551 |
in chain printings |
| 552 |
|
| 553 |
BETTI True, when Betti numbers are to be calculated |
| 554 |
BETTI-FOREACHDEGREE True, when Betti numbers are allowed to |
| 555 |
be calculated and they are updated every |
| 556 |
time the Groebner basis element is found. |
| 557 |
------------------------------------------------------------------- |
| 558 |
|
| 559 |
^LNIL Updated 2004-04-24^L |
| 560 |
member2nil |
| 561 |
MEMBER2NIL (element:any, list:lany) : genint ; DESTRUCTIVE (2) |
| 562 |
Searches list for its first occurrence of element. |
| 563 |
If found, the occurrence is (destructively) replaced by |
| 564 |
NIL, and the number of the position of element in list is |
| 565 |
returned. If element is not found in list, NIL is returned. |
| 566 |
^LNIL Updated 2004-04-24^L |
| 567 |
printbettinumber |
| 568 |
PRINTBETTINUMBER (btnumber:btnum) : - ; |
| 569 |
Prints Betti number btnumber as follows: |
| 570 |
B(homological degree, total degree) = value |
| 571 |
^LNIL Updated 2004-04-24^L |
| 572 |
printbetti |
| 573 |
PRINTBETTI () : - ; |
| 574 |
Prints all the calculated Betti numbers. |
| 575 |
((Applies the procedure PRINTBETTINUMBER to all elements of the |
| 576 |
anBETTINUMS list.)) |
| 577 |
^LNIL Updated 2004-04-24^L |
| 578 |
printcurrentbetti |
| 579 |
PRINTCURRENTBETTI () : - ; |
| 580 |
Prints Betti numbers for the last calculated Groebner basis |
| 581 |
degree. |
| 582 |
((Applies the procedure PRINTBETTINUMBER to all elements of the |
| 583 |
anCURRENTBETTINUMS list.)) |
| 584 |
^LNIL Updated 2004-04-24^L |
| 585 |
macbettiprint |
| 586 |
MACBETTIPRINT () : bool ; |
| 587 |
Prints Betti numbers in Macaulay form. Returns boolean value T. |
| 588 |
^LNIL Updated 2004-04-24^L |
| 589 |
anickresolutionoutputfile |
| 590 |
ANICKRESOLUTIONOUTPUTFILE |
| 591 |
Is equal to the name of output file. In case it equals to NIL, |
| 592 |
the output channel will be associated with the file name |
| 593 |
"andifres.txt". |
| 594 |
^LNIL Updated 2004-04-24^L |
| 595 |
settenspolprtstrings |
| 596 |
SETTENSPOLPRTSTRINGS (strings:lstr) : lstr ; |
| 597 |
The list strings should consist of 3 strings which are |
| 598 |
used to print tensor product. First string is printed |
| 599 |
at the beginning, second - as a tensor multiplication sign |
| 600 |
and the third - as the ending of thensor monomial. |
| 601 |
The list of 3 strings of old settings is returned. |
| 602 |
^LNIL Updated 2004-04-24^L |
| 603 |
gettenspolprtstrings |
| 604 |
GETTENSPOLPRTSTRINGS () : lstr ; |
| 605 |
Returns a list of 3 strings which are used when tensor |
| 606 |
monomials are printed as beginning, middle and ending |
| 607 |
strings. |
| 608 |
^LNIL Updated 2004-04-24^L |
| 609 |
setedgestring |
| 610 |
SETEDGESTRING (strng:string) : genstring ; |
| 611 |
The string strng is taken for printing as edges when chain |
| 612 |
vertexes are printed. The old value of it is returned. |
| 613 |
^LNIL Updated 2004-04-24^L |
| 614 |
getedgestring |
| 615 |
GETEDGESTRING () : - ; |
| 616 |
Returns the value of string which is printed between chain |
| 617 |
vertexes. |
| 618 |
^LNIL Updated 2004-04-24^L |
| 619 |
printnewchainsdiff |
| 620 |
PRINTNEWCHAINSDIFF (chan:genint) : - ; |
| 621 |
Prints differentials for the new generated chains |
| 622 |
to the channel chan |
| 623 |
^LNIL Updated 2004-04-24^L |
| 624 |
printchainsdiff |
| 625 |
PRINTCHAINSDIFF (chan:genint) : - ; |
| 626 |
Prints differentials for the all generated chains |
| 627 |
to the channel chan |
| 628 |
^LNIL Updated 2004-04-24^L |
| 629 |
prtchndiff |
| 630 |
PRTCHNDIFF (inchain:chn) : - ; |
| 631 |
Prints differential for the chain inchain in form |
| 632 |
D (chain length, chain) = differential |
| 633 |
^LNIL Updated 2004-04-24^L |
| 634 |
calcbetti |
| 635 |
CALCBETTI (flag:bool) : - ; |
| 636 |
Depending on whether flag is non-NIL or not, switches on/off |
| 637 |
the calculation of Betti numbers. It sets corresponding flags. |
| 638 |
^LNIL Updated 2004-04-24^L |
| 639 |
onflybetti |
| 640 |
ONFLYBETTI (flag:bool) : - ; |
| 641 |
Depending on whether flag is non-NIL or not, switches on/off |
| 642 |
the calculation of Betti numbers. Also, the feature of |
| 643 |
calculating and printing them while Groebner basis is being |
| 644 |
calculated degree by degree. It sets corresponding flags. |
| 645 |
^LNIL Updated 2004-04-24^L |
| 646 |
getbettinums |
| 647 |
GETBETTINUMS () : lbtnum; |
| 648 |
Returns the list of Betti numbers. |
| 649 |
^LNIL Updated 2004-04-24^L |
| 650 |
getbtorder |
| 651 |
GETBTORDER (btnumber:btnum) : int ; |
| 652 |
Returns the order of Betti number btnumber. |
| 653 |
^LNIL Updated 2004-04-24^L |
| 654 |
getbtdegree |
| 655 |
GETBTDEGREE (btnumber:btnum) : int ; |
| 656 |
Returns the degree of Betti number btnumber. |
| 657 |
^LNIL Updated 2004-04-24^L |
| 658 |
getbtvalue |
| 659 |
GETBTVALUE (btnumber:btnum) : int ; |
| 660 |
Returns the value of Betti number btnumber. |
| 661 |
^LNIL Updated 2004-04-24^L |
| 662 |
clearresolution |
| 663 |
CLEARRESOLUTION () : - ; |
| 664 |
Calls ResolutionDone and ResolutionClear procedures. |
| 665 |
^LNIL Updated 2004-04-24^L |
| 666 |
anickdisplay |
| 667 |
ANICKDISPLAY () : - ; |
| 668 |
Prints the Betti numbers into the result file. |
| 669 |
^LNIL Updated 2004-04-24^L |
| 670 |
calculateanickresolutiontolimit |
| 671 |
CALCULATEANICKRESOLUTIONTOLIMIT (limdeg:int) : - ; |
| 672 |
Countinues the process of Anick resolution calculation up to |
| 673 |
the degree limdeg. It maybe called after the Groebner basis is |
| 674 |
calculated, in case it is finite and calculations stopped |
| 675 |
at a lower degree than thatonto which the Anick resolution |
| 676 |
should be calculated. |
| 677 |
^LNIL Updated 2004-04-24^L |
| 678 |
printchain |
| 679 |
PRINTCHAIN (chain:chn) : - ; |
| 680 |
Prints chain. The vertices are printed as monomials |
| 681 |
(corresponding to the present ALGOUTMODE and minor output |
| 682 |
mode settings). If PRINTEDGESTRING is ON, then between |
| 683 |
vertices it prints the value of anEDGESTRING. |
| 684 |
^LNIL Updated 2004-04-24^L |
| 685 |
mprint |
| 686 |
MPRINT (mat:matrix) : bool ; |
| 687 |
Prints mat as a matrix to standard output and returns T, if |
| 688 |
that is not NIL. Else it prints nothing and returns NIL. |
| 689 |
^LNIL Updated 2004-04-24^L |
| 690 |
cflineprint |
| 691 |
CFLINEPRINT (ln:lcoeff) : bool ; |
| 692 |
Prints the list of coefficients ln in one line and returns |
| 693 |
T if ln is non-NIL. Else it prints nothing and returns NIL. |
| 694 |
^LNIL Updated 2004-04-24^L |
| 695 |
rank |
| 696 |
RANK (mat:inputmatrix) : int ; |
| 697 |
Returns the rank of mat calculated in present coefficient |
| 698 |
field. |
| 699 |
^LNIL Updated 2004-04-24^L |
| 700 |
inputmatrix2redandmatrix |
| 701 |
INPUTMATRIX2REDANDMATRIX (mtrx:inputmatrix) : matrix ; DESTRUCTIVE |
| 702 |
Modifies the elements of mtrx so that their type is of |
| 703 |
acceptance by further procedures. |
| 704 |
^LNIL Updated 2004-04-24^L |
| 705 |
prettyprintsdp |
| 706 |
PRETTYPRINTSDP (pol:tp) : - ; |
| 707 |
Prints the semi-distributed polynomial pol in a form decided by |
| 708 |
the tensor polynomials print-mode. (See GETTENSORPOLSPRINTMODE). |
| 709 |
^LNIL Updated 2004-04-24^L |
| 710 |
printtensorpolsdistributed |
| 711 |
PRINTTENSORPOLSDISTRIBUTED () : - ; |
| 712 |
Selects distributed form for printing semi-distributed |
| 713 |
polynomials. |
| 714 |
^LNIL Updated 2004-04-24^L |
| 715 |
printtensorpolssemidistributed |
| 716 |
PRINTTENSORPOLSSEMIDISTRIBUTED () : - ; |
| 717 |
Selects semi-distributed form for printing semi-distributed |
| 718 |
polynomials. |
| 719 |
^LNIL Updated 2004-04-24^L |
| 720 |
gettensorpolsprintmode |
| 721 |
GETTENSORPOLSPRINTMODE () : id ; |
| 722 |
Returns the identifier which is a keyword either DISTRIBUTED |
| 723 |
or SEMIDISTRIBUTED. This identifier points out how the current |
| 724 |
semi-distributed polynomials are printed. |
| 725 |
^LNIL |
| 726 |
2005-02-04: A short summary of the (experimental) ring stack feature: |
| 727 |
|
| 728 |
Normally, the ring structure is given by the present setup. |
| 729 |
Sometimes, we may want to work with several rings simultaneously. In |
| 730 |
order to do this, the present ring characteristica may be saved on a |
| 731 |
stack, or restored therefrom. (Or, should I call it a 'heap'? Anyhow, |
| 732 |
a 'last in, first out' object.) It then may be restored at a later stage. |
| 733 |
|
| 734 |
For the moment, the 'ring structure' is taken as meaning the |
| 735 |
VARIABLESETUP part of the setup, together with the internal |
| 736 |
representations of the 'interned' monomials. |
| 737 |
|
| 738 |
For the moment, the following (user available) procedures exist: |
| 739 |
|
| 740 |
POPRING (void) ; genint |
| 741 |
If the ring stack is non-empty, then restore the ring setting |
| 742 |
from the topmost ring stack object; remove this; and return the |
| 743 |
former ring stack length. Else, do nothing, and return NIL. |
| 744 |
|
| 745 |
PUSHRING (void) ; int |
| 746 |
Add an item on top of the ring stack, corresponding to the |
| 747 |
present ring setting. Return the new ring stack length. |
| 748 |
|
| 749 |
RINGSTACKLENGTH () : int |
| 750 |
Return the length of the ring stack. |
| 751 |
|
| 752 |
SWITCHRING (void) ; boolean |
| 753 |
If the ring stack is empty, then do nothing, and return NIL. |
| 754 |
Else, replace the current ring setting with the one given |
| 755 |
by the topmost ring stack element, and vice versa, and return T. |
| 756 |
^L |