Mathematical Computations Using Bergman

Jörgen Backelin, Svetlana Cojocaru, Victor Ufnarovski

Contents

Chapter 1
A brief bergman tutorial

1.1  Preliminaries

• MS Windows 95 and later (CLISP);
• Linux on different machines (PSL, Reduce, CLISP);
• Sun Solaris for Sparc and Sun Blade (PSL, Reduce, CLISP);
• Dec Alpha under OSF and Linux (PSL, Reduce).

• Gröbner basis
• Hilbert series
• Poincaré series
• Anick resolution
• Betti numbers

1.1.1  Starting a bergman session

Entering LISP ...

Bergman 0.984, 14-Dec-2004 

1 lisp>

  i i i i i i i    ooooo    o        ooooooo   ooooo   ooooo 
  I I I I I I I   8     8   8           8     8     o  8    8
  I  \ `+' /  I   8         8           8     8        8    8
   \  `-+-'  /    8         8           8      ooooo   8oooo
    `-__|__-'     8         8           8           8  8
        |         8     o   8           8     o     8  8
  ------+------    ooooo    8oooooo  ooo8ooo   ooooo   8

Copyright(c) Bruno Haible,Michael Stoll 1992, 1993
Copyright(c) Bruno Haible,Marcus Daniels 1994-1997
Copyright(c) Bruno Haible,Pierpaolo Bernardi,Sam Steingold 1998
Copyright(c) Bruno Haible,Sam Steingold 1999

Welcome to the BERGMAN system.

[1]> 

1.1.2  Ending a bergman session

1.1.3  What you need to know about Lisp syntax

1.2  Simplest calculations in bergman

1.2.1  Selecting alternatives

1.2.2  Commutative algebras

1 lisp> (simple)
Now input in-variables and ideal generators in 
algebraic form, thus:
      vars v1, ..., vn;
      r1, ..., rm;
where v1, ..., vn are the variables, 
and r1, ..., rm the generators.
algebraic form input> vars x,y;x^2-y^2,x*y;
% 2
x*y,
   x^2-y^2,

% 3
y^3,

Done
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), 
     and run a new (SIMPLE).
nil
2 lisp>

1 lisp> (simple "test1.a" "test.bg")
t
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), 
     and run a new (SIMPLE).
nil
2 lisp> (quit)

Quitting

% 2
x*y,
   x^2-y^2,

% 3
y^3,

Done

1.2.3  Non-commutative algebras

2 lisp> (noncommify)
nil
3 lisp>  (simple)
Now input in-variables and ideal generators in 
algebraic form, thus:
      vars v1, ..., vn;
      r1, ..., rm;
where v1, ..., vn are the variables, 
and r1, ..., rm the generators.
algebraic form input> vars x,y;x^2-y^2,x*y;
% 2
x*y,
   -y^2+x^2,
   
% 3
x^3,
   y*x^2,
   
Done
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), 
     and run a new (SIMPLE).
nil
4 lisp> 

1 lisp> (simple "test2.a" "test2.bg")
nil
nil
t
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), 
     and run a new (SIMPLE).
nil
2 lisp> 

% 2
x*y,
   -y^2+x^2,
   
% 3
x^3,
   y*x^2,

Done

1 lisp>(ncpbhgroebner "test2.a""test2.bg""test2.pb""test2.hs")
*** I turn on noncommutativity
nil
10
nil
*** Function `degreeenddisplay' has been redefined

% No. of Spolynomials calculated until degree 2: 0
% No. of ReducePol(0) demanded until degree 2: 0
% Time: 425

% No. of Spolynomials calculated until degree 3: 2
% No. of ReducePol(0) demanded until degree 3: 0
% Time: 646

% No. of Spolynomials calculated until degree 4: 8
% No. of ReducePol(0) demanded until degree 4: 5
% Time: 833
*** Function `degreeenddisplay' has been redefined
nil
2 lisp>

+2*z^2
+0*z^3
+0*z^4

+t^2*(2*z^2)
+t^3*(2*z^2+2*z^3)
+t^4*(6*z^3+2*z^4)

% 2
x*y,
   -y^2+x^2,
   
% 3
x^3,
   y*x^2,

Done

1.2.4  Normal form and reduction

2 lisp> (noncommify)
nil
3 lisp> (simple)
Now input in-variables and ideal generators in 
algebraic form, thus:
        vars v1, ..., vn;
        r1, ..., rm;
where v1, ..., vn are the variables, 
and r1, ..., rm the generators.
algebraic form input> vars a,b; 2*a^2-3*b^2;
SetupGlobals
 ... done
+t^2*(z^2)
% 2
-3*b^2+2*a^2,

+t^3*(z^2+z^3)
% 3
-b*a^2+a^2*b,

+t^4*(z^3+z^4)
Done
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL),
     and run a new (SIMPLE).
nil
4 lisp>

4 lisp> (readtonormalform)
algebraic form input> a^3*b^3-b^3*a^3;
is reduced to
2/3*(-a^4*b*a+a^5*b),
nil

5 lisp> (readtonormalform)
algebraic form input> a^4*b^2-b^2*a^4;

is reduced to
0,

• (readpol l), which reads the list l of polynomials from the input, separated by the semicolons,
• (writepol l), which prints them on the screen,
• (reducepol a b), which reduces the polynomial a to the (printable) polynomial b,
• (printqpols b), which prints (printable) polynomial.

1.2.5  Starting a new calculation

• kill bergman with (quit); or
• interrupt bergman with   ^Z ; or
• clear the memory with (clearideal), and run a new (simple).

• initial ideal generators,
• calculated Gröbner basis,
• all the memory, used for the calculations.

• all selected modes (see section 2.4), including list of input variables.

 
1 lisp> (simple)
Now input in-variables and ideal generators 
in algebraic form, thus:
        vars v1, ..., vn;
        r1, ..., rm;
where v1, ..., vn are the variables, 
and r1, ..., rm the generators.
algebraic form input>  vars x,y,z;
algebraic form input> x^3, x^2*y-y^2*x, z^2*x, x^2*z-y^2*z;
% 3
x*z^2,
   x^2*z-y^2*z,
   x^2*y-x*y^2,
   x^3,
   
% 4
y^2*z^2,
   y^3*z,
   x*y^2*z,
   x*y^3,
   
Done
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), 
     and run a new (SIMPLE).
nil
2 lisp> (clearideal)
nil
3 lisp> (simple)
Now input in-variables and ideal generators 
in algebraic form, thus:
        vars v1, ..., vn;
        r1, ..., rm;
where v1, ..., vn are the variables, 
and r1, ..., rm the generators.
algebraic form input> y*z^2-z^3, x^2*z-y*z^2, x*y*z;
% 3
y*z^2-z^3,
   x*y*z,
   x^2*z-z^3,
   
% 4
z^4,
   x*z^3,
   
Done
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), 
     and run a new (SIMPLE).
nil
4 lisp> 

Chapter 2
Computations in bergman

2.1  Introduction

2.2  Bergman: philosophy and approach

2.3  Bergman: main restrictions

2.4  The polynomial ring set up

2.4.1  Variable names and the flag raise

6 lisp> (getinvars)
(x y z)

1. From the very beginning the value of this flag is ON. That is why you can write (SIMPLE) instead of (simple)
2. You may influence whether or not reading of variables and generators is case sensitive mode. Typing
   (setcasesensalgin t)
   you establish the case sensitive mode of algebraic input and by
   (setcasesensalgin nil)
   the mode is switched to no-case sensitivity.
3. Most the procedures, available to user have been written in source files using capital names. The procedures, intended to be unavailable to the normal user have been written with the names containing both small and capital letters, such as SecretProcedure. They will be unavailable because by the default flag raise is ON.
   In the later versions of Reduce and LISP the situation is more complicated. Because flag raise works in the opposite direction now (decapitalizing instead of capitalizing), all the procedures written in capitals would be unavailable too. That is why in those versions a special converter is used to interchange lowercase and capital characters. So, for example, even if in the source files the procedure is written as (SIMPLE) it will have the name (simple) inside the bergman and will be available independent of the flag raise. The unpleasant effect of this is that such procedures as SecretProcedure can appears as sECRETpROCEDURE or even as s!E!C!R!E!Tp!R!O!C!E!D!U!R!E, but this ugly names we can see in the case of errors only (when the user is able to recover easy the original name the SecretProcedure).
   More exactly, some procedures may turn OFF the flag raise while they are working. If a break loop (for example because of mistake) happens during their work the value of the flag will be OFF and, for example, you will be unable to quit from the program writing
   (QUIT)
   because in this case the name should be decapitalized:
   (quit)
   Another way to quit is
   (on raise)
   (QUIT)
4. If the user wants (e.g. for the debugging) to have access inside the bergman to the procedures and variables with the names, containing both small and capital letters, such as SecretProcedure (s)he needs to switch the flag raise OFF and use the names, where secret letters (capital in last version and lowercase in the older versions) are printed after exclamations: b!A!D. Even the multiplication in some versions is secret and looks as !*. But normally you don't need take care about this.

2.4.2  Ordering

• in the non-commutative DEGLEX mode the last variable is always the highest;
• in the commutative mode and both eliminating orderings first variable is the highest.

2.4.3  Using eliminating ordering

2 lisp> (noncommify)
nil
3 lisp> (elimorder)
nil
4 lisp> (simple)
Now input in-variables and ideal generators 
in algebraic form, thus:
        vars v1, ..., vn;
        r1, ..., rm;
where v1, ..., vn are the variables, 
and r1, ..., rm the generators.
algebraic form input>  vars r,l,q,h;
algebraic form input>  r*r-q*q+l*r-r*h,r*q-q*r+l*q-q*h,
algebraic form input>  l*r-r*l,l*q+q*l-2*q*h,
algebraic form input>  r*r-r*l-2*l*r+2*l*l-r*h+l*h,
algebraic form input>  r*h-h*r,q*h-h*q,l*h-h*l;

% 2
-h*q+q*h,
   -h*l+l*h,
   q*l+l*q-2*q*h,
   -h*r+r*h,
   -q*r+r*q+l*q-q*h,
   -4*r*l+2*l^2+l*h+q^2,
   4*l*r-2*l^2-l*h-q^2,
   4*r^2-4*r*h+2*l^2+l*h-3*q^2,

% 3
4*r*q*h-4*l^2*q+10*l*q*h-q^3-9*q*h^2,
   4*r*q^2+12*l^3-10*l*q^2-3*l*h^2-3*q^2*h,

% 4
l*q^3-3*l*q*h^2-q^3*h+3*q*h^3,
   -12*l^3*h-4*l^2*q^2+20*l*q^2*h+3*l*h^3-q^4-6*q^2*h^2,
   -4*l^3*q+12*l^2*q*h-11*l*q*h^2+3*q*h^3,
   12*l^4-8*l^2*q^2-3*l^2*h^2-2*l*q^2*h+q^4,

% 5
-48*l^2*q*h^2+96*l*q*h^3-q^5+10*q^3*h^2-57*q*h^4,

% 6
-48*l^2*q^2*h^2+96*l*q^2*h^3-q^6+10*q^4*h^2-57*q^2*h^4,

% 7
-q^7+13*q^5*h^2-39*q^3*h^4+27*q*h^6,

2.4.4  Coefficients: background

2.4.5  Coefficients: choices

2.4.6  Weights handling

1 lisp> (setweights 2  2 1)
nil
2 lisp> (getweights)
(2 2 1)
3 lisp> (simple)
Now input in-variables and ideal generators 
in algebraic form, thus:
        vars v1, ..., vn;
        r1, ..., rm;
where v1, ..., vn are the variables, 
and r1, ..., rm the generators.
algebraic form input> vars x,y,z;
algebraic form input> x^3, x*z-y*z;
% 3
x*z-y*z,
   
% 6
x^3,
   
% 7
y^3*z,
   
Done
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), 
     and run a new (SIMPLE).
nil
4 lisp> 

2.4.7  Rings exchange

1 lisp> (simple)
Now input in-variables and ideal generators
in algebraic form, thus:
        vars v1, ..., vn;
        r1, ..., rm;
where v1, ..., vn are the variables,
and r1, ..., rm the generators.
algebraic form input> vars x,y;x^2-y^2;

% 2
x^2-y^2,

Done
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), and run a new (SIMPLE).
nil
2 lisp> (readtonormalform)
algebraic form input> x^2;

is reduced to
y^2,

nil
3 lisp> (pushring)
1
4 lisp> (clearideal)
5 lisp> (simple)
Now input in-variables and ideal generators
in algebraic form, thus:
        vars v1, ..., vn;
        r1, ..., rm;
where v1, ..., vn are the variables,
and r1, ..., rm the generators.
algebraic form input> vars x,y;x^2;
% 2
x^2,

Done
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), and run a new (SIMPLE).
nil
6 lisp> (readtonormalform)
algebraic form input> x^2;

is reduced to
0,
nil
7 lisp> (switchring)
t
8 lisp> (readtonormalform)
algebraic form input> x^2;

is reduced to
y^2,

nil
9 lisp> (popring)
1
10 lisp> (readtonormalform)
algebraic form input> x^2;

is reduced to
0,
nil

2.5  Homogenisation

1 lisp> (purelexify)
nil
3 lisp> (setalgoutmode alg)
nil
4 lisp> (algforminput)
algebraic form input> vars x,y,z,t;
algebraic form input> x^2-2, y^2-3, z^2-5, t-x-y-z;
t
5 lisp> (homogeniseinput)
*** Function `h!O!M!O!Gpm!O!N' has been redefined
nil
6 lisp> (groebnerinit)
nil
7 lisp> (groebnerkernel)
d!O!N!E
8 lisp> (algforminput)
algebraic form input> vars x,y,z,t,f;
algebraic form input> ;
nil
9 lisp> (bigoutput)
-x-y-z+t,
   z^2-5*f^2,
   2*y*z-2*y*t-2*z*t+t^2+6*f^2,
   y^2-3*f^2,
   2*y*f^2-3*z*t^2+6*z*f^2+t^3+4*t*f^2,
   y*t^2-7*z*t^2+12*z*f^2+2*t^3+12*t*f^2,
   4*z*t^3-t^4-20*t^2*f^2+24*f^4,
   -80*z*t^2*f^2+96*z*f^4-t^5+60*t^3*f^2+24*t*f^4,
   96*z*t*f^4-t^6+40*t^4*f^2-376*t^2*f^4+480*f^6,
   576*z*f^6-5*t^7+194*t^5*f^2-1520*t^3*f^4+2544*t*f^6,
   -t^8+40*t^6*f^2-352*t^4*f^4+960*t^2*f^6-576*f^8,
   
nil
10 lisp> (quit)

2.6  Choosing a strategy

2.7  Input-output modes for the polynomials

2.7.1  Commutative case

• ** may be used instead of ^;
• Blank space may be inserted everywhere, except within identifiers or integers or between two successive ** .
• Exponents 0 and 1 may occur.
• The order of the variables in a monomial is arbitrary.

2.7.2  Non-commutative case

1. Both algforminput parts, i. e., the input variable setting and the polynomial listing, are optional. You may thus give lisp form input, but perform algforminput vars v1,...,vn; ; (NOTE the double ;), in order to enable alg or macaulay output. Of course, if you try to print polynomials when the variables are not set, you are in trouble.
2. New successful (and non-empty) polynomial inputs replace old ones. Likewise, new successful input variable settings replace old ones. Running groebnerkernel (successfully) or clearideal kills the input polynomials, but not the variable settings.
3. The implementation of algforminput depends on specific PSL features, since the pure Standard Lisp has poor alternative scanning abilities. If algforminput should be disabled in some other implementation, and if you still wish to use algebraic output modes, then you must define the variable names in another way, using the internal representations. In bergman 0.9* and the next versions, the output variable settings performed by
   vars x,y,z;
   in the commutative case corresponds to
   (setq O!u!tV!a!r!s (quote (!x !y !z)))
   and in the non-commutative case corresponds to
   (setq O!u!tV!a!r!s (quote ((1 . !x) (2 . !y) (3 . !z)))) .

2.8  Calculating and using series

2.8.1  Hilbert series computation

(setmaxdeg 10)
(setalgoutmode alg)
(algforminput)
vars x,y;
x*x-2*y*y;

1 lisp>(ncpbhgroebner "test.a" "test.gb" "test.pb" "test.hs")
*** I turn on noncommutativity
nil
alg
t
*** Function `!O!L!D!D!E!D' has been redefined
*** Function `degreeenddisplay' has been redefined
%ufn malencie bucvi seichas 'degreeenddisplay'
% No. of Spolynomials calculated until degree 2: 0
% No. of ReducePol(0) demanded until degree 2: 0
% Time: 238


% No. of Spolynomials calculated until degree 3: 1
% No. of ReducePol(0) demanded until degree 3: 0
% Time: 289


% No. of Spolynomials calculated until degree 4: 2
% No. of ReducePol(0) demanded until degree 4: 0
% Time: 323

