| 1 |
\section{SELECTING MODES} \label{modes} |
| 2 |
|
| 3 |
\subsection{Variable names and the flag RAISE. Ordering } |
| 4 |
|
| 5 |
We start from the variables -- generators of our algebras (modules). |
| 6 |
Their names may be specified |
| 7 |
to almost any valid LISP identifiers. (Some special signs, like $*$ and |
| 8 |
$^,$ cannot be used unslashified in the identifier names.) |
| 9 |
So, not only usual letters such as x,Y may be used, but also |
| 10 |
x1,Y45 or even I\_ kiss\_ you\_ 1000\_ times can be used as a variable. |
| 11 |
But do not try $x[1]$ or $Y(2)$ as names! |
| 12 |
In any place you may have a look to your current list of variables: |
| 13 |
|
| 14 |
{\bf (GETINVARS)} |
| 15 |
\begin{exm} |
| 16 |
\begin{verbatim} |
| 17 |
6 lisp> (GETINVARS) |
| 18 |
(!x !y !z) |
| 19 |
\end{verbatim} |
| 20 |
\end{exm} |
| 21 |
|
| 22 |
|
| 23 |
One important question is if the names "y" and "Y" represent the same |
| 24 |
variable. The answer depend on the current value of the flag |
| 25 |
{\bf RAISE}. If it is in the state OFF, they are different, otherwise |
| 26 |
(if it is in the state ON) "y"="Y". |
| 27 |
|
| 28 |
The meaning of this flag is to translate all the letters to the |
| 29 |
capitals. Important notes, concerning this flag: |
| 30 |
\begin{enumerate} |
| 31 |
\item From very beginning the value of this flag is ON. That is |
| 32 |
why you can write {\bf (simple)} instead of {\bf (SIMPLE)} |
| 33 |
\item Most the procedures, available to user have capital names. |
| 34 |
Nevertheless several procedures turn OFF the flag while they |
| 35 |
are working. If break loop (for example because of mistake) |
| 36 |
happens during their work the value of the flag will be OFF |
| 37 |
and, for example, you will be unable to quit from the program |
| 38 |
writing |
| 39 |
|
| 40 |
{\bf (quit)} |
| 41 |
|
| 42 |
because in this case the name should be capitalised: |
| 43 |
|
| 44 |
{\bf (QUIT)} |
| 45 |
|
| 46 |
Another way to quit is |
| 47 |
|
| 48 |
{\bf (ON RAISE)} |
| 49 |
|
| 50 |
{\bf (quit)} |
| 51 |
|
| 52 |
\item Note, that turning ON this flag you loose access to all |
| 53 |
the procedures and variables with the names, containing small letter, |
| 54 |
such as SecretProcedure. Idea is that they should be unavailable |
| 55 |
to the usual user, being absolutely internal and private. Nevertheless |
| 56 |
user can sometimes see their names, where small letter are printed after |
| 57 |
exclamations: S!e!c!r!e!tP!r!o!c!e!d!u!r!e. Even the multiplication |
| 58 |
is secret in this mode and looks as !*. |
| 59 |
But normally you need not care about this and turn OFF the |
| 60 |
RAISE flag. |
| 61 |
|
| 62 |
|
| 63 |
\end{enumerate} |
| 64 |
The last important thing we should say about variables is their ordering. |
| 65 |
It is important for Gr\"{o}bner basis calculations which of variables is highest |
| 66 |
(largest). The rule is determined by the order of the variables, |
| 67 |
written after {\bf vars } in one of the top-of-the-top |
| 68 |
procedures and is as follows: |
| 69 |
\begin{itemize} |
| 70 |
\item in the noncommutative mode the last variable is always highest. |
| 71 |
\item in the commutative mode first variable is highest |
| 72 |
from the very beginning or after the |
| 73 |
calling the procedure |
| 74 |
|
| 75 |
{\bf (DEGLEXIFY)} |
| 76 |
|
| 77 |
\item in the commutative mode the last variable is highest after the |
| 78 |
calling the procedure |
| 79 |
|
| 80 |
{\bf (REVLEXIFY)} |
| 81 |
|
| 82 |
|
| 83 |
\end{itemize} |
| 84 |
|
| 85 |
% \begin{exm} -------------To be rewritten--------------------- |
| 86 |
% |
| 87 |
% Suppose that |
| 88 |
%\end{exm} {\bf setinvars x, y, z } |
| 89 |
% {\em was written. Then we have:} |
| 90 |
% \begin{itemize} |
| 91 |
% \item \verb+ y*z*z >x*z*y > x*y*y + in the noncommutative mode |
| 92 |
% \item \verb+ y*z*z >x*y*z (=x*z*y) > x*y*y + in the noncommutative mode |
| 93 |
|
| 94 |
%\end{itemize} |
| 95 |
|
| 96 |
\subsection{INPUT--OUTPUT MODES\\ FOR THE POLYNOMIALS} |
| 97 |
\label{inputform} |
| 98 |
|
| 99 |
There are three basic output formats, named LISP (default), ALG |
| 100 |
(its synonym is also MAPLE), and |
| 101 |
MACAULAY, corresponding to the formats, used in those 3 languages. |
| 102 |
The first two of these also are acceptable input formats. |
| 103 |
In all input and output, the polynomials are distributed (written with |
| 104 |
no parentheses). There is a difference between commutative and |
| 105 |
noncommutative case. |
| 106 |
\begin{description} |
| 107 |
\item{{\bf Commutative case}} |
| 108 |
|
| 109 |
The (output) ALG representation of the polynomial is |
| 110 |
$$c_1*v_1\wedge m_{11}*\ldots *v_n\wedge m_{1n}+ \ldots |
| 111 |
+ c_r*v_1\wedge m_{r1}* \ldots *v_n\wedge m_{rn} .$$ |
| 112 |
Here $v_1, \ldots , v_n$ stand for the variable names, $m_{ij}$ |
| 113 |
for the exponents, |
| 114 |
and $c_i$ for the coefficients. Highest terms will be printed first. |
| 115 |
|
| 116 |
Occurrences of $*v_i\wedge 0$ and of $\wedge 1$ are omitted. |
| 117 |
+ is omitted before $-$ . |
| 118 |
The MACAULAY representation is similar, but without $*$ and $\wedge$; and the |
| 119 |
polynomials then are not separated by commata. |
| 120 |
In input, some slight variation is allowed in the ALG format: |
| 121 |
\begin{itemize} |
| 122 |
\item $**$ may be used instead of $\wedge$; |
| 123 |
\item Blank space may be inserted everywhere, except within identifiers |
| 124 |
or integers or between two successive $**$ . |
| 125 |
\item Exponents 0 and 1 may occur. |
| 126 |
\item The order of the variables in a monomial is arbitrary. |
| 127 |
\end{itemize} |
| 128 |
|
| 129 |
|
| 130 |
The LISP representation of the same commutative polynomial in n variables is a |
| 131 |
lisp list of length n+1 lists of integers: |
| 132 |
$$((c_1\ m_{11}\ \ldots m_{1n}) \ldots (c_r\ m_{r1}\ \ldots m_{rn}))$$ |
| 133 |
where the CAR of the i:th list is the coefficient of the i:th monomial, |
| 134 |
and the other n integers (which should be non-negative) are the |
| 135 |
exponents. Highest terms will be printed first in the output. |
| 136 |
|
| 137 |
%\begin{exm} ------------------To be written-------------------- |
| 138 |
%\end{exm} |
| 139 |
|
| 140 |
\item{{\bf Non--commutative case}} |
| 141 |
|
| 142 |
LISP form (homogeneous) polynomial of |
| 143 |
degree $d$ is a list of lists of integers of length $d+1:$ |
| 144 |
$$((c_1\ m_{11}\ \ldots m_{1d}) \ldots (c_r\ m_{r1}\ \ldots m_{rd})) $$ |
| 145 |
where the CAR of the i:th list is the coefficient of the i:th monomial, |
| 146 |
and the other n integers (which should be positive) are the "indices" |
| 147 |
of the variables, i. e., their position if they are ordered by increasing |
| 148 |
significance. The corresponding ALG format is |
| 149 |
$$c_1*v_{m_{11}}*...*v_{m_{1d}}+ ... +c_r*v_{m_{r1}}*...*v_{m_{rd}} .$$ |
| 150 |
In input, identical factors may be collected to exponents. E. g., if |
| 151 |
the variables are $x,y,$ and $z$ (in this order), then the LISP form |
| 152 |
polynomial $((5\ 1\ 1\ 1\ 3\ 2\ 2))$ will be ALG form output as |
| 153 |
$5*x*x*x*z*y*y,$ |
| 154 |
but it may optionally be input as $5*x**3*z*y\wedge 2.$ |
| 155 |
Highest terms will be printed first in the output. |
| 156 |
|
| 157 |
|
| 158 |
\end{description} |
| 159 |
|
| 160 |
If you want to have output in ALG or MACAULAY form, you in one way or |
| 161 |
another must define the variable names, and you must set the global |
| 162 |
variable ALGOUTMODE to ALG or MACAULAY. The variable names are most |
| 163 |
easily given by setinvars within a ALGFORMINPUT, as explained below. |
| 164 |
|
| 165 |
You may add your own algebraic output mode options by means |
| 166 |
of\\ ADDALGOUTMODE, as explained below. |
| 167 |
|
| 168 |
In order to perform LISP mode input, write |
| 169 |
|
| 170 |
{\bf (LISPFORMINPUT) } |
| 171 |
|
| 172 |
pol1 pol2 ..... pols |
| 173 |
|
| 174 |
{\bf (LISPFORMINPUTEND)} |
| 175 |
|
| 176 |
where pol1, ..., pols are polynomials on LISP form. If you must specify |
| 177 |
the number of variables to a number $n$ (as in the non-commutative case, |
| 178 |
if you want to know the Hilbert series), then set EMBDIM to $n$. (EMBDIM |
| 179 |
is short for "the embedding dimension".) |
| 180 |
|
| 181 |
In order to perform ALG mode input, write |
| 182 |
|
| 183 |
|
| 184 |
{\bf (ALGFORMINPUT) } |
| 185 |
|
| 186 |
{\bf vars v1, ...,vn;} |
| 187 |
|
| 188 |
{\bf pol1, ... , pols;} |
| 189 |
|
| 190 |
where v1, ..., vn are the variable names and pol1, ..., pols are |
| 191 |
polynomials on ALG form. |
| 192 |
|
| 193 |
COMMENTS: |
| 194 |
|
| 195 |
\begin{enumerate} |
| 196 |
\item Both ALGFORMINPUT parts, i. e., the input variable setting and the |
| 197 |
polynomial listing, are optional. You may thus give LISP form input, |
| 198 |
but perform (ALGFORMINPUT) vars v1,...,vn; ; (NOTE the double ;), |
| 199 |
in order to enable ALG or MACAULAY output. Of course, if you try |
| 200 |
to ALGFORMINPUT polynomials when the variables are not set, you are in |
| 201 |
trouble. |
| 202 |
\item New successful (and non-empty) polynomial inputs replace old ones. |
| 203 |
Likewise, new successful input variable settings replace old ones. |
| 204 |
Running GROEBNERKERNEL (successfully) or CLEARIDEAL kills the input |
| 205 |
polynomials, but not the variable settings. |
| 206 |
\item The implementation of ALGFORMINPUT depends on specific PSL features, |
| 207 |
since the pure Standard Lisp has poor alternative scanning abilities. |
| 208 |
If ALGFORMINPUT should be disabled in some other implementation, and |
| 209 |
you still wish to use algebraic output modes, then you must define |
| 210 |
the variable names in another way, using the internal |
| 211 |
representations. In BERGMAN 0.9*, the output variable settings |
| 212 |
performed by |
| 213 |
|
| 214 |
vars x,y,z; |
| 215 |
|
| 216 |
in the commutative case corresponds to |
| 217 |
|
| 218 |
(SETQ O!u!tV!a!r!s (QUOTE (!x !y !z))) |
| 219 |
|
| 220 |
and in the non-commutative case corresponds to |
| 221 |
|
| 222 |
(SETQ O!u!tV!a!r!s (QUOTE ((1 . !x) (2 . !y) (3 . !z)))) . |
| 223 |
|
| 224 |
\end{enumerate} |
| 225 |
|
| 226 |
|
| 227 |
\subsection {STRATEGIES} |
| 228 |
The last important mode choice that should be mentioned is selecting |
| 229 |
the strategy of the calculations. Besides selecting of the |
| 230 |
algorithm (commutative or noncommutative, Buchberger or staggered) |
| 231 |
that you are doing selecting by appropriate procedure, you have |
| 232 |
some influence on the intermediate calculation. Choosing |
| 233 |
|
| 234 |
{\bf (ON IMMEDIATEFULLREDUCTION) } |
| 235 |
|
| 236 |
(and this is default) you demand immediate reduction of all the terms |
| 237 |
of your Gr\"{o}bner basis and obtain it in the reduced form. |
| 238 |
Sometimes it might be |
| 239 |
more efficient to switch OFF this flag. The obtained Gr\"{o}bner basis may be |
| 240 |
not reduced, but calculations might be slightly faster. There is no |
| 241 |
clear receipts when it happens - try yourself! |
| 242 |
|
| 243 |
%\subsection{series} \label{series} |
| 244 |
%----------------To be Written--------- |