*** Function `degreeenddisplay' has been redefined
NIL
2 lisp> (calctolimit(getmaxdeg))
+t^5*(z^4+z^5)
+t^6*(z^5+z^6)
+t^7*(z^6+z^7)
+t^8*(z^7+z^8)
+t^9*(z^8+z^9)
+t^10*(z^9+z^10)
NIL
3 lisp> (tdegreehseriesout(getmaxdeg))
+6*z^5
+7*z^6
+8*z^7
+9*z^8
+10*z^9
+11*z^10
11
4 lisp>

% 2
-2*y^2+x^2,

% 3
-y*x^2+x^2*y,

+t^2*(z^2)
+t^3*(z^2+z^3)
+t^4*(z^3+z^4)

+3*z^2
+4*z^3
+5*z^4

1 lisp> (noncommify)
NIL
2 lisp> (setmaxdeg 10)
10
3 lisp> (simple)
Now input in-variables and ideal generators 
in algebraic form, thus:
        vars v1, ..., vn;
        r1, ..., rm;
where v1, ..., vn are the variables, 
and r1, ..., rm the generators.
algebraic form (noncomm.) input> vars x,y;
algebraic form (noncomm.) input> x*x-2*y*y;

+t^2*(z^2)
% 2
-2*y^2+x^2,

+t^3*(z^2+z^3)
% 3
-y*x^2+x^2*y,

+t^4*(z^3+z^4)

Done
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), 
     and run a new (SIMPLE).
NIL
4 lisp>  (calctolimit(getmaxdeg))
+t^5*(z^4+z^5)
+t^6*(z^5+z^6)
+t^7*(z^6+z^7)
+t^8*(z^7+z^8)
+t^9*(z^8+z^9)
+t^10*(z^9+z^10)
NIL
5 lisp>  (tdegreehseriesout(getmaxdeg)) 
+3*z^2
+4*z^3
+5*z^4
+6*z^5
+7*z^6
+8*z^7
+9*z^8
+10*z^9
+11*z^10
11
6 lisp>

1 lisp> (algforminput)
algebraic form input> vars x,y; x^3, x*y^2-x^2*y;
t
2 lisp> (groebnerinit)
SetupGlobals
 ... done
nil
3 lisp> (groebnerkernel)
d!O!N!E
4 lisp> (calcrathilbertseries)
nil
5 lisp> (setq p hilbertnumerator)
((4 . -1) (3 . -1) (2 . 1) (1 . 1) (0 . 1))
6 lisp> (setq q hilbertdenominator)
1
7 lisp>  (tdegreehseriesout 1)
2
8 lisp>  (tdegreehseriesout 2)
3
9 lisp>  (tdegreehseriesout 3) 
2
10 lisp> (tdegreehseriesout 4)
1
11 lisp> (tdegreehseriesout 5)
1
12 lisp> (tdegreehseriesout 6)
1
13 lisp> (tdegreehseriesout 7)
1
15 lisp> (groebnerfinish)

1 lisp> (hilbert)
Input the maximal power series degree you want to calculate
1 lisp> 6
Now input in-variables and ideal generators 
in algebraic form, thus:
        vars v1, ..., vn;
        r1, ..., rm;
where v1, ..., vn are the variables, 
and r1, ..., rm the generators.
algebraic form input> vars x,y;
algebraic form input> x^3, x*y^2-x^2*y;
% 3
-x^2*y+x*y^2,
   x^3,

% 4
x*y^3,

Hilbert series numerator:   +1*t^0+1*t^1+1*t^2-1*t^3-1*t^4
Hilbert series denominator:  1-t
Hilbert power series:        1+2t^1+3t^2+2t^3+t^4+t^5+t^6+...
Done

(setmaxdeg 6)
(algforminput)
vars x,y;
x^3, x*y^2-x^2*y;

(hilbert ``input_file'' ``output_gb_file'' ``output_hs_file'')

2.8.2  Computation of Gröbner basis using known
Hilbert series

1 lisp> (setinterruptstrategy minhilblimits) 
nil
2 lisp> (sethseriesminima 1 6 20 49 98 169 259 360 462 557 642
  715 778 836 894 954 1014 1074 1134 1194)
t
3 lisp> (simple "sixroots" "sixroots.bg")
t
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), 
     and run a new (SIMPLE).
nil
4 lisp> 

2.9  The jumping rabbit

2 lisp> (rabbit 2 2 8)
algebraic form input> vars a,b,c;a*b-c, b*c-a, c*a-b;
SetupGlobals
 ... done
RABBIT: Added step, Maxdegree=4
 Jump number 1

RABBIT: Jump number 2

RABBIT: Jump number 3

RABBIT: Added step, Maxdegree=6
 Jump number 4

GB is completely calculated
Rabbit have finished jumping. GB is 
a*b-c,
   b^2-a^2,
   b*c-a,
   c*a-b,
   -c^2+a^2,
   a^3-c*b,
   -a^2*c+b*a,
   b*a^2-a*c,
   b*a*c-a*c*b,
   -c*b*a+a*c*b,
   
nil

(setrabbit 2 2 8)
(algforminput)
vars a,b,c;
a*b-c, b*c-a, c*a-b;

2.10  Some bricks to build your own procedures

• the top-of-the-top level,
• the top level,
• the level of internal using.

algebraic form input>

• groebnerinit, that initiates numerous internal variables. It should be called after selecting modes and doing input.
• groebnerkernel. Here the main calculations are performed. The results of calculations are saved in several variables and files (see section 4.2.4). You can use them in your own procedures.
• groebnerfinish. This procedure closes all files and restores variables and flags.

(DE DEGREEENDDISPLAY () 
 (PROGN 
    (DEGREEOUTPUT) 
    (TERPRI)
    (PRIN2 "% No. of Spolynomials calculated until degree ")
    (PRIN2 (GETCURRENTDEGREE)) (PRIN2 ": ")  
    (PRINT NOOFSPOLCALCS)
    (PRIN2 "% Time: ") (PRINT (TIME))
))

(DE DEGREEENDDISPLAY () 
  (PROGN 
     (DEGREELMOUTPUT) 
     (TERPRI)
     (PRIN2 "% No. of Spolynomials calculated until degree ")
     (PRIN2 (GETCURRENTDEGREE)) (PRIN2 ": ")  
     (PRINT NOOFSPOLCALCS)
     (PRIN2 "% Time: ") (PRINT (TIME))
))

1 lisp> (setcustdisplay t)
nil
2 lisp> (dskin "mydisplay")
*** Function `degreeenddisplay' has been redefined
degreeenddisplay
nil
3 lisp> (simple)
Now input in-variables and ideal generators
in algebraic form, thus:
        vars v1, ..., vn;
        r1, ..., rm;
where v1, ..., vn are the variables,
and r1, ..., rm the generators.
algebraic form input> vars x,y;x*x-y*y,x*y;
SetupGlobals
 ... done
% 2
x*y
x^2


% No. of Spolynomials calculated until degree 2: 0
% Time: 30

% 3
y^3


% No. of Spolynomials calculated until degree 3: 1
% Time: 30

Done
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), and run a new (SIMPLE).
nil

2.11  Modules over non-commutative algebras

2.11.1  Gröbner basis for modules over
non-commutative algebras

2 lisp>  (noncommify)
nil
3 lisp> (simple)
Now input in-variables and ideal generators 
in algebraic form, thus:
        vars v1, ..., vn;
        r1, ..., rm;
where v1, ..., vn are the variables,
 and r1, ..., rm the generators.
algebraic form (noncomm.) input> vars y,x,b,a;x*x-y*y,a*x-b*y;
+t^2*(2*z^2)
% 2
x*x-y*y,
   a*x-b*y,
 
+t^3*(2*z^2+2*z^3)
% 3
x*y*y-y*y*x,
   a*y*y-b*y*x,
 
+t^4*(2*z^3+2*z^4)
Done

2.11.2  Hilbert series for modules over
non-commutative algebras

• the maximal degree of computation,
• the number of module variables,
• the list of the algebra and module variables, (the algebra variables should be at the beginning of the list),
• the algebra relations (more exactly - ideal generators, because instead of the relation r_i=0 we input r_i itself.)
• the module relations.

• the maximal degree of computation,
• the number of module variables,
• the list of the algebra and module variables (the algebra variables should be at the beginning of the list) and the ideal generators,

• the module relations.

2 lisp> (modulehseries)
*** Function `modulehseries' has been redefined
*** We turn on noncommutativity
Input the Maximum Degree you want to calculate
2 lisp> 4
Input the number of module generators
2 lisp> 2
Now input ALL ring and module variables but ONLY
the ring ideal generators in algebraic form, thus:
      vars v1, ..., vn;
       r1, ..., rm;
where v1, ..., vn are all the variables, 
and r1, ..., rm the generators.
algebraic form (noncomm.) input> vars x,y,a,b;
algebraic form (noncomm.) input> x*x-y*y, x*y;
+t^2*(2*z^2)
% 2
x*y,
   -y^2+x^2,
   
+t^3*(2*z^2+2*z^3)
% 3
x^3,
   y*x^2,
   
+t^4*(6*z^3+2*z^4)
+14*z^2
+48*z^3
+168*z^4
Now input ONLY the module relations, 
thus:    r1, ..., rm;
where  r1, ..., rm are the module relations.
algebraic form (noncomm.) input> a*x-b*y;
+t^2*(3*z^2)
% 2
-b*y+a*x,

+t^3*(3*z^2+3*z^3)
% 3
b*x*x,

+t^4*(9*z^3+3*z^4)
Done
+13*z^2
+40*z^3
+127*z^4

Here is (1-H)^(-1) for the Hilbert series H of the module

 +1
 +2*t^1
 +7*t^2
+22*t^3
+69*t^4
Here is the Hilbert series H of the module
+2*t^1
+3*t^2
+2*t^3
nil
3 lisp>

• the maximal degree of computation defined by
  (setmaxdeg degree)
• the number of module generators defined by
  (setq nmodgen number)
• the procedure call to process the list of variables presented in algebraic form:
  (algforminput)
• the list of the algebra and module variables (the algebra variables should be at the beginning of the list). To input them it is necessary to write (without brackets!):
  vars v₁, ... , v_n;
  r₁,...,r_n;
  
  where v_i are the algebra and module variables, r_i are the ideal generators only. Note that the items are separated by commas and every list is ended by semicolon.

• the procedure call to process the list of variables presented in algebraic form:
  (algforminput)
• the module relations:
  m₁,...,m_n;

(setmaxdeg 16)
(setq nmodgen 2)
(algforminput)
vars z,y,x,b,a;
x*x, x*y+z*x;

(algforminput)
a*x*y-b*y*y+14*b*z*z,
a*z*z*z-b*x*z*y;

2.11.3  The Anick resolution and Betti numbers for the trivial module

• the maximal degree of computation,
• the list of the algebra variables,
• the algebra relations.

• the maximal degree of computation,
• the list of the ideal variables and relations.

2 lisp> (anick)
*** We turn on noncommutativity
Input the Maximum Degree you want to calculate
2 lisp> 4

Now input in-variables and ideal generators 
in algebraic form, thus:
     vars v1, ..., vn;
      r1, ..., rm;
where v1, ..., vn are the variables, 
and r1, ..., rm the generators.
algebraic form input> vars x,y; x*x+y*y+x*y+y*x;
The Anick resolution initialization...
B(1,1)=2
The Anick resolution initialization done.
+t^2*(z^2)
% 2
y^2+y*x+x*y+x^2,

Calculating the Anick resolution in degree 2...
B(1,1)=2
B(2,2)=1
    0   1   2
  +----------
0 | 1   2   1
1 | -   -
end of Calculations.
+t^3*(z^3)
Calculating the Anick resolution in degree 3...
B(1,1)=2
B(2,2)=1
B(3,3)=1
    0   1   2   3
  +--------------
0 | 1   2   1   1
1 | -   -   -
2 | -   -
end of Calculations.

Groebner basis is finite.
If you want to continue calculations until maximal degree
type (CALCULATEANICKRESOLUTIONTOLIMIT (GETMAXDEG))
nil
3 lisp> (calculateanickresolutiontolimit (getmaxdeg))
Calculating the Anick resolution in degree 4...
B(1,1)=2
B(2,2)=1
B(3,3)=1
B(4,4)=1
    0   1   2   3   4
  +------------------
0 | 1   2   1   1   1
1 | -   -   -   -
2 | -   -   -
3 | -   -
end of Calculations.
nil
4 lisp> (anickdisplay)
Printing the results ...
Printing is done.
nil
5 lisp> (quit)

(setq anickresolutionoutputfile "resolution.txt")

D(0, x)=1.x
D(0, y)=1.y
D(1, yy)=y.y+y.x+x.y+x.x
D(2, yyy)=yy.y+yy.x
D(3, yyyy)=yyy.y+yyy.x
B(1,1)=2
B(2,2)=1
B(3,3)=1
B(4,4)=1
    0   1   2   3   4
  +------------------
0 | 1   2   1   1   1
1 | -   -   -   -
2 | -   -   -
3 | -   -

• the maximal degree of computation defined by
  (setmaxdeg degree). In fact this line may be omitted. In this case calculations will finish when the Gröbner basis will be completely calculated or be formally infinite (until there are enough resources).
• the procedure call to process the list of variables presented in algebraic form:
  (algforminput)
• the list of the algebra variables and the list of the algebra relations. To input them it is necessary to write (without brackets!):
  vars v₁, ... , v_n;
  r₁,...,r_n;
  
  where v_i are the algebra variables, r_i are the algebra relations. Note that the items are separated by commas and every list is ended by semicolon.

(setmaxdeg 4)
(algforminput)
vars x,y,a,b;
x*x-y*y, a*x-b*y;

2.11.4  Writing own procedures

• (on calcbetti) - turns on the Betti numbers calculation mode. This flag is mandatory.
• (on onflybetti) - informs the application to calculate Betti numbers after each degree of Gröbner basis is operated out. This allows to view Betti numbers degree by degree during the Gröbner basis computations.

2 lisp> (setringobject)
nil
3 lisp> (noncommify)
nil
4 lisp> (load anick)
nil
5 lisp> (setmaxdeg 4)
nil
6 lisp> (onflybetti)
nil
7 lisp> (simple)
Now input in-variables and ideal generators 
in algebraic form, thus:
        vars v1, ..., vn;
        r1, ..., rm;
where v1, ..., vn are the variables, 
and r1, ..., rm the generators.
algebraic form input> vars x;x*x;
The Anick resolution initialization...
B(1,1)=1
The Anick resolution initialization done.
+t^2*(z^2)
% 2
x^2,
Calculating the Anick resolution in degree 2...
B(1,1)=1
B(2,2)=1
    0   1   2
  +----------
0 | 1   1   1
1 | -   -
end of Calculations.
+t^3*(z^3)
Calculating the Anick resolution in degree 3...
B(1,1)=1
B(2,2)=1
B(3,3)=1
    0   1   2   3
  +--------------
0 | 1   1   1   1
1 | -   -   -
2 | -   -
end of Calculations.
Done
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), 
     and run a new (SIMPLE).
nil
8 lisp>

2.11.5  The Anick resolution and Betti numbers for a right module

• the maximal degree of computation,
• the number of module variables,
• the list of the algebra and module variables (the algebra variables should be at the beginning of the list),
• the algebra relations (more exactly - the corresponding ideal generators, but it will be convenient to call them relations to avoid in the future ambiguity in the interpretation of the word "generators")
• the module relations.

• the maximal degree of computation,
• the number of module variables,
• the list of the algebra and module variables (the algebra variables should be at the beginning of the list) and the algebra and module relations.

1 lisp> (setq anickresolutionoutputfile  "resolution.txt")
"resolution.txt"
2 lisp> (modulebettinumbers)

*** We turn on the MODULE mode
*** We turn on noncommutativity
Input the Maximum Degree you want to calculate
2 lisp> 5
Input the number of the module variables
2 lisp> 1
Now input all ring and then all module variables.
Input  the ring ideal and module relations 
in algebraic form  thus:
      vars v1, ..., vn;
       r1, ..., rm;
where v1, ..., vn are all the variables, 
and r1, ..., rm the  relations.
algebraic form input>  vars x,a;x*x,a*x;
The Anick resolution initialization...
B(0,0)=1
The Anick resolution initialization done.
+t^2*(2*z^2)
% 2
x^2,
   a*x,

Calculating the module Anick resolution in degree 2...
B(0,0)=1
B(1,1)=1
    0   1   2
  +----------
0 | 1   1
1 | -
end of Calculations.
+t^3*(2*z^3)
Calculating the module Anick resolution in degree 3...
B(0,0)=1
B(1,1)=1
B(2,2)=1
    0   1   2   3
  +--------------
0 | 1   1   1
1 | -   -
2 | -
end of Calculations.

Groebner basis is finite.
If you want to continue calculations until the maximal 
degree type (CALCULATEANICKRESOLUTIONTOLIMIT (GETMAXDEG))
nil
3 lisp>  (CALCULATEANICKRESOLUTIONTOLIMIT (GETMAXDEG))
Calculating the module Anick resolution in degree 4...
B(0,0)=1
B(1,1)=1
B(2,2)=1
B(3,3)=1
    0   1   2   3   4
  +------------------
0 | 1   1   1   1
1 | -   -   -
2 | -   -
3 | -
end of Calculations.
Calculating the module Anick resolution in degree 5...
B(0,0)=1
B(1,1)=1
B(2,2)=1
B(3,3)=1
B(4,4)=1
    0   1   2   3   4   5
  +----------------------
0 | 1   1   1   1   1
1 | -   -   -   -
2 | -   -   -
3 | -   -
4 | -
end of Calculations.
nil
4 lisp> (anickdisplay)
Printing the results ...
Printing is done.
nil
5 lisp> (quit)

D(0, a)=1.a
D(1, ax)=a.x
D(2, axx)=ax.x
D(3, axxx)=axx.x
D(4, axxxx)=axxx.x
B(0,0)=1
B(1,1)=1
B(2,2)=1
B(3,3)=1
B(4,4)=1
    0   1   2   3   4   5
  +----------------------
0 | 1   1   1   1   1
1 | -   -   -   -
2 | -   -   -
3 | -   -
4 | -

• the maximal degree of computation defined by
  (setmaxdeg degree). In fact this line may be omitted. In this case calculations will finish when the Gröbner basis will be completely calculated or be formally infinite (until there are enough resources).
• the number of module generators defined by
  (setq nmodgen number)
• the procedure call to process the list of variables presented in algebraic form:
  (algforminput)
• the list of the algebra and module variables (the algebra variables should be at the beginning of the list) and the list of the algebra and module relations. To input them it is necessary to write (without brackets!):
  vars v₁, ... , v_n;
  r₁,...,r_n;
  
  where v_i are the algebra and module variables, r_i are the algebra and module relations. Note that the items are separated by commas and every list is ended by semicolon.

(setmaxdeg 4)
(setq nmodgen 2)
(algforminput)
vars x,y,a,b;
x*x-y*y, a*x-b*y;

2.11.6  The Anick resolution and Betti numbers for right, two-sided ideals, and factor-algebras, considered as right modules

vars x,y,c,X,Y; x*y, c*x;

• the maximal degree of Gröbner basis computation,
• the list of the algebra variables, the module variable and copies of the algebra variables, as it is described above.
• the algebra relations,
• the ideal generators, multiplied by the module variable.

• the maximal degree of computation,
• the input list of variables and relations.

1 lisp> (factalgbettinumbers)
*** We turn on the MODULE mode
*** Function `addadditionalrelations' has been redefined
*** We turn on noncommutativity
Input the Maximum Degree you want to calculate
1 lisp> 5
Now input all ring variables, a dummy variable (D),
and copies of the ring variables 
(in this order), in this manner:
    vars x1, ..., xn, D, y1, ..., yn;
(where x1,..., xn are the ring varables,
and y1,...,yn their copies)
Then input  the ring ideal relations 
(in ordinary algebraic form);
but the factor algebra relations in the form
     D*r1, ..., D*rm,
where r1, ..., rm are the relations.
algebraic form input>  vars x,y, D, X,Y;
algebraic form input>  x*y,y*x, y*y,D*x*x;
*** Function `addadditionalrelations' has been redefined
The Anick resolution initialization...
B(0,0)=1
The Anick resolution initialization done.
+t^2*(5*z^2)
% 2
x*y,
   y*x,
   y^2,
   X*D-D*x,
   Y*D-D*y,

Calculating the module Anick resolution in degree 2...
B(0,0)=1
    0   1
  +------
0 | 1
end of Calculations.
+t^3*(z^2+5*z^3)
% 3
D*x^2,

Calculating the module Anick resolution in degree 3...
B(0,0)=1
B(1,2)=1
    0   1   2   3
  +--------------
0 | 1   -   -
1 | -   1
2 | -
end of Calculations.
+t^4*(3*z^3+8*z^4)
Calculating the module Anick resolution in degree 4...
B(0,0)=1
B(1,2)=1
B(2,3)=1
    0   1   2   3   4
  +------------------
0 | 1   -   -   -
1 | -   1   1
2 | -   -
3 | -
end of Calculations.

Groebner basis is finite.
If you want to continue calculations until the maximal 
degree type (CALCULATEANICKRESOLUTIONTOLIMIT (GETMAXDEG))
nil
2 lisp> (CALCULATEANICKRESOLUTIONTOLIMIT (GETMAXDEG))
Calculating the module Anick resolution in degree 5...
B(0,0)=1
B(1,2)=1
B(2,3)=1
B(3,4)=2
    0   1   2   3   4   5
  +----------------------
0 | 1   -   -   -   -
1 | -   1   1   2
2 | -   -   -
3 | -   -
4 | -
end of Calculations.
nil
3 lisp> (anickdisplay)
Printing the results ...
Printing is done.

D(0, D)=1.D
D(1, Dx^2)=D.x^2
D(2, Dx^2y)=Dx^2.y
D(3, Dx^2yx)=Dx^2y.x
D(3, Dx^2yy)=Dx^2y.y
B(0,0)=1
B(1,2)=1
B(2,3)=1
B(3,4)=2
    0   1   2   3   4   5
  +----------------------
0 | 1   -   -   -   -
1 | -   1   1   2
2 | -   -   -
3 | -   -
4 | -

• the maximal degree of computation defined by
  (setmaxdeg degree)
• the procedure call to process the list of variables presented in algebraic form:
  (algforminput)
• the input list of variables and relations. To input them it is necessary to write (without brackets!):
  vars v₁, ... , v_n;
  r₁,...,r_n;
  
  where v_i are the algebra, module or copy variables, r_i are all the relations. Note that the items are separated by commas and every list is ended by semicolon.

(setmaxdeg 8)
(algforminput)
vars  x,y,c,X,Y;
x*y,  c*x;

2.11.7  Working with the left modules

1 lisp>  (leftmodulebettinumbers)
Input the Maximum Degree you want to calculate
1 lisp> 5
Input the number of the module variables
1 lisp> 1
Now input all ring and then all module variables.
Input  the ring ideal and module relations 
in algebraic form  thus:
      vars v1, ..., vn;
       r1, ..., rm;
where v1, ..., vn are all the variables, 
and r1, ..., rm the  relations.
algebraic form input> vars x,a; x*x, x*a;
The Anick resolution initialization...
B(0,0)=1
The Anick resolution initialization done.
+t^2*(2*z^2)
% 2
x^2,
   a*x,

Calculating the module Anick resolution in degree 2...
B(0,0)=1
B(1,1)=1
    0   1   2
  +----------
0 | 1   1
1 | -
end of Calculations.
+t^3*(2*z^3)

Calculating the module Anick resolution in degree 3...
B(0,0)=1
B(1,1)=1
B(2,2)=1
    0   1   2   3
  +--------------
0 | 1   1   1
1 | -   -
2 | -
end of Calculations.

Groebner basis is finite.
If you want to continue calculations until the maximal 
degree type (CALCULATEANICKRESOLUTIONTOLIMIT (GETMAXDEG))
nil
2 lisp> (CALCULATEANICKRESOLUTIONTOLIMIT (GETMAXDEG))
Calculating the module Anick resolution in degree 4...
B(0,0)=1
B(1,1)=1
B(2,2)=1
B(3,3)=1
    0   1   2   3   4
  +------------------
0 | 1   1   1   1
1 | -   -   -
2 | -   -
3 | -
end of Calculations.
Calculating the module Anick resolution in degree 5...
B(0,0)=1
B(1,1)=1
B(2,2)=1
B(3,3)=1
B(4,4)=1
    0   1   2   3   4   5
  +----------------------
0 | 1   1   1   1   1
1 | -   -   -   -
2 | -   -   -
3 | -   -
4 | -
end of Calculations.
nil
3 lisp>

2 lisp>  (factalgbettinumbers)

*** We turn on the MODULE mode
*** We turn on noncommutativity
Input the Maximum Degree you want to calculate
2 lisp> 4
Now input all ring variables, a dummy variable (D),
and copies of the ring variables 
(in this order), in this manner:
    vars x1, ..., xn, D, y1, ..., yn;
(where x1,..., xn are the ring varables,
and y1,...,yn their copies
Then input  the ring ideal relations 
(in ordinary algebraic form);
but the factor algebra relations in the form
     D*r1, ..., D*rm,
where r1, ..., rm are the relations.
Finally, input the dummy commutators
   y1*D-D*x1, ..., ym*D-D*ym;
algebraic form input>  vars x,y,c, X,Y;
algebraic form input>  x*x-x*y, c*x;
The Anick resolution initialization...
B(0,0)=1
The Anick resolution initialization done.
+t^2*(4*z^2)
% 2
-x*y+x^2,
   c*x,
   X*c,
   Y*c-c*y,
   
Calculating the module Anick resolution in degree 2...
B(0,0)=1
B(1,1)=1

    0   1   2
  +----------
0 | 1   1
1 | -
end of Calculations.
+t^3*(z^2+3*z^3)
% 3
c*y*x,
   
Calculating the module Anick resolution in degree 3...
B(0,0)=1
B(1,1)=1
B(1,2)=1
B(2,2)=1
    0   1   2   3
  +--------------
0 | 1   1   1
1 | -   1
2 | -
end of Calculations.
+t^4*(z^2+3*z^3+2*z^4)
% 4
c*y^2*x,
   
Calculating the module Anick resolution in degree 4...
B(0,0)=1
B(1,1)=1
B(1,2)=1
B(2,2)=1
B(1,3)=1
B(2,3)=1
    0   1   2   3   4
  +------------------
0 | 1   1   1   -
1 | -   1   1
2 | -   1
3 | -
end of Calculations.

nil
3 lisp>  (clearideal)
Closing the streams.Cleaning the variables
nil
4 lisp> (factalagbettinumbers)
Input the Maximum Degree you want to calculate
4 lisp> 4
Now input all ring variables, a dummy variable (D),
and copies of the ring variables 
(in this order), in this manner:
    vars x1, ..., xn, D, y1, ..., yn;
(where x1,..., xn are the ring varables,
and y1,...,yn their copies
Then input  the ring ideal relations 
(in ordinary algebraic form);
but the factor algebra relations in the form
     D*r1, ..., D*rm,
where r1, ..., rm are the relations.
Finally, input the dummy commutators
   y1*D-D*x1, ..., ym*D-D*ym;
algebraic form input>  vars x,y,c, X,Y;
algebraic form input>  x*x-y*x,c*x;
The Anick resolution initialization...
B(0,0)=1
The Anick resolution initialization done.
+t^2*(4*z^2)
% 2
-y*x+x^2,
   c*x,
   X*c,
   Y*c-c*y,
   
Calculating the module Anick resolution in degree 2...

B(0,0)=1
B(1,1)=1

    0   1   2
  +----------
0 | 1   1
1 | -
end of Calculations.
+t^3*(2*z^3)
Calculating the module Anick resolution in degree 3...
B(0,0)=1
B(1,1)=1
    0   1   2
  +----------
0 | 1   1
1 | -
end of Calculations.

Groebner basis is finite.
If you want to continue calculations until the maximal 
degree type (CALCULATEANICKRESOLUTIONTOLIMIT (GETMAXDEG))
nil
5 lisp> (CALCULATEANICKRESOLUTIONTOLIMIT (GETMAXDEG))
Calculating the module Anick resolution in degree 4...
B(0,0)=1
B(1,1)=1
    0   1   2
  +----------
0 | 1   1
1 | -
end of Calculations.
nil 

2.11.8  Betti numbers for two modules

• the maximal degree of computation,
• the number of the right module variables,
• the number of the left module variables,
• the list of the algebra and module variables (the algebra variables should be at the beginning of the list, followed by right module variables. The left module variables should be at the end of the list.)
• the algebra and both module relations (in arbitrary order).

• the maximal degree of computation,
• the number of the right module variables,
• the number of the left module variables,
• the list of the algebra and module variables (the algebra variables should be at the beginning and the left module variables should be at the end of the list.) and the ideal and module relations.

1 lisp> (twomodbettinumbers)

*** We turn on the TWOMODULES mode
*** We turn on noncommutativity
Input the Maximum Degree you want to calculate
1 lisp> 6
Input the number of the right  module variables
1 lisp> 1
Input the number of the left  module variables
1 lisp> 1
Now input all ring and then all module variables.
Right module variables should be before the left ones.
Input  the ring ideal and module relations 
in algebraic form  thus:
      vars v1, ..., vn;
       r1, ..., rm;
where v1, ..., vn are all the variables, 
and r1, ..., rm the  relations.
algebraic form input> vars x,y,r,l;
algebraic form input> r*x, y*l-x*l;
SetupGlobals
 ... done
The Anick resolution initialization (for two modules)...
The Anick resolution initialization done.
+t^2*(2*z^2)
% 2
y*l-x*l,
   r*x,

Calculating the module Anick resolution in degree 2...
B(0,0)=1

    0   1   2
  +----------
0 | 1

end of Calculations.

Groebner basis is finite.
If you want to continue calculations until the maximal 
degree type (CALCULATEANICKRESOLUTIONTOLIMIT (GETMAXDEG))
nil
2 lisp> (CALCULATEANICKRESOLUTIONTOLIMIT (GETMAXDEG))
Calculating the module Anick resolution in degree 3...
B(0,0)=1
    0   1   2
  +----------
0 | 1
end of Calculations.
Calculating the module Anick resolution in degree 4...
B(0,0)=1
B(0,2)=1
    0   1   2   3   4
  +------------------
0 | 1   -   -
1 | -   -
2 | 1
end of Calculations.
Calculating the module Anick resolution in degree 5...
B(0,0)=1
B(0,2)=1
B(0,3)=2
    0   1   2   3   4   5
  +----------------------
0 | 1   -   -   -
1 | -   -   -
2 | 1   -
3 | 2
end of Calculations.
Calculating the module Anick resolution in degree 6...
B(0,0)=1
B(0,2)=1
B(0,3)=2
B(0,4)=4
    0   1   2   3   4   5   6
  +--------------------------
0 | 1   -   -   -   -
1 | -   -   -   -
2 | 1   -   -
3 | 2   -
4 | 4
end of Calculations.
nil
3 lisp>

• the maximal degree of computation defined by
  (setmaxdeg degree). In fact this line may be omitted. In this case calculations will finish when the Gröbner basis will be completely calculated or be formally infinite (until the resources are exhausted).
• the number of the right module generators defined by
  (setq nrmodgen number)
• the number of the left module generators defined by
  (setq nlmodgen number)
• the procedure call to process the list of variables presented in algebraic form:
  (algforminput)
• the list of the algebra and module variables (in the order described above) and the list of the ideal and module relations. To input them it is necessary to write (without brackets!):
  vars v₁, ... , v_n;
  r₁,...,r_n;
  
  where v_i are the algebra and module variables, r_i are the ideal and module relations. Note that the items are separated by commas and every list is ended by semicolon.

(setmaxdeg 4)
(setq nrmodgen 2)
(setq nlmodgen 2)
(algforminput)
vars  x,y,A1,A2,B1,B2;
x*x+x*y+y*x+y*y,
A1*x*x+A2*y*y,A1*y*y,y*x*B1+x*y*B2,y*y*y*B1;

2.11.9  Calculating Hochschild homology of an algebra

2 lisp> (twomodbettinumbers)

*** We turn on the TWOMODULES mode
*** We turn on noncommutativity
Input the Maximum Degree you want to calculate
2 lisp> 5
Input the number of the right  module variables
2 lisp> 1
Input the number of the left  module variables
2 lisp> 1
Now input all ring and then all module variables.
Right module variables should be before the left ones.
Input  the ring ideal and module relations 
in algebraic form  thus:
      vars v1, ..., vn;
       r1, ..., rm;
where v1, ..., vn are all the variables, 
and r1, ..., rm the  relations.
algebraic form input> vars x,y,X,Y,r,l;  
algebraic form input> x*y,Y*X, x*X-X*x, 
algebraic form input> x*Y-Y*x, y*X-X*y, y*Y-Y*y,
algebraic form input> r*x-r*X, r*y-r*Y, x*l-X*l, y*l-Y*l;
The Anick resolution initialization (for two modules)...
The Anick resolution initialization done.
+t^2*(10*z^2)
% 2
x*y,
   -X*x+x*X,
   -X*y+y*X,
   -X*l+x*l,
   -Y*x+x*Y,
   -Y*y+y*Y,
   Y*X,
   -Y*l+y*l,
   -r*X+r*x,
   -r*Y+r*y,

Calculating the module Anick resolution in degree 2...
B(0,0)=1

    0   1   2
  +----------
0 | 1
end of Calculations.
+t^3*(4*z^2+12*z^3)
% 3
r*x*X-r*x^2,
   -r*y*x+r*x*Y,
   r*y*X,
   r*y*Y-r*y^2,

Calculating the module Anick resolution in degree 3...
B(0,0)=1
B(0,1)=2
B(1,1)=2

   0   1   2   3
  +--------------
0 | 1   2
1 | 2
end of Calculations.
+t^4*(4*z^2+11*z^3+6*z^4)
% 4
r*x^2*X-r*x^3,
   -r*y^2*x+r*x*Y^2,
   r*y^2*X,
   r*y^2*Y-r*y^3,

Calculating the module Anick resolution in degree 4...
B(0,0)=1
B(0,1)=2
B(1,1)=2
B(0,2)=2
B(1,2)=2
    0   1   2   3   4
  +------------------
0 | 1   2   -
1 | 2   2
2 | 2
end of Calculations.
+t^5*(4*z^2+11*z^3+6*z^4+z^5)
% 5
r*x^3*X-r*x^4,
   -r*y^3*x+r*x*Y^3,
   r*y^3*X,
   r*y^3*Y-r*y^4,
 
Calculating the module Anick resolution in degree 5...
B(0,0)=1
B(0,1)=2
B(1,1)=2
B(0,2)=2
B(1,2)=2
B(0,3)=2
B(1,3)=2
    0   1   2   3   4   5
  +----------------------
0 | 1   2   -   -
1 | 2   2   -
2 | 2   2
3 | 2
end of Calculations.

4 lisp> (hochschild)
*** Function `addadditionalrelations' has been redefined
Input the Maximum Degree you want to calculate
4 lisp> 5


Now input all ring variables, copies of the ring variables,
  and two dummy variable (D1,D2) 
(in this order), in this manner:
    vars x1, ..., xn,  y1, ..., yn, D1, D2;
(where x1,..., xn are the ring varables,
and y1,...,yn their copies)
Then input  the ring ideal relations 
(in ordinary algebraic form);
       r1, ..., rm;

algebraic form input> vars  x,y, X,Y,r,l;
algebraic form input> x*y;
*** Function `addadditionalrelations' has been redefined
The Anick resolution initialization (for two modules)...
The Anick resolution initialization done.
+t^2*(10*z^2)
% 2
x*y,
   -X*x+x*X,
   -X*y+y*X,
   X*l-x*l,
   -Y*x+x*Y,
   -Y*y+y*Y,
   Y*X,
   Y*l-y*l,
   r*X-r*x,
   r*Y-r*y,

Calculating the module Anick resolution in degree 2...
B(0,0)=1
    0   1   2
  +----------
0 | 1
end of Calculations.
+t^3*(4*z^2+12*z^3)
% 3
r*x*X-r*x^2,
   -r*y*x+r*x*Y,
   r*y*X,
   r*y*Y-r*y^2,

Calculating the module Anick resolution in degree 3...
B(0,0)=1
B(0,1)=2
B(1,1)=2
    0   1   2   3
  +--------------
0 | 1   2
1 | 2
end of Calculations.
+t^4*(4*z^2+11*z^3+6*z^4)
% 4
r*x^2*X-r*x^3,
   -r*y^2*x+r*x*Y^2,
   r*y^2*X,
   r*y^2*Y-r*y^3,

Calculating the module Anick resolution in degree 4...
B(0,0)=1
B(0,1)=2
B(1,1)=2
B(0,2)=2
B(1,2)=2
    0   1   2   3   4
  +------------------
0 | 1   2   -
1 | 2   2
2 | 2
end of Calculations.
+t^5*(4*z^2+11*z^3+6*z^4+z^5)
% 5
r*x^3*X-r*x^4,
   -r*y^3*x+r*x*Y^3,
   r*y^3*X,
   r*y^3*Y-r*y^4,

Calculating the module Anick resolution in degree 5...
B(0,0)=1
B(0,1)=2
B(1,1)=2
B(0,2)=2
B(1,2)=2
B(0,3)=2
B(1,3)=2
    0   1   2   3   4   5
  +----------------------
0 | 1   2   -   -
1 | 2   2   -
2 | 2   2
3 | 2
end of Calculations.

nil
5 lisp>

2.12  Bergman under Reduce

2.12.1  Working in the Reduce syntax

symbolic car '(a);
x+y;

> bergman
 4: simple();
Now input in-variables and ideal generators 
in algebraic form, thus:
        vars v1, ..., vn;
        r1, ..., rm;
where v1, ..., vn are the variables, 
and r1, ..., rm the generators.
algebraic form input> vars x,y; x^2-y^2,x*y;
% 2
x*y,
   x^2-y^2,
   
% 3
y^3,
   
Done
 - All is OK (I hope). Now you may (e. g.):
   - kill bergman with (QUIT); or
   - interrupt bergman with ^Z; or
   - clear the memory with (CLEARIDEAL), 
     and run a new (SIMPLE).

nil

5: quit;

Quitting

2.12.2  Parametric coefficients

> bergman

7:  symbolic;

nil

8:  setreducesfcoeffs();

nil

9: setiovars '(x,y);

nil

10:  algebraic;

11: lpol:= {x^2-a*y^2,x*y};

               2    2
lpol := { - a*y  + x ,x*y}

12:  bmgroebner lpol;

           2    2    3
{x*y, - a*y  + x ,a*y }

13:  bye;

2.13  Debugging in bergman

(setmaxdeg 10)
(algforminput)
vars v,d,r,s,t,e,q,m,b,c,h,g,l,k,p,n,a;
g*q^3+h*p^3-k^2*l^2,
2*a^2*g^2-2*a^2*l^2+2*a^2*m^2-b^2*g^2+2*c^3*h-4*g*n^3+
2*g*p^3+2*k^4,
a^2*b^2*h+3*a^2*g*k^2-2*a^2*q^3-b^2*g*k^2-2*c^3*m^2+
4*e^4*h+2*g*s^4-4*k^2*n^3, 3*a^2*b^2*h+12*a^2*g*k^2-
12*a^2*q^3+2*c^3*g^2-6*c^3*l^2-6*c^3*m^2-2*d^3*g^2+
12*e^4*h+12*g*s^4-12*k^2*n^3-6*k^2*p^3,
-a^4*g^2+4*a^2*k^4+8*a^2*t^4-2*b^4*g^2-4*b^2*g*n^3+
8*c^3*g*k^2-16*e^4*g^2+8*e^4*m^2+8*g*v^5-4*n^6+8*p^6,
a^2*g^3-a^2*g*l^2-a^2*g*m^2-2*a^2*h*k^2+2*a^2*r^3+
2*g^2*p^3+4*k^2*q^3-2*l^2*n^3-2*m^2*p^3,
-2*a^2*g^3+4*a^2*g*l^2+8*a^2*h*k^2-4*a^2*r^3-b^2*g^3+
2*c^3*g*h-10*g^2*p^3-6*g*k^2-8*k^2*q^3+4*l^2*n^3+
8*l^2*p^3+4*m^2*p^3,
-a^2*g*l^2-3*a^2*h*k^2-b^2*h*k^2-2*c^3*g*h+4*g^2*p^3+
4*g*k^4+4*g*t^4-2*h*s^4+2*l^2*n^3-8*l^2*p^3,
-6*a^2*h*k^2-3*b^2*g*l^2-4*c^3*g*h-2*d^3*g*h+6*g^2*p^3+
12*g*k^4+12*g*t^4-6*k^2*q^3-18*l^2*p^3+6*m^2*p^3,
3*a^2*g^3-4*a^2*g*l^2-6*a^2*h*k^2+4*a^2*r^3-2*g^2*n^3+
8*g^2*p^3+4*g*k^4+8*k^2*q^3-4*l^2*n^3-4*l^2*p^3-4*m^2*p^3,
18*a^12-81*a^10*b^2+189*a^8*b^4+108*a^8*e^4-279*a^6*b^6-
108*a^6*b^2*e^4-30*a^6*c^6+96*a^6*c^3*d^3-12*a^6*d^6-
144*a^6*f^6+243*a^4*b^8-324*a^4*b^4*e^4+162*a^4*b^2*c^6-
432*a^4*b^2*c^3*d^3+108*a^4*b^2*d^6+324*a^4*b^2*f^6-
108*a^2*b^10+540*a^2*b^6*e^4-198*a^2*b^4*c^6+
504*a^2*b^4*c^3*d*3-144*a^2*b^4*d^6-432*a^2*b^4*f^6-
648*a^2*b^2*e^8+288*a^2*c^6*e^4-144*a^2*c^3*d^3*e^4-
144*a^2*d^6*e^4-432*a^2*e^4*f^6+18*b^12-216*b^8*e^4+
66*b^6*c^6-168*b^6*c^3*d^3+48*b^6*d^6+144*b^6*f^6+
648*b^4*e^8-720*b^2*c^6*e^4+1008*b^2*c^3*d^3*e^4-
288*b^2*d^6*e^4-864*b^2*e^4*f^6+128*c^12-416*c^9*d^3+
480*c^6*d^6+264*c^6*f^6-224*c^3*d^9-672*c^3*d^3*f^6+
32*d^12+192*d^6*f^6-2592*e^12+288*f^12,
-a^2*b^2*g^2+2*a^2*k^4+4*c^3*g*k^2-4*e^4*g^2+4*p^6;

1 lisp> (simple "tests/inv.err")
10
***** 
dskin of `tests/inv.err' aborted after 1 form(s).
***** Segmentation Violation
2 lisp> 

1 lisp> (simple "tests/inv.err")
10
***** 
***** Continuable error.
Break loop
2 lisp break (1) > 

1 lisp> (on break)
nil
2 lisp> (simple "tests/inv.err")
10
***** 
Break loop
3 lisp break (1) > 

1 lisp> (simple "tests/inv.err")
10
***** 
***** Continuable error.
Break loop
2 lisp break (1) > T
Backtrace from top of stack:
backtrace top!-loop!-eval!-and!-print continuableerror
a!L!G!I!Nr!E!A!De!R!Rm!E!S!S!A!G!E 
p!O!La!L!Gr!E!A!D algforminput dskin!-step
unprotected!-dskin!-stream 
dskin!-stream dskin simple top!-loop!-eval!-and!-print
standardlisp 
nil

3 lisp break (1) > V

a!L!G!I!Nr!E!A!De!R!Rm!E!S!S!A!G!E -> continuableerror:
p!O!La!L!Gr!E!A!D -> a!L!G!I!Nr!E!A!De!R!Rm!E!S!S!A!G!E:
        18
        f

a!L!G!I!Nr!E!A!De!R!Rm!E!S!S!A!G!E -> continuableerror:
p!O!La!L!Gr!E!A!D -> a!L!G!I!Nr!E!A!De!R!Rm!E!S!S!A!G!E:
        18
        3
        nil
        504

504*a^2*b^4*c^3*d*3

1 lisp> (simple "tests/inv.err")
10
t
% 4
q^3*g-l^2*k^2+h*p^3,
   2*c^3*h-b^2*g^2+2*k^4+2*g*p^3-4*g*n^3+2*m^2*a^2+
   2*g^2*a^2-2*l^2*a^2,   
% 5
4*g*k^4+4*g^2*p^3-4*l^2*p^3-2*g^2*n^3+2*m^2*g*a^2+
g^3*a^2-2*g*l^2*a^2-2*h*k^2*a^2,
   -4*g*k^2-4*g^2*p^3+4*l^2*p^3+2*g^2*n^3-2*m^2*g*a^2-
g^3*a^2+2*g*l^2*a^2+2*h*k^2*a^2,
    4*q^3*k^2-2*m^2*p^3+2*g^2*p^3-2*l^2*n^3+2*r^3*a^2-
m^2*g*a^2+g^3*a^2-g*l^2*a^2-2*h*k^2*a^2,
    24*t^4*g-4*d^3*h*g-4*b^2*g^3-6*b^2*g*l^2+6*m^2*p^3-
6*g^2*p^3-4*l^2*p^3-6*l^2*n^3+6*r^3*a^2-11*m^2*g*a^2+
3*g^3*a^2+5*g*l^2*a^2-2*h*k^2*a^2,
    6*s^4*g-2*d^3*g^2+2*c^3*g^2-6*c^3*l^2+3*b^2*g*k^2-
6*k^2*p^3-6*q^3*a^2+3*g*k^2*a^2,
   -12*s^4*h+4*d^3*h*g-2*b^2*g^3+6*b^2*g*l^2-6*b^2*h*k^2-
6*m^2*p^3+6*g^2*p^3-8*l^2*p^3-6*g^2*n^3+18*l^2*n^3-
6*r^3*a^2+5*m^2*g*a^2-5*g*l^2*a^2+2*h*k^2*a^2,
   -6*m^2*c^3+12*e^4*h+2*d^3*g^2-2*c^3*g^2+6*c^3*l^2-
6*b^2*g*k^2+6*k^2*p^3-12*k^2*n^3+3*b^2*h*a^2+6*g*k^2*a^2,
   
***** Segmentation Violation
Break loop
2 lisp break (1) > 

 
1 lisp> (dskin "tests/inv.err")
10
t
nil
2 lisp> (testindata)
((4 4) (5 5 nil 5 5 5 5) (6 6) (12))

-6*g*k^2

3 lisp> (printsetup)
((objecttype ring (autoaddrelationstate nil nil)) 
(resolutiontype none)
(variablesetup 
      (ringtype commutative) 
      (commutativeorder tdegrevlex) 
      (noncommutativeorder tdegleftlex)
      (variablenumber 18) 
      (invariables (v d r s t e q m f b c h g l k p n a))
      (outvariables (v d r s t e q m f b c h g l k p n a)) 
      (variableweights nil)(homogenisationvariable nil)) 
      (strategy default 
          (mindeg nil) 
          (maxdeg 10) 
          (interruption ordinary)(customised nil))
      (coefficientdomain nil (oddprimesmoduli ordinary))
      (inputformat casesensalgin) 
      (outputformat algexptsprint 
      (immediateassocringpbdisplay nil) 
      (overwrite nil) (customised nil))
      (debugstate (directalertclosing nil) 
      (checkfailuredisplay t) 
      (activetracebreaks nil)) 
(variousflags 
     (degreeprintoutput off) 
     (dynamiclogtables off) 
     (immediatecrit off) 
     (immediatefullreduction on) 
     (immediaterecdefine off) 
     (nobignum off) 
     (standardanickmodes on) 
     (pbseries off) 
     (reductivity on) (savedegree off) 
     (saverecvalues on)))

• ring type (in our example: (ringtype commutative)),
• ordering (in our example: (commutativeorder tdegrevlex)),
• characteristic (in our example: (coefficientdomain nil (oddprimesmoduli ordinary)) corresponds to characteristic 0),
• number, list of input and output variables, their weights (variableweights nil) in our example means the naturally graded list).

• strategy,
• resolution type,
• maximal and minimal degrees,
• input and output formats (in our example: case sensitive algebraic form input and algebraic form output where the exponents values are printed explicitly),
• various flags, their meaning is explained in the manual.

3 lisp> (checksetup (getsetup))
t

9 lisp> (checksetup (getsetup))

*** Clashes between different mode settings were found.

10 lisp> (findmodeclashes1 (getsetup))
((((resolutiontype) eq (car item) (quote anick)) 
(variousflags pbseries) eq (car item) (quote off)) 
(((resolutiontype) eq (car item) (quote anick)) 
(variablesetup ringtype) not (eq (car item) 
(quote noncommutative))))

2.14  Customising bergman

(CUSTDISPLAYINIT)

: EXPR

Called (if it is defined) at initialising Gröbner basis calculations. Then, supplants the default action, which initialises two counters (NOOFSPOLCALC and NOOFNILREDUCTIONS) to NIL. Intended for similar purposes.

(DEGREEENDDISPLAY)

: EXPR

Called (if it is defined) whenever calculations of the new Gröbner basis elements of a certain degree are finished. Will supplant both other degree-wise output, and optional Poincaré-Betti series calculation. An example of a DEGREEENDDISPLAY template is given in the section 2.10.

(CUSTCLEARCDEGDISPLAY)

: EXPR

Called (if it is defined), if the `Hilbert series limitation' is active, and for a particular degree returns the verdict that both the input and the obstruction monomials of this degree shall be discarded, without any calculations.

It is called before this abandoning, but does not supplant any action. May be used e.g. for printing information on how many input polynomials or obstruction monomials are to be discarded at this degree.

(CUSTCLEARCDEGOBSTRDISPLAY)

: EXPR

Called (if it is defined), if the `Hilbert series limitation' is active, and for a particular degree returns the verdict that only input polynomials should be processed (and thus all current degree obstruction monomials should be discarded). Apart from this, as the preceding procedure.

(HSERIESMINCRITDISPLAY)

: EXPR

Called (if it is defined), if the `Hilbert series limitation' is active, and causes the rest of the input polynomials and obstruction monomials of a certain degree to be discarded. since the prescribed number of new Gröbner basis elements (now) have been found. Apart from this, as the preceding procedures.

(NODISPLAY)

: EXPR

Empty procedure to do nothing. It is a pre-defined alternative for some of the procedures above.

(CUSTNEWCDEGFIX binno)

: EXPR

If it is defined, it is called and supplants the ordinary action of the procedure FixNcDeg (defined in two variants in the file strategy.sl). The result of the procedure decides whether or not to continue calculations, when a new current degree was found.

Returning NIL signifies ßtop"; all other return values signify "continue".

The input "binno" is one of the integers 1, 2, and 3, which should be considered as binary strings of length 2 (i.e., as 01, 10, and 11, respectively). The left bit (right bit) is 1 if and only if there are input polynomials (obstruction monomials, respectively) of the proposed new current degree.

The proposed new current degree may be accessed as the value of (GETCURRENTDEGREE) (or of the variable cDeg).

(CUSTNEWINPUTGBEFIND)

: EXPR

If it is defined, calls and supplants other action, whenever ordinarily the next input polynomial would be reduced, and the resulting polynomial in normal form, if non-zero, would be returned as a new Gröbner basis element. The value of the call to CUSTNEWINPUTGBEFIND ought to be either NIL (signifying "this was a reduction to zero"), or a new Gröbner basis element, in Reductand form.

The supplanted action of the procedure FindInputNGbe (defined in monom.sl) would have included removing an investigated polynomial from the list of current input polynomials (cInPols).

(CUSTCRITPAIRTONEWGBE)

: EXPR

If it is defined, calls and supplants other action, whenever ordinarily an S-polynomial would have been formed from the next critical pair, then would be reduced, and the resulting polynomial in normal form, if non-zero, would be returned as a new Gröbner basis element. The value of the call to CUSTCRITPAIRTONEWGBE ought to be either NIL (signifying "this was a reduction to zero") or a new Gröbner basis element, in Reductand form.

The supplanted action of the procedure FindCritPairNGbe (defined in monom.sl) would have included removing an investigated critical pair from the list of currently investigated critical pairs (SP2r).

(CUSTENDDEGREECRITPAIRFIND)

: EXPR

If it is defined, calls and supplants other action, whenever ordinarily new critical pairs would have been calculated and saved, since all new Gröbner elements of the current degree just were found. If you plan to employ this, you are recommended to view the definition of the procedure whose action it supplants, DEnSPairs (defined in monom.sl).

Note, that the return value is without interest; only the side effects of this procedure matters.

2.15  Computations in bergman under shell

2.15.1  Problems of interface to bergman

dskin of `tests/test1.txt' aborted after 1 form(s).
***** Segmentation Violation

• the functional programming style with its forest of strictly balanced parentheses is rather far from the usual (mathematical) language and can create difficulties for non-experienced user;
• bergman doesn't perform the checking of the input information correctness, in particular, the compatibility of the different parameters values, the homogeneity of the input relations (in the proper case) etc. The last one could be checked only by applying a special function.
• in many cases the error messages are yielded by Lisp interpreter being not understandable for a user who is not skilled in Lisp programming;
• the usage of a single window for interface, where the different zones, destined to different actions, are mixed, causes some troubles in finding of the necessary information.

2.15.2  Shell overview

2.15.3  Shell description

1. File;
2. Profiles;
3. Sessions;
4. View properties;
5. Preview LISP;
6. Run;
7. Process results;
8. Tools;
9. Options;
10. Windows;
11. Help.

• select a session and load its data to panels, i.e., switch to the saved problem;
• create a new session (by selecting < new session > from the session drop-down list);
• save data in the selected session;
• save data in a different session (save as...);
• delete a session.

Figure 2.1: bergman shell: sessions panel

Figure 2.2: bergman shell: calculations menu, variables and relations input areas

• integers of different length (1/2/4 bytes and arbitrary integers, characteristic 0); the coefficient field is the field Q of rational numbers, and the coefficient domain is the ring Z of integers;
• characteristic 2 (modulo 2); the coefficient field and the coefficient domain both are Z/ (2) = GF(2);
• characteristic p (modulo p, p is an odd prime); the coefficient field and the coefficient domain both are Z/ (p) = GF(p).

Figure 2.3: bergman shell: coefficients menu

Figure 2.4: bergman shell: object menu

Chapter 3
Bergman for the advanced user

3.1  References

3.1.1  Mode handling

3.1.2  Sustained operating mode alternatives

3.1.3  The mode designator tree structure

 XXXXX <...>
    YYYYY
    ZZZZZ <...>

 WWWWW <...>

 OBJECTTYPE  <RING | MODULE | TWOMODULES | FACTORALGEBRA>
    AUTOADDRELATIONSTATE  <NIL NIL | T NIL | NIL T>
    LOWTERMSHANDLING    <QUICK | SAFE>

 RESOLUTIONTYPE  <NONE | ANICK>

 ANICK
    TENSPOL-PRINTMODE     <SEMIDISTRIBUTED | DISTRIBUTED>
    TENSTERM-PRINTMODE    <NIL | <a string>> 
                          <NIL | <a string>> <NIL | <a string>> 
    EDGE-STRING           <<a string>>
    EDGE-STRING-PRINTING  <NIL | T>
    BETTI                 <T | NIL>
    BETTI-FOREACHDEGREE   <T | NIL>

 VARIABLESETUP
    RINGTYPE            <COMMUTATIVE | NONCOMMUTATIVE>
    COMMUTATIVEORDER    <TDEGLEX | PURELEX | TDEGREVLEX>
    NONCOMMUTATIVEORDER <TDEGLEFTLEX | ELIMLEFTLEX
                         | HOMOGELIMLEFTLEX | INVELIMLEFTLEX>
    VARIABLENUMBER      <NIL | <a non-negative integer>>
    INVARIABLES         <<a list of different identifiers>>
    OUTVARIABLES        <<a list of different identifiers>>
    VARIABLEWEIGHTS
    HOMOGENISATIONVARIABLE <<an identifier>>

 STRATEGY               <ORDINARY | RABBIT | SAWS>
    AUTOREDUCTION       <IMMEDIATE | POSTPONED>
    CONTENTS            <DENSE | SPARSE>
    MINDEG              <NIL | <a non-negative integer>>
    MAXDEG              <NIL | <a non-negative integer>>
    INTERRUPTION        <ORDINARY | MINHILBLIMITS>
    HSERIESLIMITATIONS
    CUSTOMISED    <NIL | T>

 COEFFICIENTDOMAIN      <NIL | SF | 0 | <a prime>>
   ODDPRIMESMODULI      <MODLOGARITHMIC | ORDINARY>

 INPUTFORMAT   <CASESENSALGIN | NOCASESENSALGIN>

 OUTPUTFORMAT  <LISP | ALG | MACAULAY> 
                         <NOEXPTSPRINT | EXPTSPRINT>
    IMMEDIATEASSOCRINGPBDISPLAY   <NIL | T>
    CUSTOMISED              <NIL | T>

 DEBUGSTATUS
    DIRECTALERTCLOSING  <NIL | T>
    CHECKFAILUREDISPLAY <NIL | T>
    ACTIVETRACEBREAKS <NIL | T>

 VARIOUSFLAGS
    DEGREEPRINTOUTPUT
    DYNAMICLOGTABLES
    IMMEDIATECRIT
    IMMEDIATERECDEFINE
    NOBIGNUM
    OBSOLETENAMESINFORM
    OLDPRINTMODES1
    OLDSERIESMODES1
    STANDARDANICKMODES
    PBSERIES
    REDUCTIVITY
    SAVEDEGREE
    SAVERECVALUES

(GETbbb),

which returns for the given branch bbb the current value of its chosen leaf or subtree.

(SETbbb chosen),

which sets the chosen value for the given branch bbb.

(SETlll),

which makes a leaf lll to be chosen as a current value.

3.1.4  The mode handling procedures

(SETSETUP mode-tree-structure)

: EXPR

Sets the whole mode setup tree. Normally it is used to recover the peviously saved tree. For changing a particular mode is more efficient to use specialised setting procedures described below.

(GETSETUP)

: EXPR

Gets the current mode setup tree.

(PRINTSETUP)

: EXPR

Prints the current mode tree.

• It checks that the input is an association list (i.e., a list, whose members are dotted pairs).
• It checks that the items are of different types, and of types which we consider as (major) modes.
• If there is an OBJECTTYPE item, CHECKSETUP checks that its CDR is a list.
• If there is a RESOLUTIONTYPE item, CHECKSETUP checks that it is a list of length two, and that its second member <s> is a valid resolution type name.
• If there is a VARIABLESETUP item, CHECKSETUP checks that its CDR is an alist. If so, then this alist is searched for some subitems.
• If there is a VARIABLENUMBER subitem, CHECKSETUP should check that the subitem is a list of length two, and that its second member <s> is either NIL or a non-negative integer. If <s> is a number, and INVARIABLES and/or OUTVARIABLES are explicitly given, but of length(s) different from <s>, then a non-fatal warning is issued (but this part of the setup is accepted).
• If there is a STRATEGY item, CHECKSETUP checks that its CDR is an alist. If so, then this alist is searched for some subitems:
  If there is an INTERRUPTION subitem, CHECKSETUP checks that it is a list of length two, and that its second member <s> is a valid interruption minor strategy mode. If <s>= MINHILBLIMITS, CHECKSETUP checks that the VARIABLESETUP item (if any) does not contain a VARIABLEWEIGHTS subitem, with a non-NIL argument.
• If there is a COEFFICIENTDOMAIN item, CHECKSETUP checks that its CDR is a non-empty list, whose CAR is NIL or a non-negative integer, and whose CDR is an alist.
• If there is an INPUTFORMAT item, CHECKSETUP checks that its CDR is a list.
• If there is an OUTPUTFORMAT item, CHECKSETUP checks that its CDR is a list.
• If there is an ANICK item, CHECKSETUP notes it but ignores it.
• If there is a VARIOUSFLAGS item, CHECKSETUP checks that its CDR is an alist.

*** Clashes between different mode settings were found.

(FINDMODECLASHES mst1 mst2)

: EXPR

Gives the information about the found incompatibility between two setups mst1 mst2.

(FINDMODECLASHES1 mst)

: EXPR

Gives the information about the found incompatibility into the setup mst.

(SETOBJECTTYPE objecttype)

: EXPR

Sets the current object type (e.g., RING, MODULE, TWOMODULES).

(GETOBJECTTYPE)

: EXPR

Gets the current object type (e.g.,RING, MODULE, TWOMODULES).

(SETRINGOBJECT)

: EXPR

Sets the current object type to RING.

(SETMODULEOBJECT)

: EXPR

Sets the current object type to MODULE.

(SETTWOMODULESOBJECT)

: EXPR

Sets the current object type to TWOMODULES.

(MODULEOBJECT)

: EXPR

A boolean procedure cheking if the current type is MODULE.

(SETANICKRESOLUTION)

: EXPR

Sets the resolutiontype to ANICK which forced bergman to compute Anick resolution together with Gröbner basis.

(SETNORESOLUTION)

: EXPR

Sets the resolutiontype to NIL.

(SETRESOLUTIONTYPE rt)

: EXPR

Sets the resolutiontype to NIL or to ANICK depending of the value of rt.

(GETRESOLUTIONTYPE)

: EXPR

Gets the current resolutiontype.

(SETINVARS list)

: EXPR

Sets the list of input variables. Sets also the variable number, if it is not already set.

(SETOUTVARS list)

: EXPR

Sets the list of output variables.

(SETIOVARS list)

: EXPR

Sets both lists of the input and output variables.

(CLEARVARS)

: EXPR

Clears the variables lists.

(GETINVARS)

: EXPR

Gets the list of input variables.

(GETOUTVARS)

: EXPR

Gets the list of output variables.

(GETINVARNO)

: EXPR

Gets the number of input variables.

(SETRINGTYPE ringtype)

: FEXPR

Sets the current ring type to the parameter ringtype value (COMMUTATIVE or NONCOMMUTATIVE).

(GETRINGTYPE)

: EXPR

Gets the current ring type (COMMUTATIVE or NONCOMMUTATIVE).

(COMMIFY)

: EXPR

Turns on commutative mode.

(NONCOMMIFY)

: EXPR

Turns on non-commutative mode. (It is automatically performed by ncpbhgroebner, rabbit and a number of other procedures dealing with the Anick resolution. The procedures inter alia changes some flags, which should NOT be changed directly.)

(DEGLEXIFY)

: EXPR

Should only be used in the commutative mode. Sets the monoid order to the TOTAL DEGREE - LEXICOGRAPHICAL one. (In LISP form input, the variable in first position is used first in order comparisons. In ALG form input, the first "vars" listed variable is used first.)

(DEGREVLEXIFY)

: EXPR

Should only be used in the commutative mode. Sets the monoid order to the TOTAL DEGREE - REVERSE LEXICOGRAPHICAL one. (In LISP form input, the variable in last position is first used in order comparisons. In ALG form input, the last "vars" listed variable is first used.)

(DEGLEFTLEXIFY)

: EXPR

Should only be used in the non-commutative mode. Sets the monoid order to the TOTAL DEGREE - LEFT LEXICOGRAPHICAL one.

(PURELEXIFY)

: EXPR

ONLY interesting in conjunction with homogenisation. Not to be used in ordinary manner.

(ELIMORDER)

: EXPR

Sets an elimination ordering. Should only be used in the non-commutative mode.

(INVELIMORDER)

: EXPR

Sets the INVELIMLEFTLEX elimination ordering.

(HOMOGELIMORDER)

: EXPR

Sets the HOMOGELIMLEFTLEX ordering. Is authomatically used with the rabbit strategy only and hardly can be used in other cases.

(NOELIM)

: EXPR

Takes away the HOMOGELIMLEFTLEX ordering. By default recovers DEGLEFTLEXIFY ordering.

(GETORDER)

: EXPR

Gets the current ordering.

(SETCOMMORDER order)

: FEXPR

Sets the commutative ordering indicated as a argument.

(GETCOMMORDER)

: EXPR

Gets the current commutative ordering.

(SETNONCOMMORDER order)

: FEXPR

Sets the non-commutative ordering indicated as a argument.

(GETNONCOMMORDER)

: EXPR

Gets the current non-commutative ordering.

(SETMODULUS pr)

: EXPR

pr should be a prime, 0, or NIL. (NIL is interpreted as 0.) The new coefficient field is set to the prime field of characteristic pr. For pr > 2, some recompilations (which may take several seconds) are performed. If furthermore the mode MODLOGARITHMIC was choosen, a file with a certain kind of "modular logarithm tables" is sought for. The (full) name of the file is supposed to be a preamble followed by the number pr (in decimal notation). The creation of the table file also requires some time, depending on the size of pr.

(RESTORECHAR0)

: EXPR

Has the same effects as
(SETMODULUS 0).

(SETMODULUS2)

: EXPR

Has the same effects as
(SETMODULUS 2).

(SETREDUCESFCOEFFS)

: EXPR

(Only in bergman-under-reduce.) The coefficients are set to be Reduce 'standard forms'. (Any previous SETMODULUS call is cancelled). In this mode, coefficient arithmetics is performed by ordinary Reduce standard form procedures, whence any Reduce flags or standard forms simplifications are in force. In this way very general domains may be set up.

(GETMODULUS)

: EXPR

Returns the characteristic of the coefficient field, or SF if the coefficients are standard forms. (Characteristic 0 may be represented by NIL.)

(SETODDPRIMESMODULI)

: FEXPR

Sets one of two possible values: ordinary to use ordinary bignum arithmetic or modlogarithmic to work with the logarithmic tables.

(GETODDPRIMESMODULI)

: EXPR

Informs about the current choice.

(GETSTRATEGY)

: EXPR

Returns the present strategy of the calculations (DEFAULT, RABBIT or SAWS).

(SETDEFAULTSTRATEGY)

: EXPR

Sets DEFAULT strategy as a current strategy of the calculations.

(SETRABBITSTRATEGY)

: EXPR

Sets RABBIT strategy as a current strategy of the calculations.

(SETSAWSSTRATEGY)

: EXPR

Sets SAWS strategy as a current strategy of the calculations.

(SETINTERRUPTSTRATEGY strategy name)

: FEXPR

(Interruption) strategy name should be one of ORDINARY, NONE, NIL, or MINHILBLIMITS. The first three cause the ordinary (default) strategy, with no interruptions. The argument MINHILBLIMITS turns on the minimal limit interruption strategy submode (see details in 3.4). In this, at any new current degree cDeg the value v of (GETHSERIESMINIMUM cDeg) is investigated. If v is NIL, no interruption is made at this degree. If v is SKIPCDEG, the degree is skipped but calculations continue for higher degrees. If v is T, all further Gröbner basis calculations are skipped. If v is an integer, then this is interpreted as the minimal possible Hilbert function value of cDeg for the factor-ring. Calculations at this degree are interrupted as soon as the found preliminary Gröbner basis elements are enough to make the corresponding monomial ring not to have a higher Hilbert series value of cDeg. (The check is performed by FixNcDeg, whence by defining CUSTNEWCDEGFIX and turning on CUSTSTRATEGY you could modify the action; see this flag.)

(GETINTERRUPTSTRATEGY)

: EXPR

Returns the current interruption strategy (ORDINARY or MINHILBLIMITS).

(CHECKINTERRUPTSTRATEGY)

: EXPR

Inspects the current interruption strategy.

(ORDNGBESTRATEGY)

: EXPR

Has the same effects as (SETINTERRUPTSTRATEGY ORDINARY).

(MINHILBLIMITSTRATEGY)

: EXPR

Has the same effects as (SETINTERRUPTSTRATEGY MINHILBLIMITS), respectively.

(DENSECONTENTS)

: EXPR

(SPARSECONTENTS)

: EXPR

In the (integer of characteristic 0) and the (Reduce standard form) coefficient major modes, the 'coefficient domain' does not coincide with the 'base field'. Then the polynomials under reduction and the preliminary Gröbner basis elements will in general not be monic. As a consequence, we now and then get non-unit contents of polynomials under reduction (i.e., non-trivial greatest common divisors of all coefficients). There are different possible strategies for how often such contents should be calculated and factored out. The bergman default is 'densely', i.e., more or less at each reduction steps. A 'sparsely' variant is also available, where we postpone this until we have normal forms. DENSECONTENTS/SPARSECONTENTS switches between them.

(COMMENT: In the Möller et al. Reduce GROEBNER package, an intermediate strategy of some interest has been tested: Factor out the content once for each (say) tenth step.)

(SETMAXDEG Degree)

: EXPR

Sets the limit for maximum degree in the calculating of the Gröbner basis. It is normally used in the non-commutative calculations to avoid an infinite process. Note that if the Gröbner basis have no elements greater than maximum degree the other calculations (as Betti numbers) will be stopped before the maximum degeree will be achieved.

(GETMAXDEG)

: EXPR

Gets the value of the current maximum degree.

(SETMINDEG Degree)

: EXPR

Sets the lower limit for the degree of the calculations. Is used in a very special situations.

(GETMINDEG)

: EXPR

Gets the value of the current minimum degree.

3.2  Monomials and polynomials in bergman

(MONINTERN LispFormMonomial)

: EXPR

Changes its argument from a Lisp form monomial to a monomial in the appropriate internal representation (augmonomial), and returns the changed monomial.

Warning: The output monomial may not be a printable LISP object.

(MONLISPOUT puremon)

: EXPR

Produces a Lisp form of its argument (pure monomial), without changing the argument.

(MONPRINT mon)

: EXPR

Prints its argument (an internally represented monomial) in algebraic form if the appropriate settings are done, else in Lisp form.

(MONLESSP Mon1:puremon, Mon2:puremon)

: EXPR

Evaluates the current admissible order. Note, that the result may be undefined (possibly erroneous) if Mon1 and Mon2 represent the same monomial or are of different total-degrees. Else, non-NIL iff Mon1 is less than Mon2 with respect to the active order.

(MONTIMES2 Mon1:puremon, Mon2:puremon)

: EXPR

The output represents the product Mon1 * Mon2 (in the given order).

(MONFACTORP Mon1:puremon, Mon2:puremon)

: EXPR

Decides whether or not the first puremon (pure monomial) is a factor of the second one. In the latter case, the output is non-nil, and may contain enough information for deciding in what manner the first one is a factor in the second. (In the non-commutative, there indeed may be several such ways.)

(TOTALDEGREE Mon:puremon)

: EXPR

Calculates the degree of the monomial (using the weights, if they are given).

(GETMONAUGPROP mon prop)

: EXPR

Returns T if prop is found, NIL else.

(REMMONPROP augmon prop)

: EXPR

Returns T if prop is found (whence removed), NIL else. Only the first occurrence of the prop property is removed from the monomial property list of augmon.

(ALGFORMINPUT)

: EXPR

Scans the succeeding input for variable lists and/or polynomial input on ALG form;

(LISPFORMINPUT)

: EXPR

Scans the succeeding input for variable lists and/or polynomial input on Lisp form;

(NORMALFORM ratpol)

: EXPR

Changes its argument to the ratpol representation of the normal form of its input (with respect to GBasis). Returns NIL if the normal form is zero, its changed argument else.

(POLALGOUT InternalFormPolynomial)

: EXPR

Prints its argument (an internally represented polynomial), in algebraic form if the appropriate settings are done, else in Lisp form.

(POLINTERN LispFormPolynomial)

: EXPR

Changes its argument from a Lisp form polynomial to a polynomial in the appropriate internal representation, and returns the changed polynomial if it is non-zero; else it returns NIL.

Warning: The output polynomial may not be a printable lisp object.

(QPOLMONMULT ratpol puremon)

: EXPR

Returns a ratpol representation of the product of ratpol and puremon (in this order), without changing its arguments.

(REDAND2LISPOUT Reductand-Polynomial)

: EXPR

Produces a Lisp form of its argument, without changing the argument.

(REDANDCF!+)

:EXPR

(REDANDCF!-)

:EXPR

(REDANDCF!-!-)

:EXPR

(REDANDCF!*)

:EXPR

(REDANDCF!/)

:EXPR

(REDANDCFREMAINDER)

:EXPR

(REDANDCFDIVISION)

:EXPR

Each of these EXPRs take one or two redandcoeffs as input, and perform the operations addition, negation ( = "unary minus"), subtraction, multiplication, truncated division, taking of remainder with respect to truncated division, and lastly performing both these operations at once returning CONS of the resulting truncated quotient and the remainder). The output is a redandcoeff (or a dotted pair of such), with NIL representing zero in the output; zero input is not permitted.

Using these procedures in most cases would be very slow compared to ordinary operations; thus they should be avoided.

(REDANDCFNEGATIVE)

: EXPR

Returns T if there is a meaningful concept of "negativity" in the coefficient domain and Cf is negative; NIL else.

(REDANDMONMULT augredand puremon)

: EXPR

Returns the augredand representation of the product of augredand and puremon (in this order), without changing its arguments.

(REDOR2LISPOUT Reductor-Polynomial)

: EXPR

Produce a Lisp form of its argument, without changing the argument.

(RATCF!- Cf)

: EXPR

Performs negation ( = unary minus).

(SHORTENRATCF Cf)

: EXPR

Changes Cf to a ßimple" representative for the same coefficient field element, and returns this changed input. (Thus destructive.) If the coefficient domain comprises an algorithm for calculating greatest common divisors, the ßimple" representative may be achieved by factoring out the GCD of the numerator and the denominator parts from both.

(INTEGERISE Line)

: EXPR

Each (non-NIL) ratcoeff in Line is replaced by a redandcoeff, representing some c times the element which the ratcoeff represents, using the same c for the whole list. Returns c.

(CFMONREDANDMULT Cf Mon Pol)

: EXPR

augredand : = Cf*Mon*Pol (non-destructively and in this order).

(LISPPOLS2INPUT)

: EXPR

(LISPPOL2REDAND)

: EXPR

(REDAND2LISPPOL)

: EXPR

(REDOR2LISPPOL)

: EXPR

(QPOL2LISPPOL)

: EXPR

(OUTPUT2LISPPOLS)

: EXPR

(REDANDALGOUT)

: EXPR

(REDANDALGIN)

: EXPR

(REDORALGOUT)

: EXPR

(REDORALGIN)

: EXPR

(QPOLALGOUT)

: EXPR

(PRINTQPOLRATFACTOR)

: EXPR

(PRINTRATCF)

: EXPR

3.3  Controlling the calculations process

(GROEBNERINIT)

: EXPR

Initiates various internal global variables, et cetera, before running GROEBNERKERNEL. It should be called after selecting modes and performing input.

(The reason why this is not a part of GROEBNERKERNEL, is that for some specialised applications (like reading in a partial Gröbner basis and continuing calculations from some high degree) one might want to hand-set these variables.)

(GROEBNERKERNEL)

: EXPR

Performs the main calculations. Should (normally) be preceded by GROEBNERINIT and succeeded by GROEBNERFINISH.

(GROEBNERFINISH)

: EXPR

Concludes the calculations; closes the DEGREEOUTPREPAREd file, if any; print out the entire basis, if DEGREEOUTPREPARE was not called and printing is customised; set some variables.

(Not a part of GROEBNERKERNEL for reasons similar to those for GROEBNERINIT.)

(CLEARIDEAL)

: EXPR

This removes MOST remaining memories of former calculations, such as remaining input, calculated (partial) Gröbner basis, and remaining critical pairs. It does not change the modes, nor the set input or output variables or embedding dimension.

(CLEARRING)

: EXPR

A more powerful function than clearideal, which clears also the list of input and output variables and their weights.

(CALCTOLIMIT PositiveInteger)

: EXPR

Continues the calculations different from Gröbner basis calculations until the given degree. Is used for the calculating Betii numbers or Hilbert series when Gröbner basis maximum degree is less than desired degree.

(STAGGERINIT)

: EXPR

Used in the SAWS mode for some extra initiations (after GROEBNERINIT, STAGTYPECHECKER, and AUTOREDUCEINPUT, but before STAGGERKERNEL).

(STAGGERKERNEL)

: EXPR

The SAWS mode replacement of GROEBNERKERNEL.

(STAGGERFINISH)

: EXPR

The SAWS mode replacement of GROEBNERFINISH.

(STAGTYPECHECKER)

: EXPR

Used in the SAWS mode for some mode settings.

(AUTOREDUCEINPUT)

: EXPR

This is used in the SAWS module, in order to auto-reduce the input (after reading in but before starting the Gröbner or SAWS basis calculation). It is unnecessary with the ordinary algorithms. If you are in SAWS mode and know that your input is auto-reduced anyhow, you may omit it.

(GETCURRENTDEGREE)

: EXPR

Returns the "current degree" (which is ordinarily set within the Gröbner basis routines), the total degree presently or last under Gröbner basis extension consideration. (Initially and immediately after the CLEARIDEAL, the current degree is NIL.)

(SETCURRENTDEGREE int)

: EXPR

For very special applications only, this procedure provides the user the possibility to set the internal "current degree" to int, which must be a non-negative integer or nil. (Cf. GETCURRENTDEGREE.)

WARNING: Changing the current degree in the middle of calculations, or during succeeding series calculations to higher degrees, might cause rather weird results.

(DEGREEOUTPREPARE file-name)

: FEXPR

(The argument is optional.)

Redirects output to be performed degree by degree (by DEGREEOUTPUT if printing is customised), by turning on DEGREEPRINTOUT. If given a file-name argument, and the file doesn't exist, output by DEGREEOUTPUT is directed to that file.

(ENDDEGREEOUTPUT)

: EXPR

Prints "Done", and closes the Gröbner basis output file (if any) opened with DEGREEOUTPREPARE. Is automatically called at the end of calculation of the entire Gröbner basis, if DEGREEPRINTOUT is on but there is no printing customisation.

(TDEGREECALCULATEPBSERIES PositiveInteger)

: EXPR

Only works if the associated monomial ring Poincare-Betti series has been calculated, but only to some degree less than PositiveInteger. It then causes a continued calculation up to and including PositiveInteger. (It returns NIL; use other ways of seeing the result.)

(AUTOADDRELATIONSTATE)

: EXPR

Informs if the automatic relations adding mode is chosen.

(SETAUTOADDRELATIONSTATE state)

: EXPR

Sets the automatic relations adding mode state to the given value.

(AUTOADDRELATIONS)

: EXPR

Sets the automatic relations adding mode.

(NOAUTOADDRELATIONS)

: EXPR

Cancels the automatic relations adding mode.

(ADDALGFORMINPUT)

: EXPR

New set of polynomials in algebraic form is added to those already saved in InPols.

(ADDLISPPOLS2INPUT)

: EXPR

New set of polynomials is added to those already saved in InPols.

(ADDLISPFORMINPUT)

: EXPR

New set of polynomials in LISP form is added to those already saved in InPols.

(FACTALGADDITIONALRELATIONS ll)

: EXPR

Adds special relations to the listll.

(HOCHADDITIONALRELATIONS ll)

: EXPR

Adds special relations to the list ll.

(ADDALGOUTMODE

mode-name bop+ bop- ip+ ip- ip* ip^ eop bol eol): FEXPR

If mode-name is not a recognised algebraic output mode name (to which you can set ALGOUTMODE), mode-name is added to the list of such names. The seven first of the remaining arguments are used in printing polynomials in this mode; the two last are at present only used in some specialised series output printing. The mnemonics are:

bop (eop) = beginning (end) of polynomial,

ip = within a polynomial,

bol (eol) = beginning (end) of list.

When a polynomial is output in mode mode-name, first bop+ or bop- (depending on the sign of the first coefficient) is printed; then the absolute value of the first coefficient, followed by ip*, if this absolute value is not 1; et cetera. The polynomial is ended by eop. (In alg mode, this has the bad effect of letting a comma follow also the last polynomial.)

(EXPTSPRINTMODE)

: EXPR

Chooses print mode with the collecting of the common factors to exponents.

(NOEXPTSPRINTMODE)

: EXPR

Chooses print mode when each factor is printing separately.

(BIGOUTPUT)

: EXPR

Causes the printing of the calculated Gröbner Basis, in LISP form if algoutmode has not been set to alg, macaulay, or a user defined algebraic output mode. (See also addalgoutmode.)

(DEGREEENDDISPLAY)

: EXPR (User defined option.)

Since control over output seems to be a very much wished possibility, the user is given the option of defining his/her own degree-wise output procedure. This procedure is performed after the calculation of one degree, if we are in the customised displaying mode. It then replaces other output; but you may call (e.g. DEGREEOUTPUT within it, see 2.14 for details.)

(DEGREEPBSERIESDISPLAY)

: EXPR

Prints the last degree item on DEGREEPBSERIES in an algebraic format, using the TDEGVARIABLE and HDEGVARIABLE values as names for the total degree and the homological degree variables, respectively.

(DEGREEOUTPUT)

: EXPR

Performs output of the newly calculated Gröbner basis elements (of the current degree). If DEGREEOUTPREPARE has been given a file name argument, output is directed to that file.

Is automatically called at the end of calculations for each degree, if DEGREEPRINTOUT is on but the printing process is not customised.

(NCPBHDED)

: EXPR

The DEGREEENDDISPLAY alternative definition used by
NCPBHGROEBNER.

(NCPBHDD)

: EXPR

Acts analogously as the previous one in the case when Gröbner basis is not printed.

(ALGOUTLIST listnvars)

: EXPR

Prepares variables to the algebraic form output.

(GETVARNO)

: EXPR

Gives the number of variables in the input (embedding dimension).

(SETVARNO (inum))

: EXPR

Sets the embedding dimension. Dangerous, but useful when Lisp form input was done and we need series calculations (e.g. in a free algebra, when there was no relations in the input).

(CLEARVARNO)

: EXPR

(INITVARNO u)

: EXPR Two (dangerous!) procedures to change embedding dimension interactively.

(PREPARETOANICK)

: EXPR

Switches several flags to the values necessary for Anick resolution computation.

(ANICKRES)

: FEXPR

Similarly with the previous one switches flags and checks the correctness of the input file in the case when input is performed by meaning of a file.

(PRINTBETTINUMBER btnumber)

: EXPR

Prints Betti number btnumber as follows:

B(homological degree, total degree) = value

(PRINTBETTI)

: EXPR

Prints all the calculated Betti numbers, applying the procedure printbettinumber to all elements of the anBETTINUMS list.

(PRINTCURRENTBETTI)

: EXPR

Prints Betti numbers for the last calculated Gröbner basis degree (applying the procedure PRINTBETTINUMBER to all elements of the anCURRENTBETTINUMS list)

(MACBETTIPRINT)

: EXPR

Prints Betti numbers in Macaulay form. Returns boolean value T.

(SETTENSPOLPRTSTRINGS strings)

: EXPR

The list strings should consist of 3 strings which are used to print tensor product. First string is printed at the beginning, second - as a tensor multiplication sign and the third - as the ending of thensor monomial. The list of 3 strings of old settings is returned.

(GETTENSPOLPRTSTRINGS)

: EXPR

Returns a list of 3 strings which are used when tensor monomials are printed as beginning, middle and ending strings.

(SETEDGESTRING strng)

: EXPR

The string strng is taken for printing as edges when chain vertexes are printed. The old value of it is returned.

(GETEDGESTRING)

: EXPR

Returns the value of string which is printed between chain vertexes.

(PRINTNEWCHAINSDIFF chan)

: EXPR

Prints differentials for the new generated chains to the channel chan.

(PRINTCHAINSDIFF chan)

: EXPR

Prints differentials for the all generated chains to the channel chan.

(PRTCHNDIFF inchain)

: EXPR

Prints differential for the chain inchain in form
D (chain length, chain) = differential

(GETBETTINUMS)

: EXPR

Returns the list of Betti numbers.

(GETBTORDER btnumber)

: EXPR

Returns the order of Betti number btnumber.

(GETBTDEGREE btnumber)

: EXPR

Returns the degree of Betti number btnumber.

(GETBTVALUE btnumber)

: EXPR

Returns the value of Betti number btnumber.

(CLEARRESOLUTION)

: EXPR

Calls ResolutionDone and ResolutionClear procedures.

(ANICKDISPLAY )

: EXPR

Prints the Betti numbers into the result file.

(CALCULATEANICKRESOLUTIONTOLIMIT limdeg)

: EXPR

Continues the process of Anick resolution calculation up to the degree limdeg. It maybe called after the Gröbner basis is calculated, in case it is finite and calculations stopped at a lower degree than that to which the Anick resolution should be calculated.

(PRINTCHAIN chain)

: EXPR

Prints chain. The vertices are printed as monomials (corresponding to the present ALGOUTMODE and minor output mode settings). If PRINTEDGESTRING is ON, then between vertices it prints the value of anEDGESTRING.

(PRETTYPRINTSDP pol)

: EXPR

Prints the semi-distributed polynomial pol in a form decided by the tensor polynomials print-mode. (See gettenspolsprintmode).

(PRINTTENSORPOLSDISTRIBUTED)

: EXPR

Selects distributed form for printing semi-distributed polynomials.

(PRINTTENSORPOLSSEMIDISTRIBUTED)

: EXPR

Selects semi-distributed form for printing semi-distributed polynomials.

(GETTENSORPOLSPRINTMODE)

: EXPR

Returns the identifier which is a keyword either DISTRIBUTED or SEMIDISTRIBUTED. This identifier points out how the current semi-distributed polynomials are printed.

(MPRINT mat)

: EXPR

Prints mat as a matrix to standard output and returns T, if that is not NIL. Else it prints nothing and returns NIL.

(CFLINEPRINT ln)

: EXPR

Prints the list of coefficients ln in one line and returns T ifln is non-NIL. Else it prints nothing and returns NIL.

(RANK mat)

: EXPR Returns the rank of mat calculated in present coefficient field.

(INPUTMATRIX2REDANDMATRIX mtrx)

: EXPR

Modifies the elements of mtrx so that their type is of acceptance by further procedures.

(MEMBER2NIL element list)

: EXPR

Searches list for its first occurrence of element. If found, the occurrence is (destructively) replaced by NIL, and the number of the position of element in list is returned. If element is not found in list, NIL is returned.

(BIGARITHP)

: EXPR

"Big Arithmetics Property". Should return T if big arithmetics work, NIL else.

(CALCREDUCTORPRIORITY augmon)

: EXPR

When this procedure is called, the pointer of the input monomial is set to a new Gröbner basis element. The procedure should return an integer. Such 'priority' integers later may be used in order to compare Gröbner basis elements in order to decide which one of them to employ in a reduction. A Gröbner basis element with lower 'priority number' is preferred.

By redefining this procedure, the user thus may influence the reductions of other polynomials, and the choices of what critical pairs to consider.

(It should be noted, however, that 'priority comparisons' are made only in some situations.)

(INPOLS2GBASIS)

: EXPR

If a gbasis is read in (as InPols), it is moved to GBasis. You then may make a new input, and start reducing.

3.4  The commutative Hilbert series procedures

• If f(d) is nil, then GROEBNERKERNEL follows "procedures as usual" for the current degree d (with no non-ordinary constraints on the calculations).
• If f(d) is t, then GROEBNERKERNEL is exited without any further calculations. (Thus we get an effect similar to a MAXDEG setting, but probable with some unnecessary critical pair calculation performed on degree d or higher.)
• If f(d) is skipcdeg, then the current degree d is ßkipped": critical pairs and input polynomials of degree d are removed, as if they (or the corresponding S-polynomials) were found to reduce to zero. (A new test is made for the next occurring degree.)
• If f(d) is a non-negative integer, then calculation at degree d continues only until either all input polynomials and critical pairs of degree d are processed, or the associated quotient ring Hilbert series value for d, i.e., the vector space dimension of the degree d component of the factor-ring of the current polynomial ring modulo the ideal generated by the leading monomials of all (partial) Gröbner basis elements found so far, no longer exceeds f(d); the the remaining input polynomials and critical pairs of degree d (if any) are skipped (like in the skipcdeg case).

        (COND ((GREATERP HSDEG 10) T)
              ((LESSP HSDEG 3) SKIPCDEG)
              (T (PLUS HSDEG 2)))

(CALCPOLRINGHSERIES varno)

: EXPR

Initialises HILBERTNUMERATOR and HILBERTDENOMINATOR values to those for the present polynomial rings. Right now, varno isn't used; instead, the numbers of variables is extracted by means of GETVARNO.

(CALCRATHILBERTSERIES)

: EXPR

Uses the calculated (full or partial) Gröbner basis in order to calculate the Hilbert series for the factor-ring modulo the ideal generated by the leading monomials of the basis elements. Errs if no (partial) Gröbner basis is stored in GBasis.

(CLEARPBSERIES)

: EXPR

Sets all series variables to nil.

(PBINIT)

: EXPR

Sets constant and linear terms for all series variables.

(GBASIS2HSERIESMONID)

: EXPR

Creates a special kind of lisp form representation of the monomial ideal generated by the leading monomials of the calculated (full or partial) Gröbner basis. The format is a (printable) list of flagged monomials (FMon's), as described in the introduction to the source file hseries.sl.

(GETHSERIESMINIMA)

: EXPR

Extracts the full information about the pre-stored Hilbert series limitation, in a printable format acceptable as input to SETHSERIESMINIMA.

(GETHSERIESMINIMUM tdeg)

: EXPR

Extracts the information about the pre-stored Hilbert series limitation for degree tdeg, as an integer or as one of the constants NIL, T, and SKIPCDEG. (tdeg must be a non-negative integer; else, rather weird errors may occur.)

(SETHSERIESMINIMA)

: FEXPR

Specifies the Hilbert series limitations, as a sequence of dotted pairs or as a list of limitation constants, in either case optionally accompanied by a DEFAULT setting. In the dotted pair variant, each dotted pair antecedent ("CAR part") should be a non-negative integer or the identifier DEFAULT; the postcedent ("CDR part") when the CAR is an integer d should be the limitation for d (i.e., a non-negative integer or one of the constants NIL, T, and SKIPCDEG), and when the CAR is DEFAULT it should be of the SETHSERIESMINIMUMDEFAULT input form. In the sequence case, the items are considered as CDR parts corresponding to CAR parts 0, 1, 2, ... (in this order); everything after DEFAULT is considered as the DEFAULT CDR part (whether or not it is on list form). In either case, the default value or procedure is changed only if a new DEFAULT is specified.

Example:

(SETHSERIESMINIMA T SKIPCDEG NIL 6 7 8 9 DEFAULT 8)

and

(SETHSERIESMINIMA (0 . T) (1 . SKIPCDEG) (2) (3 . 6)
                       (4 . 7) (6 . 9) (DEFAULT . 8))

have the same effects. (Note that in lisp, (2) and (2 . NIL) are considered as identical.)

(SETHSERIESMINIMUMDEFAULT)

: FEXPR

Specify the Hilbert series limitation default value or procedure. (Explicitly specified values for specified degrees are not changed.)

(SERIESPRINTING)

: EXPR

Calculates and prints the power series coefficients.

(TDEGREEHSERIESOUT PositiveInteger)

: EXPR

Returns the Hilbert function (i. e. Hilbert series coefficient) for PositiveInteger (provided adequate series calculation up to that degree is done previously). If necessary, induces calculations of HILBERTSERIES and INVHILBERTSERIES items.

(REVERTSERIESCALC)

: EXPR

Should be given the last total degree for which series were calculated as an argument, or possibly a higher value. If so, all effects of (possibly) having calculated the Hilbert series, associated monomial ring double Poincare-Betti series, et cetera, should be canceled; except induced calculations in lower total degrees.

3.5  User available flags

CUSTDISPLAY

 

If it is turned on (by the procedure setcustdisplay) we get several customised display actions:

• GROEBNERKERNEL exhibits output degree by degree, by means of the user customised procedure DEGREEENDDISPLAY. (This is intended for customisation. There may exist an exemplifying definition, showing how to demand some statistics at each end of degree; if so, you could read it with (GETD DEGREEENDDISPLAY).)
• If furthermore the user has defined CUSTDISPLAYINIT, then this procedure (with no argument) replaces the normal displaying initiation actions performed when executing GROEBNERINIT. (These normal actions are to set NOOFSPOLCALCS and NOOFNILREDUCTIONS to zero.)
• If the user has defined CUSTCLEARCDEGDISPLAY, then this procedure (with no argument) is called first within a CLEARCDEGREEGKINPUT call.
• If the user has defined HSERIESMINCRITDISPLAY and the MINHILBLIMIT strategy mode is active, then when this strategy leads to the abortion of the rest of the calculations at the current degree (since the last possible new Gröbner basis element is just found) HSERIESMINCRITDISPLAY (with no argument) is called.

CUSTSTRATEGY

 

WARNING: Don't turn this ON unless you have familiarised yourself with the internal programming of bergman! If it is turned on and if the user has defined one or several of the following procedures, calling them supplants the action of the following procedures (see also 2.14):

• CUSTNEWINPUTGBEFIND supplants the action of FindInputNGbe;
• CUSTCRITPAIRTONEWGBE supplants the action of FindCritPairNGbe;
• CUSTENDDEGREECRITPAIRFIND supplants the action of
  DEnSPairs;
• CUSTNEWCDEGFIX supplants the action of FixNcDeg.

It is possible to get the 'true' action of the bergman procedure to be performed, by the 'PROG variable initiation trick'. Whenever a variable is declared as a PROG variable, it is locally bound to NIL. Thus e.g. the following bit of Standard Lisp code

(OFF RAISE)
(DE CUSTENDDEGREECRITPAIRFIND ()
 (PROG  (!*CUSTSTRATEGY)
        <action 1>
        (DEnSPairs)
        <action 2> ))
(ON RAISE)

defines CUSTENDDEGREECRITPAIRFIND in such a way, that when CUSTSTRATEGY is ON a call to DEnSPairs yields the following effect: First < action 1 > is taken, then DEnSPairs is called recursively but with CUSTSTRATEGY OFF (if < action 1 > didn't turn it ON), performing its ordinary action, and last < action 2 > is taken.

DEGREEPRINTOUTPUT

 

Only influential when the SAWS algorithm is used. Then makes the final reduced Gröbner basis be exhibited degree by degree, with separating degree annotations, as in `ordinary' degree-wise output. (C.f. SAVEDEGREE.)

DYNAMICLOGTABLES

 

When MODLOGARITHMIC is chosen and (SETMODULUS prime) is executed with an odd integer as prime, and a saved logarithms table file is not found, then logarithm tables are constructed. If DYNAMICLOGTABLES is OFF, this is done in a subshell, writing a file which is read into the bergman session but also saved for future use. If it is ON, then the tables should be constructed directly (and ephemerally). (The dynamic logtables creation is not yet implemented.)

IMMEDIATECRIT

 

Turned ON/OFF by NONCOMMIFY/COMMIFY. Tries to eliminate critical pairs (employing various criteria) as soon as a degree is finished, instead of waiting until the degree of the pair is reached. Should NOT be turned ON in the commutative case!

IMMEDIATEFULLREDUCTION

 

Default: ON. Immediate full reduction of `old' Gröbner basis elements by means of newfound ones. (This is at variance with many other systems, where a preliminary Gröbner basis element will not be changed once it is entered.)

IMMEDIATERECDEFINE

 

Intended meaning: When calculating PBseries, define the recursive monomial-bound sub-series while these monomials anyhow are considered from the critical pair point of view. This option is not fully implemented, however, so the flag should NOT be turned ON.

MONOIDAL

 

Used in some experimental variant to signify that we actually work within the monoid of monomials; i.e., that all relations are pure binomial. If this work is ever included into the general bergman framework, probably it will be in the form of mode changing procedures rather than by flag-setting, though.

NOBIGNUM

 

Inhibit automatic loading of the bignum package. If you "know" that no bignums will be needed in your particular run (although it e. g. is in characteristic zero or the Hilbert series is calculated), you may turn it ON BEFORE initialisations or mode-changings have invoked it.

(Note that in your installation the Bignum package may already be loaded from start, in which case the flag should be on by default. This is probable, if you run bergman under Reduce.)

PBSERIES

 

Turned ON/OFF by SETPBSERMODE. Should NOT be ON in the commutative case. Calculate the Poincaré-Betti series of the associated monomial ring (total degree-wise) (with a method ONLY WORKING IN THE NON-COMMUTATIVE CASE)! Its effects are partially superceeded by turning CUSTDISPLAY ON - take care that your DEGREEENDDISPLAY calls e. g. TDEGREECALCULATEPBSERIES in this case. Should be ON if Hilbert series or Anick resolution are to be calculated in the non-commutative mode.

POSLEADCOEFFS

 

Default: ON. In the characteristic 0 case, make sure that the final reduced Gröbner basis element leading coefficients are positive. (Turning it OFF saves very little calculation, but makes the result compatible with results from older versions of bergman.)

REDUCTIVITY

 

Turned ON when the SAWS module is loaded. Inhibits the `cannibalising' garbage collection of lower degree monomials, thus making it possible to use the Gröbner basis for calculating normal forms. It may be turned ON for this purpose, or because the `cannibalism' may have unwanted side effects in the context.

SAVEACCIDENTALREDUCIBILITYINFO

 

Only active within the SAWS mode. If ON, save and re-use information on whether or not a leading monomial is divisible by another Gröbner basis leading monomial (disregarding substance).

SAVEDEGREE

 

Turned ON/OFF by
DEGREEOUTPREPARE/ENDDEGREEOUTPUT. Make GROEBNERKERNEL exhibit output degree by degree, by means of the inbuilt procedure DEGREEOUTPUT. In general, the final result is output. However, if the SAWS algorithm is active, it is the preliminary (staggered linear) basis which is output. In this case, the final reduced Gröbner basis is NOT calculated degree-wise, and so no speed is gained by exhibiting output degree-wise. If you anyhow wish such output (e. g., for compatibility reasons), you may turn ON DEGREEPRINTOUTPUT.

SAVERECVALUES

 

Default: ON. In the Poincaré-Betti series algorithm, numerous interdepending integer series are defined by linear recursion formulae. When the flag is ON, the calculated values at each degree are saved. This saves (considerable) time, but sometimes may use considerable space.

3.6  User available counters

NOOFNILREDUCTIONS

 

Counts the total number of times the normal form procedure ("ReducePol") is called with an argument representing the zero polynomial. (Ordinarily, this happens precisely whenever a new-formed S-polynomial is zero before reduction.)

NOOFREPRIORITATIONS

 

In the SAWS algorithm, counts the number of times `all' the prioritation values must be changed, in order to enable new (integer!) values between two old ones.

NOOFSPOLCALCS

 

Counts the number of S-polynomials actually formed. Together with a counting of the final basis (except the input), this gives a good measure of the efficiency of the critical pair elimination criteria.

NOOFSTAGCONECRIT

 

Counts the number of applications of a SAWS algorithm elimination criterion.

Chapter 4
Some useful appendixes

4.1  Bergman proceedings extending
Standard Lisp

4.1.1  Introduction

4.1.2  Fast variant Standard Lisp extensions

BMI!+ <--> PLUS2
BMI!- <--> DIFFERENCE
BMI!* <--> TIMES2
BMI!/ <--> QUOTIENT
BMI!< <--> LESSP
BMI!= <--> EQ
BMI!> <--> GREATERP
FASTGETV <--> GETV

4.1.3  General Standard Lisp extensions

(ADDINTTOLIST i lint)

 

i should be a number, and lint a list (i₁ i₂ i₃ …) of numbers. The list (i₁+i i₂+i i₃+i…) is returned.

(APPENDLCHARTOID lch id)

: EXPR

lch should be a list of characters, id an identifier. Returns an interned identifier, whose print name consists of the characters on lch followed by the print name of id.

(APPENDNUMBERTOSTRING numb strng)

: EXPR

A new string is formed, consisting of the characters in the string strng followed by the characters (sign if negative, digits, et cetera) in the print form of the number numb.

(APPLYIFDEF0 lexprid)

: EXPR

lexprid should be a list of identifiers. Each of these (in order) is tested for a function definition, and if one is found, the function is applied on an empty list. (Thus any one of the identifiers being defined should be an EXPR with no arguments.)

(ASSIGNSTRING id string)

: EXPR

Checks if string is a string, and then assignis it as the value of id, returning the old value. Else, prints a warning message, and returns NIL. id is neither checked for being an identifier, nor for having a value.

(ATSOC any alist)

: EXPR As ASSOC, but tests if any equals the car of a dotted pair on alist with EQ instead of EQUAL.

(BMDATING)

: EXPR

If available returns a string informing on the present date and time. (If not available, the returned string informs on this fact.)

(CALLSHELL filstr lst)

: EXPR

Makes a system call with the calling command name given by the string filstr and the arguments by the items of the list lst. (These items are represented by their print forms.)

(CIRCLENGTH any)

: EXPR

Sets !*CSTRUCTURE!*. Extends length measurement from ordinary lists to arbitrary s-expressions, including circular lists. Returns the number of CDR's possible until an atom is achieved (in which case !*CSTRUCTURE!* is set to NIL), or a former CDR is repeated (in which case !*CSTRUCTURE!* is set to T). Thus, (1 2 3 4) has circlength 4; (1 2 . 3) has circlength 2; and if we have
A= (1 2 3 4 3 4 3 4 ...) (with (CDDR A) EQ to (CDDDDR A), then A has circlength 2.

(CDRADD1 alist)

: EXPR

alist should be an association list with numeric CDRs of items. Each such CDR c is replaced by (ADD1 c). (Unspecified return value.)

(CONSTANTLIST2STRING lst)

: EXPR

Returns a string consisting of the print forms of the items on the list lst, separated by spaces.

(COPY any)

: EXPR

Returns a recursively constructed copy of the S-expression any. Dotted pairs are copied to new ones, until atoms are encountered. In other words, COPY behaves as if defined by

(DE COPY (any)
 (COND  ((PAIRP any) (CONS (COPY (CAR any)) 
                           (COPY (CDR any))))
        (T any))) 

(COPYD imgid srcid)

: EXPR

Both arguments should be identifiers; the second one should be a function name. COPYD copies the function definition from srcid to imgid. (Unspecified return value.)

(DEFP id)

: MACRO

Returns non-NIL iff has a function definition.

(DELQ lst any)

: EXPR

As DELETE, but tests if any equals an item on lst with EQ instead of EQUAL.

(DEGLIST2LIST dlist)

: EXPR

Returns the items of a degree list (but not the degree numbers) in one list, ordered in the way they come in the degree list.

(DPLISTCOPY alist)

: EXPR

Returns a copy of the association list alist; but copying is done on the top list level and on thealist dotted pair items top level. (In other words, in (DPLISTCOPY '(((1 2) 3 4))), the old and new ((1 2) 3 4) parts won't be EQ, but both the (1 2) and the (3 4) parts will be.)

(DPLISTP any)

: EXPR

Returns non-NIL iff any is an association list (i.e., a list of dotted pairs).

(DSKIN filen)

: EXPR

Open the file with name filen; reads, evals, and prints successively each s-expression therein (if not redirected as some evaluation side effect) until end-of-file is reached, and closes the file. (Unspecified return value.)

(EVENP no)

: EXPR or MACRO

Returns non-NIL iff the integer no is even.

(FASTGETV vect no)

: MACRO

Returns (GETV vect no) if the input is correct, but may be faster due to the elimination of some error checks.

(FILEP filstr)

: EXPR or MACRO

Returns non-NIL if filstr is a legal file name of an existing file. (In some versions, where this is not so easily done, it may always returns non-NIL.)

(FLIPSWITCH id boole)

: EXPR

Id must be an identifier, and be assigned a value. Id is assigned NIL if boole is NIL, T else; and the old value of id is returned.

(FLUSHCHANNEL chn)

: MACRO

Flush the output to the output channel (stream) chn.

(IBIDNOOPFCN any)

: EXPR

Just returns any. (Useful with COPYD in case some no-operator variants are wanted in some modes.)

(LAPIN filen)

: EXPR

Open the file with name filen; reads and evals successively each s-expression therein (if not redirected as some evaluation side effect) until end-of-file is reached, and closes the file. (Unspecified return value.)

(LASTCAR lst)

: EXPR

Returns the last item of the list lst.

(LASTPAIR (list) (COND ((NULL (CDR list)) list)

 

Returns the last top level pair (consisting of the last item and NIL) of the list lst.

(LCONC ptr lst)

: EXPR

ptr should be a dotted pair consisting of a list and of its LASTPAIR. This list is concatenated with the list lst, and the CDR of ptr is changed to the LASTPAIR of the prolonged list. (lst may be NIL.) (Unspecified return value.)

(LISTCOPY lst)

: EXPR

Returns a copy of the list lst; but copying is done only on the top list level.

(LISTONENOOPFCN0)

: EXPR

(LISTONENOOPFCN1 any)

: EXPR

(LISTONENOOPFCN2 any1 any2)

: EXPR

Just returns a freshly constructed list. (Useful with COPYD in case some no-operator variants are wanted in some modes.)

(LOADIFMACROS lid)

: FEXPR

For each identifier (member of lid), checks whether this is function bound to a macro, defined as a lambda expression. If so, eval this expression (with NIL bound as argument). This is only intended for 'self loading MACROs', where it efficiently forces the intended loading (and replacement of the MACRO definition by an EXPR or FEXPR one), without or before calling the function. (Useful in case self loading MACROs are called in compiled code as EXPRs or FEXPRs. Since the 'self loading MACRO' trick is principally intended for use with top level procedures, this should rarely happen.)

(MERGESTRINGS string string)

: EXPR

Returns the concatenation of the two strings.

(MINUSP no)

: EXPR or MACRO

Returns non-NIL iff the number no is negative.

(NCONS any)

: EXPR or MACRO

Returns (CONS any NIL).

(NILNOOPFCN0)

: EXPR

(NILNOOPFCN1 any)

: EXPR

(NILNOOPFCN2 any1 any2)

: EXPR

(NILNOOPFCN3 any1 any2 any3)

: EXPR

(NILNOOPFCN4 any1 any2 any3 any4)

: EXPR

Just returns NIL. (Useful with COPYD in case some no-operator variants are wanted in some modes.)

(OFF id)

: FEXPR

Sets the identifier whose name is the name of the identifier id preceeded by an asterisk ( * ) to NIL. (Unspecified return value.)

(ON id)

: FEXPR

Sets the identifier whose name is the name of the identifier id preceeded by an asterisk ( * ) to T. (Unspecified return value.)

(ONENOOPFCN1 any)

: EXPR

(ONENOOPFCN2 any1 any2)

: EXPR

Just returns 1. (Useful with COPYD in case some no-operator variants are wanted in some modes.)

(PAIRCOPYD alist)

: EXPR

alist should be an association list of identifiers; the second one in each pair should be a function name. PAIRCOPYD copies the function definition from the second identifier to the first one in each of the pairs. (Unspecified return value.)

(PNTH lst no)

: EXPR

lst should be a list of LENGTH greater than or equal to the positive integer no. Returns the no'th top level pair of the list (so that (PNTH lst 1) is EQ to lst, (PNTH lst 2) is EQ to (CDR lst), et cetera).

(PRINTX any)

: EXPR

Sometimes succeeds in printing an "unprintable object".

(PROMPTREAD string)

: EXPR

A READ is performed, and the result returned. If reading is connected with prompting, the string should be used for prompt.

(PRUNEFIRSTDEGREEITEM dlany int)

: EXPR

dlany must be a non-empty degree list. If the first degree appearing on dlany is int, then (CDR dlany) is returned; else, dlany is returned.

(RECLAIM)

: EXPR or MACRO

Performs a garbage collection. (May be a no-operator in some versions.) (Unspecified return value.)

(SETVECTPROG id no)

: EXPR

Creates a new vector of length no + 1 and name id, and successively reads the next no + 1 s-expressions (without evaluation), assigning the vector entries to these. (Unspecified return value.) (Useful for reading in very large vectors without overtaxing the recursive depth of the lisp reader.)

(SETPROMPT string)

: EXPR

Set the prompt string to prompt.

(STRIPEXPLODE atm)

: EXPR

Returns the same as EXPLODE on the atom atm, except that if atm is a string its enclosing double quotes are removed.

(TCONC ptr any)

: EXPR

ptr should be either a dotted pair consisting of a list and of its LASTPAIR, or NIL. This list is concatenated with a new dotted pair formed by any and NIL, and the CDR of ptr is changed to this dotted pair. If ptr is NIL, then a list of the one element any is formed, and the dotted pair of this list and its LASTPAIR (i.e., itself) is returned; else (the modified) ptr is returned.

(TCONCPTRCLEAR ptr)

: EXPR

ptr should be a dotted pair consisting of a list and of its LASTPAIR, as returned by successive applications of TCONC. This is modified by removing all after the first element of the list. The modified ptr (which now is EQUAL to the result of (TCONC NIL (CAAR ptr))) is returned.

(TIME)

: EXPR or MACRO

Returns an integer more or less measuring the "cpu time" of the bergman session until now. (Not necessarily available in all versions.)

(TNOOPFCN1 any)

: EXPR

Just returns T. (Useful with COPYD in case some no-operator variants are wanted in some modes.)

(UNION lst1 lst2)

: EXPR

Returns a list containing the elements in the list lst1 and lst2, avoiding repetitions of EQUAL members of both lists. (If several members in one of the lists are equal, then however this `'redundancy" may be carried over to the new list.)

(ZEROP any)

: EXPR

Returns non-NIL iff any is EQN to the number 0.

4.2  Formal description of bergman

4.2.1  Organisation of the programme source files

4.2.2  Overview of the (main) units and source files

4.2.3  Basic structures and naming conventions

4.2.4  Global structures and programme outline

• InPols, the input polynomials (the original ideal basis);
• cInPols, ditto of current degree;
• SPairs, the pairs of LeadMons to investigate;
• cSPairs, ditto of current degree;
• GBasis, the Gröbner basis; and
• cGBasis, the new Gröbner basis elements (of current degree).

While InPols or SPairs is non-empty do
 begin
  cDeg:= the lowest existing degree in InPols and/or SPairs
         ( = min(caar(InPols),caar(SPairs)), if both exist);
  Move the cDeg component(s) of InPols and/or SPairs to cInPols
  and/or cSPairs, discarding their cars (i.e., degrees);
  While cInPols or cSPairs is non-empty do
   begin
    If cSPairs is empty, or if car(cInPols) exists, and its
        LeadMon   is strictly of lower order than car(cSPairs),
     then process car(cInPols), and remove it from cInPols,
     else
      begin
       SP2r:=SPolInputs(car(cSPairs));
       For (a.b) in SP2r do
           process the S-polynomial POINTER(a)-POINTER(b);
      end;
   end;
  For mon in cdr(cGBasis) do 
         PRIORITY(POINTER(mon)):=length(POINTER(mon));
  If CUSTDISPLAY is ON then call DEGREENDDISPLAY,
   else if SAVEDEGREE is ON then call DEGREEOUTPUT;
  Consider new LeadMon-pairs among the new gbe's;
  Call MonReclaim;
 end;

begin
 NGroeb := ReducePol(pol) (i. e., the normal form of pol);
 If NGroeb $\ne $ 0 then (we indeed have a new gbe, whence:)
   begin
    POINTER(LeadMon(NGroeb)) := NGroeb;
    NGroeb := LeadMon(NGroeb);
    Consider new LeadMon-pairs formed by
             NGroeb and the old gbe's;
    Insert NGroeb on its proper place in cdr(cGBasis);
    If IMMEDIATEFULLREDUCTION is ON,
      then reduce other new gbe's w. r. t. NGroeb;
   end;
end;

4.3  Mathematical background

Bibliography

[1]

W.W.  Adams, P.  Loustaunau. An Introduction to Gröbner Bases. - Vol. 3. Graduate Studies in Mathematics - Providence, RI: AMS, 1966.

[2]

D. Anick. On the homology of associative algebras. // Transactions of the American Mathematical Society, v. 296, Nr. 2, 1986. - P. 87-112.

[3]

J. Backelin, S. Cojocaru, V. Ufnarovski. The Computer Algebra Package Bergman: Current State. / In: J. Herzog, V. Vuletescu (eds.). Commutative Algebra, Singularities and Computer Algebra. - Kluwer Academic Publishers, 2003. - P. 75-100.

[4]

T. Becker, V. Wespfening. Gröbner Bases. A Computational Approach to Commutative Algebra. - Graduate Texts in Mathematics 141. - Berlin, Heidelberg, New York: Springer-Verlag, 1993.

[5]

Buchberger, B. On Finding a Vector Space Basis of the Residue Class Ring Modulo a Zero Dimensional Polynomial Ideal (German).- PhD Thesis, Univ of Innsbruck, Austria, 1965

[6]

S. Cojocaru, A. Colesnicov, L. Malahova. Network version of the computer algebra system bergman. // Computer Science Journal of Moldova, v.10, Nr. 2(29), 2002. - P. 216-222.

[7]

S. Cojocaru, V. Ufnarovski. Noncommutative Gröbner basis, Hilbert series, Anick's resolution and BERGMAN under MS-DOS. // Computer Science Journal of Moldova, v. 3, Nr. 1(7), 1995. - P. 24-39.

[8]

D. Eisenbud, D.R. Grayson, M.E. Stillman, and B. Sturmfels (eds.). Computations in algebraic geometry with Macaulay 2. - Berlin, Heidelberg, New York: Springer-Verlag, 2001. - ISBN 3-540-42230-7.

[9]

R.  Fröberg. An Intriduction to Gröbner Bases. - Chichester : John Wiley, 1997.

[10]

J. Grabmeier, E. Kaltofen, V. Wiespfenning (eds.). Computer Algebra Handbook. - Berlin, Heidelberg, New York: Springer-Verlag, 2003. - ISBN 3-540-65466-6.

[11]

E.L.  Green. An Introduction To Noncommutative Gröbner bases. / In: Fisher K.G. (ed.), Computational Algebra, Dekker, New York, 1994. (Lect. Notes Pure Appl. Math, 151): 167-190

[12]

E.L. Green, L.S. Heath, and B.J. Keller. Opal: A system for computing noncommutative Grobner bases. / In: H. Comon (ed.). RTA-97. - LNCS Nr. 1232. - Springer-Verlag, 1997.

[13]

G.-M. Greuel, G. Pfister, and H. Schönemann. Singular 2.0. A Computer Algebra System for Polynomial Computations. Centre for Computer Algebra, University of Kaiserslautern (2001). http://www.singular.uni-kl.de.

[14]

A. C.  Hearn: REDUCE User's and Contributed Packages Manual, Version 3.7, February 1999. Available from Konrad-Zuse-Zentrum Berlin, Germany.

[15]

N. Kajler (ed.). Computer-Human Interaction in Symbolic Computation. - Wien, New York: Springer-Verlag, 1998. - ISBN 3-211-82843-5.

[16]

M.  Kreuzer, L.  Robbiano. Computational Commutative Algebra 1,2. - Heidelberg: Springer-Verlag, 2000, 2004.

[17]

C. Löfwall, J.-E. Roos. A nonnilpotent 1-2-presented graded Hopf algebra whose Hilbert series converges in the unit circle. // Adv. Math. 130 (1997), Nr. 2. - P. 161-200.

[18]

J.  Marti, A.C. Hearn, M.L. Griss, C. Griss: The Standard Lisp Report, ACM SIGPLAN Notices archive. Volume 14, Issue 10 (October 1979) P. 48-68 (see also: http://www.uni-koeln.de/REDUCE/3.6/doc/sl/)

[19]

T.  Mora, G. Pfister, C. Traverso. An Introduction to Tangent Cone Algoritm. / In: Issues in non-linear geometry and robotics. - JAI Press 6, 1992. - P.  199-270.

[20]

J.-E. Roos, B. Sturmfels. A toric ring with irrational Poincaré-Betti series. C. R. Acad. Sci. Paris, Sér. I Math. 326 (1998), no. 2. - P. 141-146.

[21]

J.-E. Roos. Some non-Koszul algebras. / In: Advances in geometry, Progr. Math., 172. - Boston, MA: Birkhäuser, 1999. - P. 385-389.

[22]

B.  Sturmfels. Gröbner Bases and Convex Polytopes. - AMS UNiversity Lecture Series 8. - Providence, 1995.

[23]

V. Ufnarovski. Introduction to Noncommutative Grobner Bases Theory. / In: Grobner Bases and Applications, London Mathematical Society Lecture Notes Series. 251. - London, 1998. - P. 259-280.

Web references

[24]

home page: http://www.math.su.se/bergman/

[25]

CoCoA: a system for doing Computations in Commutative Algebra, Available at http://cocoa.dima.unige.it

[26]

home page: http://felix.hgb-leipzig.de/

[27]

B. Keller's research page ():
http://people.emich.edu/bkeller/research.html

[28]

Link to : http://www.cs.vt.edu/~keller/opal/

[29]

home:
ftp://alice.fmi.uni-passau.de/pub/ComputerAlgebraSystems/mas/

Index (showing section)