Index: /src/cgb.asd
===================================================================
--- /src/cgb.asd	(revision 7)
+++ /src/cgb.asd	(revision 8)
@@ -14,5 +14,5 @@
 
 ;;Use the grobner package within colored-poly package
-(pushnew :colored-poly-use-grobner *features*)
+;;(pushnew :colored-poly-use-grobner *features*)
 
 ;;colored-poly package
Index: /src/coefficient-ring.lisp
===================================================================
--- /src/coefficient-ring.lisp	(revision 7)
+++ /src/coefficient-ring.lisp	(revision 8)
@@ -35,6 +35,5 @@
 (in-package "COEFFICIENT-RING")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 (defstruct ring
Index: /src/colored-poly.lisp
===================================================================
--- /src/colored-poly.lisp	(revision 7)
+++ /src/colored-poly.lisp	(revision 8)
@@ -24,6 +24,5 @@
 (in-package "COLORED-POLY")
 	     
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 #+debug(defvar *colored-poly-debug* nil "If true debugging output is on.")
Index: /src/division.lisp
===================================================================
--- /src/division.lisp	(revision 7)
+++ /src/division.lisp	(revision 8)
@@ -15,6 +15,5 @@
 (in-package  "DIVISION")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 (defun divide (f fl &optional
Index: /src/dynamics.lisp
===================================================================
--- /src/dynamics.lisp	(revision 7)
+++ /src/dynamics.lisp	(revision 8)
@@ -28,6 +28,5 @@
 (in-package "DYNAMICS")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 (defun poly-scalar-composition (f G &optional (order #'lex>))
Index: /src/example.lisp
===================================================================
--- /src/example.lisp	(revision 7)
+++ /src/example.lisp	(revision 8)
@@ -17,6 +17,5 @@
     "INFIX" "COMMON-LISP"))
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 (defun example (symbol &optional (stream t))
Index: /src/grobner.lisp
===================================================================
--- /src/grobner.lisp	(revision 7)
+++ /src/grobner.lisp	(revision 8)
@@ -55,6 +55,5 @@
 (in-package "GROBNER")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 #+debug
Index: /src/infix.lisp
===================================================================
--- /src/infix.lisp	(revision 7)
+++ /src/infix.lisp	(revision 8)
@@ -277,8 +277,7 @@
 (pushnew :infix *features*)
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
-
-(eval-when (compile load eval)
+(proclaim '(optimize (speed 0) (debug 3)))
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
   (defparameter *version* "1.3  28-JUN-96")
   (defparameter *print-infix-copyright* t
@@ -544,5 +543,5 @@
   (gethash token *token-infix-operator-table*))
 
-(eval-when (compile load eval)
+(eval-when (:compile-toplevel :load-toplevel :execute)
   (defmacro define-token-operator (operator-name &key
 						 (prefix nil prefix-p)
@@ -572,5 +571,5 @@
 
 ;;; Readtable definitions for characters, so that the right token is returned.
-(eval-when (compile load eval)
+(eval-when (:compile-toplevel :load-toplevel :execute)
   (defmacro define-character-tokenization (char function)
     `(set-macro-character ,char ,function nil *infix-readtable*)))
Index: /src/modular-poly.lisp
===================================================================
--- /src/modular-poly.lisp	(revision 7)
+++ /src/modular-poly.lisp	(revision 8)
@@ -17,6 +17,5 @@
 (in-package "MODULAR-POLY")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 (defun modular-trace (plist modulus)
Index: /src/modular.lisp
===================================================================
--- /src/modular.lisp	(revision 7)
+++ /src/modular.lisp	(revision 8)
@@ -17,6 +17,5 @@
 (in-package "MODULAR")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 (defun modular-inverse (x p)
Index: /src/monom.lisp
===================================================================
--- /src/monom.lisp	(revision 7)
+++ /src/monom.lisp	(revision 8)
@@ -17,6 +17,5 @@
 (in-package "MONOM")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 ;;----------------------------------------------------------------
Index: /src/order.lisp
===================================================================
--- /src/order.lisp	(revision 7)
+++ /src/order.lisp	(revision 8)
@@ -35,6 +35,5 @@
 (in-package "ORDER")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 ;; pure lexicographic
Index: /src/parse.lisp
===================================================================
--- /src/parse.lisp	(revision 7)
+++ /src/parse.lisp	(revision 8)
@@ -19,6 +19,5 @@
 (in-package "PARSE")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 ;; The function PARSE yields the representations as above.  The two functions
Index: /src/poly-gcd.lisp
===================================================================
--- /src/poly-gcd.lisp	(revision 7)
+++ /src/poly-gcd.lisp	(revision 8)
@@ -16,6 +16,5 @@
 (in-package "POLY-GCD")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 ;; This package calculates GCD of polynomials over integers.
Index: /src/poly-with-sugar.lisp
===================================================================
--- /src/poly-with-sugar.lisp	(revision 7)
+++ /src/poly-with-sugar.lisp	(revision 8)
@@ -33,6 +33,5 @@
 (in-package "POLY-WITH-SUGAR")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 ;;----------------------------------------------------------------
Index: /src/poly.lisp
===================================================================
--- /src/poly.lisp	(revision 7)
+++ /src/poly.lisp	(revision 8)
@@ -18,6 +18,5 @@
 (in-package "POLY")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 ;;----------------------------------------------------------------
Index: /src/printer.lisp
===================================================================
--- /src/printer.lisp	(revision 7)
+++ /src/printer.lisp	(revision 8)
@@ -15,6 +15,5 @@
 (in-package "PRINTER")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (safety 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 (defun poly-print (plist vars &optional (stream t))
Index: /src/prover.lisp
===================================================================
--- /src/prover.lisp	(revision 7)
+++ /src/prover.lisp	(revision 8)
@@ -19,6 +19,5 @@
 (in-package "PROVER")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (safety 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 (defvar *prover-order* #'grevlex>
Index: /src/rat.lisp
===================================================================
--- /src/rat.lisp	(revision 7)
+++ /src/rat.lisp	(revision 8)
@@ -28,6 +28,5 @@
 (in-package "RAT")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (safety 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 (defun num (p) (car p))			;numerator
Index: /src/ratpoly.lisp
===================================================================
--- /src/ratpoly.lisp	(revision 7)
+++ /src/ratpoly.lisp	(revision 8)
@@ -34,6 +34,5 @@
 (in-package "RATPOLY")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (safety 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 ;; Arithmetic on polynomials in one variable
Index: /src/string-grobner.lisp
===================================================================
--- /src/string-grobner.lisp	(revision 7)
+++ /src/string-grobner.lisp	(revision 8)
@@ -30,6 +30,5 @@
 (in-package "STRING-GROBNER")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 (defun string-normal-form (f fl vars
Index: /src/svpoly.lisp
===================================================================
--- /src/svpoly.lisp	(revision 7)
+++ /src/svpoly.lisp	(revision 8)
@@ -14,6 +14,5 @@
 (in-package "SVPOLY")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 (defstruct (svpoly (:constructor make-svpoly-raw))
Index: /src/term.lisp
===================================================================
--- /src/term.lisp	(revision 7)
+++ /src/term.lisp	(revision 8)
@@ -16,6 +16,5 @@
 (in-package "TERM")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 ;;----------------------------------------------------------------
Index: /src/xgcd.lisp
===================================================================
--- /src/xgcd.lisp	(revision 7)
+++ /src/xgcd.lisp	(revision 8)
@@ -15,6 +15,5 @@
 (in-package "XGCD")
 
-#+debug(proclaim '(optimize (speed 0) (debug 3)))
-#-debug(proclaim '(optimize (speed 3) (debug 0)))
+(proclaim '(optimize (speed 0) (debug 3)))
 
 (defun xgcd (X Y)
Index: /trunk/contrib/infix.cl
===================================================================
--- /trunk/contrib/infix.cl	(revision 8)
+++ /trunk/contrib/infix.cl	(revision 8)
@@ -0,0 +1,1117 @@
+;;; -*- Mode: Lisp -*-
+;;; $Id: infix.cl,v 1.3 1997/11/27 17:36:16 marek Exp marek $	
+;;; Modified by M. Rychlik(rychlik@math.arizona.edu): The role of operators
+;;; ^^ (exponentiation) and ^ (logxior) of the original was reversed
+;;; 
+;;; Wed Jan 18 13:13:59 1995 by Mark Kantrowitz <mkant@FLATHEAD.OZ.CS.CMU.EDU>
+;;; infix.cl -- 40545 bytes
+
+;;; **************************************************************************
+;;; Infix ********************************************************************
+;;; **************************************************************************
+;;;
+;;; This is an implementation of an infix reader macro. It should run in any
+;;; valid Common Lisp and has been tested in Allegro CL 4.1, Lucid CL 4.0.1,
+;;; MCL 2.0 and CMU CL. It allows the user to type arithmetic expressions in
+;;; the traditional way (e.g., 1+2) when writing Lisp programs instead of
+;;; using the normal Lisp syntax (e.g., (+ 1 2)).  It is not intended to be a
+;;; full replacement for the normal Lisp syntax. If you want a more complete
+;;; alternate syntax for Lisp, get a copy Apple's MLisp or Pratt's CGOL.
+;;;
+;;; Although similar in concept to the Symbolics infix reader (#<DIAMOND>), 
+;;; no real effort has been made to ensure compatibility beyond coverage 
+;;; of at least the same set of basic arithmetic operators. There are several 
+;;; differences in the syntax beyond just the choice of #I as the macro 
+;;; character. (Our syntax is a little bit more C-like than the Symbolics 
+;;; macro in addition to some more subtle differences.) 
+;;;
+;;; We initially chose $ as a macro character because of its association
+;;; with mathematics in LaTeX, but unfortunately that character is already
+;;; used in MCL. We switched to #I() because it was one of the few options
+;;; remaining.
+;;;
+;;; Written by Mark Kantrowitz, School of Computer Science,
+;;; Carnegie Mellon University, March 1993.
+;;;
+;;; Copyright (c) 1993 by Mark Kantrowitz. All rights reserved.
+;;;
+;;; Use and copying of this software and preparation of derivative works
+;;; based upon this software are permitted, so long as the following
+;;; conditions are met:
+;;;      o no fees or compensation are charged for use, copies, 
+;;;        distribution or access to this software
+;;;      o this copyright notice is included intact.
+;;; This software is made available AS IS, and no warranty is made about
+;;; the software or its performance.
+;;;
+;;; In no event will the author(s) or their institutions be liable to you for
+;;; damages, including lost profits, lost monies, or other special, incidental
+;;; or consequential damages, arising out of or in connection with the use or
+;;; inability to use (including but not limited to loss of data or data being
+;;; rendered inaccurate or losses sustained by third parties or a failure of
+;;; the program to operate as documented) the program, or for any claim by
+;;; any other party, whether in an action of contract, negligence, or 
+;;; other tortious action.
+;;;
+;;; Please send bug reports, comments and suggestions to mkant@cs.cmu.edu.
+;;;
+;;; The current version of this software and a variety of related utilities
+;;; may be obtained from the Lisp Repository by anonymous ftp
+;;; from ftp.cs.cmu.edu [128.2.206.173] in the directory
+;;;     user/ai/lang/lisp/code/syntax/infix/
+;;; If your site runs the Andrew File System, you can cd to the AFS directory
+;;;     /afs/cs.cmu.edu/project/ai-repository/ai/lang/lisp/code/syntax/infix/
+;;;
+;;; If you wish to be added to the Lisp-Utilities@cs.cmu.edu mailing list,
+;;; send email to Lisp-Utilities-Request@cs.cmu.edu with your name, email
+;;; address, and affiliation. This mailing list is primarily for
+;;; notification about major updates, bug fixes, and additions to the Lisp
+;;; Utilities Repository. The mailing list is intended to have low traffic.
+;;;
+
+
+;;; ********************************
+;;; Documentation ******************
+;;; ********************************
+;;;
+;;; Syntax:
+;;;
+;;;   Begin the reader macro with #I( and end it with ). For example,
+;;;      #I( x^2 + y^2 )
+;;;   is equivalent to the Lisp form
+;;;      (+ (expt x 2) (expt y 2))
+;;;   but much easier to read according to some folks.
+;;;
+;;;   If you want to see the expansion, type a quote before the #I form
+;;;   at the Lisp prompt:
+;;;     > '#I(if x<y<=z then f(x)=x^2+y^2 else f(x)=x^2-y^2)
+;;;     (IF (AND (< X Y) (<= Y Z))
+;;;         (SETF (F X) (+ (EXPT X 2) (EXPT Y 2)))
+;;;         (SETF (F X) (- (EXPT X 2) (EXPT Y 2))))
+;;;
+;;;
+;;; Operators:
+;;;
+;;;    NOTE: == is equality, = is assignment (C-style).
+;;;
+;;;     \                   quoting character:  x\-y  -->  x-y
+;;;     !                   lisp escape    !(foo bar) -->  (foo bar)
+;;;     ;                   comment
+;;;     x = y               assignment                     (setf x y)
+;;;     x += y              increment                      (incf x y)
+;;;     x -= y              decrement                      (decf x y)
+;;;     x *= y              multiply and store             (setf x (* x y))
+;;;     x /= y              divide and store               (setf x (/ x y))
+;;;     x|y                 bitwise logical inclusive or   (logior x y)
+;;;     x^^y                bitwise logical exclusive or   (logxor x y)
+;;;     x&y                 bitwise logical and            (logand x y)
+;;;     x<<y                left shift                     (ash x y)
+;;;     x>>y                right shift                    (ash x (- y))
+;;;     ~x                  ones complement (unary)        (lognot x)
+;;;     x and y             conjunction                    (and x y)
+;;;     x && y              conjunction                    (and x y)
+;;;     x or y              disjunction                    (or x y)
+;;;     x || y              disjunction                    (or x y)
+;;;     not x               negation                       (not x)
+;;;     x^y                 exponentiation                 (expt x y)
+;;;     x,y                 sequence                       (progn x y)
+;;;     (x,y)               sequence                       (progn x y)
+;;;                         also parenthesis (x+y)/z -->   (/ (+ x y) z)
+;;;     f(x,y)              functions                      (f x y)
+;;;     a[i,j]              array reference                (aref a i j)
+;;;     x+y x*y             arithmetic                     (+ x y) (* x y) 
+;;;     x-y x/y             arithmetic                     (- x y) (/ x y) 
+;;;     -y                  value negation                 (- y)
+;;;     x % y               remainder                      (mod x y)
+;;;     x<y x>y             inequalities                   (< x y) (> x y)
+;;;     x <= y  x >= y      inequalities                   (<= x y) (>= x y)
+;;;     x == y              equality                       (= x y) 
+;;;     x != y              equality                       (not (= x y))
+;;;     if p then q         conditional                    (when p q)
+;;;     if p then q else r  conditional                    (if p q r) 
+;;;
+
+
+;;; Precedence:
+;;;
+;;;    The following precedence conventions are obeyed by the infix operators:
+;;;      [ ( !
+;;;      ^
+;;;      ~
+;;;      * / %
+;;;      + -
+;;;      << >>
+;;;      < == > <= != >=
+;;;      &
+;;;      ^^
+;;;      |
+;;;      not
+;;;      and
+;;;      or
+;;;      = += -= *= /=
+;;;      , 
+;;;      if
+;;;      then else
+;;;      ] )
+;;;
+;;;    Note that logical negation has lower precedence than numeric comparison
+;;;    so that "not a<b" becomes (not (< a b)), which is different from the
+;;;    C precedence conventions. You can change the precedence conventions by
+;;;    modifying the value of the variable *operator-ordering*.
+;;;
+
+
+;;; ********************************
+;;; To Do **************************
+;;; ********************************
+;;;
+;;;    Write some more test cases.
+;;;    Write some more syntactic optimizations.
+;;;    Would really like ~x to be (not x), but need it for (lognot x). 
+;;;    Support for multiple languages, such as a Prolog parser, a 
+;;;    strictly C compatible parser, etc.
+
+;;; Create a more declarative format, where there is one big table of 
+;;; operators with all the info on them, and also NOT have the list of
+;;; operators in the comment, where they are likely to become wrong when
+;;; changes are made to the code. For example, something like:
+#|
+(define-infix-operators
+  ([  30                           :matchfix aref :end ])
+  (*  20 :infix *                                       )
+  (+  10 :infix +        :prefix +                      )
+  (&  10 :infix and                                     )
+  (+= 10 :infix #'+=-operator                           )
+  ...)
+|#
+
+;;; ********************************
+;;; Change Log *********************
+;;; ********************************
+;;;
+;;;  9-MAR-93 mk     Created
+;;; 12-MAR-93 mk     Fixed defpackage form for Lucid.
+;;; 1.1:
+;;; 14-OCT-93 mk     Changed macro character from #$ to #I(). Suggested by
+;;;                  Scott McKay.
+;;; 1.2:
+;;; 18-JAN-95 norvig Added *print-infix-copyright*, string->prefix, support
+;;;                  for #I"..." in addition to #i(...) which lets one
+;;;                  type #i"a|b" which doesn't confuse editors that aren't
+;;;                  |-aware. Also added := as a synonym for =, so that
+;;;                  '#i"car(a) := b" yields (SETF (CAR A) B).
+;;;
+;;; 1.3:
+;;; 28-JUN-96 mk    Modified infix reader to allow whitespace between the #I
+;;;                 and the start of the expression.
+
+
+
+
+;;; ********************************
+;;; Implementation Notes ***********
+;;; ********************************
+;;;
+;;; Initially we tried implementing everything within the Lisp reader,
+;;; but found this to not be workable. Parameters had to be passed in
+;;; global variables, and some of the processing turned out to be 
+;;; indelible, so it wasn't possible to use any kind of lookahead.
+;;; Center-embedded constructions were also a problem, due to the lack
+;;; of an explicit stack.
+;;;
+;;; So we took another tack, that used below. The #I macro binds the
+;;; *readtable* to a special readtable, which is used solely for tokenization
+;;; of the input. Then the problem is how to correctly parenthesize the input.
+;;; We do that with what is essentially a recursive-descent parser. An 
+;;; expression is either a prefix operator followed by an expression, or an 
+;;; expression followed by an infix operator followed by an expression. When 
+;;; the latter expression is complex, the problem becomes a little tricky. 
+;;; For example, suppose we have
+;;;      exp1 op1 exp2 op2
+;;; We need to know whether to parenthesize it as
+;;;      (exp1 op1 exp2) op2
+;;; or as
+;;;      exp1 op1 (exp2 op2 ...)
+;;; The second case occurs either when op2 has precedence over op1 (e.g.,
+;;; * has precedence over +) or op2 and op1 are the same right-associative
+;;; operator (e.g., exponentiation). Thus the algorithm is as follows:
+;;; When we see op1, we want to gobble up exp2 op2 exp3 op3 ... opn expn+1
+;;; into an expression where op2 through opn all have higher precedence
+;;; than op1 (or are the same right-associative operator), and opn+1 doesn't.
+;;; This algorithm is implemented by the GATHER-SUPERIORS function. 
+;;; 
+;;; Because + and - are implemented in the infix readtable as terminating
+;;; macro cahracters, the exponentiation version of Lisp number syntax
+;;;    1e-3 == 0.001
+;;; doesn't work correctly -- it parses it as (- 1e 3). So we add a little
+;;; cleverness to GATHER-SUPERIORS to detect when the tokenizer goofed. 
+;;; Since this requires the ability to lookahead two tokens, we use a
+;;; stack to implement the lookahead in PEEK-TOKEN and READ-TOKEN.
+;;;
+;;; Finally, the expression returned by GATHER-SUPERIORS sometimes needs to
+;;; be cleaned up a bit. For example, parsing a<b<c would normally return
+;;; (< (< a b) c), which obviously isn't correct. So POST-PROCESS-EXPRESSION
+;;; detects this and similar cases, replacing the expression with (< a b c).
+;;; For cases like a<b<=c, it replaces it with (and (< a b) (<= b c)).
+;;; 
+
+
+;;; ********************************
+;;; Package Cruft ******************
+;;; ********************************
+
+(defpackage "INFIX" (:use #-:lucid "COMMON-LISP" 
+			  #+:lucid "LISP" #+:lucid "LUCID-COMMON-LISP"))
+(in-package "INFIX")
+(export '(test-infix string->prefix))
+
+(pushnew :infix *features*)
+
+(eval-when (compile load eval)
+  (defparameter *version* "1.3  28-JUN-96")
+  (defparameter *print-infix-copyright* t
+    "If non-NIL, prints a copyright notice upon loading this file.")
+
+  (defun infix-copyright (&optional (stream *standard-output*))
+    "Prints an INFIX copyright notice and header upon startup."
+    (format stream "~%;;; ~V,,,'*A" 73 "*")
+    (format stream "~%;;;   Infix notation for Common Lisp.")
+    (format stream "~%;;;   Version ~A." *version*)
+    (format stream "~%;;;   Written by Mark Kantrowitz, ~
+                            CMU School of Computer Science.")
+    (format stream "~%;;;   Copyright (c) 1993-95. All rights reserved.")
+    (format stream "~%;;;   May be freely redistributed, provided this ~
+                            notice is left intact.")
+    (format stream "~%;;;   This software is made available AS IS, without ~
+                            any warranty.")
+    (format stream "~%;;; ~V,,,'*A~%" 73 "*")
+    (force-output stream))
+
+  ;; What this means is you can either turn off the copyright notice
+  ;; by setting the parameter, or you can turn it off by including
+  ;; (setf (get :infix :dont-print-copyright) t) in your lisp init file.
+  (when (and *print-infix-copyright* 
+	     (not (get :infix :dont-print-copyright)))
+    (infix-copyright)))
+
+;;; ********************************
+;;; Readtable **********************
+;;; ********************************
+
+(defparameter *infix-readtable* (copy-readtable nil))
+(defparameter *normal-readtable* (copy-readtable nil))
+
+(defun infix-reader (stream subchar arg)
+  ;; Read either #I(...) or #I"..."
+  (declare (ignore arg subchar))
+  (let ((first-char (peek-char nil stream t nil t)))
+    (cond ((char= first-char #\space)
+	   (read-char stream)		; skip over whitespace
+	   (infix-reader stream nil nil))
+	  ((char= first-char #\")
+	   ;; Read double-quote-delimited infix expressions.
+	   (string->prefix (read stream t nil t)))
+	  ((char= first-char #\()
+	   (read-char stream)		; get rid of opening left parenthesis
+	   (let ((*readtable* *infix-readtable*)
+		 (*normal-readtable* *readtable*))
+	     (read-infix stream)))
+	  (t
+	   (infix-error "Infix expression starts with ~A" first-char)))))
+
+(set-dispatch-macro-character #\# #\I #'infix-reader *readtable*) ; was #\# #\$
+
+(defun string->prefix (string)
+  "Convert a string to a prefix s-expression using the infix reader.
+  If the argument is not a string, just return it as is."
+  (if (stringp string)
+      (with-input-from-string (stream (concatenate 'string "#I(" string ")"))
+	(read stream))
+      string))
+
+(defmacro infix-error (format-string &rest args)
+  `(let ((*readtable* *normal-readtable*)) 
+     (error ,format-string ,@args)))
+
+(defun read-infix (stream)
+  (let* ((result (gather-superiors '\) stream)) ; %infix-end-token%
+	 (next-token (read-token stream)))
+    (unless (same-token-p next-token '\)) ; %infix-end-token%
+      (infix-error "Infix expression ends with ~A." next-token))
+    result))
+
+(defun read-regular (stream)
+  (let ((*readtable* *normal-readtable*))
+    (read stream t nil t)))
+
+
+
+;;; ********************************
+;;; Reader Code ********************
+;;; ********************************
+
+(defun same-operator-p (x y)
+  (same-token-p x y))
+
+(defun same-token-p (x y)
+  (and (symbolp x)
+       (symbolp y) 
+       (string-equal (symbol-name x) (symbol-name y))))
+
+;;; Peeking Token Reader
+
+(defvar *peeked-token* nil)
+(defun read-token (stream)
+  (if *peeked-token*
+      (pop *peeked-token*)
+      (read stream t nil t)))
+(defun peek-token (stream)
+  (unless *peeked-token*
+    (push (read stream t nil t) *peeked-token*))
+  (car *peeked-token*))
+
+;;; Hack to work around + and - being terminating macro characters,
+;;; so 1e-3 doesn't normally work correctly.
+
+(defun fancy-number-format-p (left operator stream)
+  (when (and (symbolp left)
+	     (find operator '(+ -) :test #'same-operator-p))
+    (let* ((name (symbol-name left))
+	   (length (length name)))
+      (when (and (valid-numberp (subseq name 0 (1- length)))
+		 ;; Exponent, Single, Double, Float, or Long
+		 (find (subseq name (1- length))
+		       '("e" "s" "d" "f" "l")
+		       :test #'string-equal))
+	(read-token stream)
+	(let ((right (peek-token stream)))
+	  (cond ((integerp right)
+		 ;; it is one of the fancy numbers, so return it
+		 (read-token stream)
+		 (let ((*readtable* *normal-readtable*))
+		   (read-from-string (format nil "~A~A~A" 
+					     left operator right))))
+		(t
+		 ;; it isn't one of the fancy numbers, so unread the token
+		 (push operator *peeked-token*)
+		 ;; and return nil
+		 nil)))))))
+
+(defun valid-numberp (string)
+  (let ((saw-dot nil))
+    (dolist (char (coerce string 'list) t)
+      (cond ((char= char #\.)
+	     (if saw-dot
+		 (return nil)
+		 (setq saw-dot t)))
+	    ((not (find char "01234567890" :test #'char=))
+	     (return nil))))))
+
+;;; Gobbles an expression from the stream.
+
+(defun gather-superiors (previous-operator stream)
+  "Gathers an expression whose operators all exceed the precedence of
+   the operator to the left."
+  (let ((left (get-first-token stream)))
+    (loop
+      (setq left (post-process-expression left))
+      (let ((peeked-token (peek-token stream)))
+	(let ((fancy-p (fancy-number-format-p left peeked-token stream)))
+	  (when fancy-p
+	    ;; i.e., we've got a number like 1e-3 or 1e+3 or 1f-1
+	    (setq left fancy-p
+		  peeked-token (peek-token stream))))
+	(unless (or (operator-lessp previous-operator peeked-token)
+		    (and (same-operator-p peeked-token previous-operator)
+			 (operator-right-associative-p previous-operator)))
+	  ;; The loop should continue when the peeked operator is
+	  ;; either superior in precedence to the previous operator,
+	  ;; or the same operator and right-associative.
+	  (return left)))
+      (setq left (get-next-token stream left)))))
+
+(defun get-first-token (stream)
+  (let ((token (read-token stream)))
+    (if (token-operator-p token)
+	;; It's an operator in a prefix context.
+	(apply-token-prefix-operator token stream)
+	;; It's a regular token
+	token)))
+
+(defun apply-token-prefix-operator (token stream)
+  (let ((operator (get-token-prefix-operator token)))
+    (if operator
+	(funcall operator stream)
+	(infix-error "~A is not a prefix operator" token))))
+
+(defun get-next-token (stream left)
+  (let ((token (read-token stream)))
+    (apply-token-infix-operator token left stream)))
+
+(defun apply-token-infix-operator (token left stream)
+  (let ((operator (get-token-infix-operator token)))
+    (if operator
+	(funcall operator stream left)
+	(infix-error "~A is not an infix operator" token))))
+
+;;; Fix to read-delimited-list so that it works with tokens, not
+;;; characters.
+
+(defun infix-read-delimited-list (end-token delimiter-token stream)
+  (do ((next-token (peek-token stream) (peek-token stream))
+       (list nil))
+      ((same-token-p next-token end-token)
+       ;; We've hit the end. Remove the end-token from the stream.
+       (read-token stream)
+       ;; and return the list of tokens.
+       ;; Note that this does the right thing with [] and ().
+       (nreverse list))
+    ;; Ignore the delimiters.
+    (when (same-token-p next-token delimiter-token)
+      (read-token stream))
+    ;; Gather the expression until the next delimiter.
+    (push (gather-superiors delimiter-token stream) list)))
+
+
+
+;;; ********************************
+;;; Precedence *********************
+;;; ********************************
+
+(defparameter *operator-ordering* 
+    '(( \[ \( \! )			; \[ is array reference
+      ( ^ )				; exponentiation
+      ( ~ )				; lognot 
+      ( * /  % )			; % is mod
+      ( + - )
+      ( << >> )
+      ( < == > <= != >= )
+      ( & )				; logand
+      ( ^^ )				; logxor
+      ( \| )				; logior
+      ( not )
+      ( and )
+      ( or )
+      ;; Where should setf and friends go in the precedence?
+      ( = |:=| += -= *= /= )
+      ( \, )				; progn (statement delimiter)
+      ( if )
+      ( then else )
+      ( \] \) )
+      ( %infix-end-token% ))		; end of infix expression
+  "Ordered list of operators of equal precedence.")
+
+(defun operator-lessp (op1 op2)
+  (dolist (ops *operator-ordering* nil)
+    (cond ((find op1 ops :test #'same-token-p)
+	   (return nil))
+	  ((find op2 ops :test #'same-token-p)
+	   (return t)))))
+
+(defparameter *right-associative-operators* '(^ =))
+(defun operator-right-associative-p (operator)
+  (find operator *right-associative-operators*))
+
+
+
+;;; ********************************
+;;; Define Operators ***************
+;;; ********************************
+
+(defvar *token-operators* nil)
+(defvar *token-prefix-operator-table* (make-hash-table))
+(defvar *token-infix-operator-table* (make-hash-table))
+(defun token-operator-p (token)
+  (find token *token-operators*))
+(defun get-token-prefix-operator (token)
+  (gethash token *token-prefix-operator-table*))
+(defun get-token-infix-operator (token)
+  (gethash token *token-infix-operator-table*))
+
+(eval-when (compile load eval)
+  (defmacro define-token-operator (operator-name &key
+						 (prefix nil prefix-p)
+						 (infix nil infix-p))
+    `(progn
+       (pushnew ',operator-name *token-operators*)
+       ,(when prefix-p
+	  `(setf (gethash ',operator-name *token-prefix-operator-table*)
+		 #'(lambda (stream)
+		     ,@(cond ((and (consp prefix)
+				   (eq (car prefix) 'infix-error))
+			      ;; To avoid ugly compiler warnings.
+			      `((declare (ignore stream))
+				,prefix))
+			     (t
+			      (list prefix))))))
+       ,(when infix-p
+	  `(setf (gethash ',operator-name *token-infix-operator-table*)
+		 #'(lambda (stream left)
+		     ,@(cond ((and (consp infix)
+				   (eq (car infix) 'infix-error))
+			      ;; To avoid ugly compiler warnings.
+			      `((declare (ignore stream left))
+				,infix))
+			     (t
+			      (list infix)))))))))
+
+;;; Readtable definitions for characters, so that the right token is returned.
+(eval-when (compile load eval)
+  (defmacro define-character-tokenization (char function)
+    `(set-macro-character ,char ,function nil *infix-readtable*)))
+
+
+
+;;; ********************************
+;;; Operator Definitions ***********
+;;; ********************************
+
+(define-token-operator and
+    :infix  `(and ,left ,(gather-superiors 'and stream)))
+(define-token-operator or
+    :infix  `(or ,left ,(gather-superiors 'or stream)))
+(define-token-operator not
+    :prefix `(not ,(gather-superiors 'not stream)))
+
+(define-token-operator if
+    :prefix (let* ((test (gather-superiors 'if stream))
+		   (then (cond ((same-token-p (peek-token stream) 'then)
+				(read-token stream)
+				(gather-superiors 'then stream))
+			       (t
+				(infix-error "Missing THEN clause."))))
+		   (else (when (same-token-p (peek-token stream) 'else)
+			   (read-token stream)
+			   (gather-superiors 'else stream))))
+	      (cond ((and test then else)
+		     `(if ,test ,then ,else))
+		    ((and test then)
+		     ;; no else clause
+		     `(when ,test ,then))
+		    ((and test else)
+		     ;; no then clause
+		     `(unless ,test ,else))
+		    (t
+		     ;; no then and else clauses --> always NIL
+		     nil))))
+
+(define-token-operator then
+    :prefix (infix-error "THEN clause without an IF."))
+(define-token-operator else
+    :prefix (infix-error "ELSE clause without an IF."))
+
+(define-character-tokenization #\+
+    #'(lambda (stream char)
+	(declare (ignore char))
+	(cond ((char= (peek-char nil stream t nil t) #\=)
+	       (read-char stream t nil t)
+	       '+=)
+	      (t
+	       '+))))
+(define-token-operator +
+    :infix `(+ ,left ,(gather-superiors '+ stream))
+    :prefix (gather-superiors '+ stream))
+(define-token-operator +=
+    :infix `(incf ,left ,(gather-superiors '+= stream)))
+
+(define-character-tokenization #\-
+    #'(lambda (stream char)
+	(declare (ignore char))
+	(cond ((char= (peek-char nil stream t nil t) #\=)
+	       (read-char stream t nil t)
+	       '-=)
+	      (t
+	       '-))))
+(define-token-operator -
+    :infix `(- ,left ,(gather-superiors '- stream))
+    :prefix `(- ,(gather-superiors '- stream)))
+(define-token-operator -=
+    :infix `(decf ,left ,(gather-superiors '-= stream)))
+
+(define-character-tokenization #\*
+    #'(lambda (stream char)
+	(declare (ignore char))
+	(cond ((char= (peek-char nil stream t nil t) #\=)
+	       (read-char stream t nil t)
+	       '*=)
+	      (t
+	       '*))))
+(define-token-operator *
+    :infix `(* ,left ,(gather-superiors '* stream)))
+(define-token-operator *=
+    :infix `(,(if (symbolp left) 
+		  'setq
+		  'setf)
+	      ,left 
+	      (* ,left ,(gather-superiors '*= stream))))
+
+(define-character-tokenization #\/
+    #'(lambda (stream char)
+	(declare (ignore char))
+	(cond ((char= (peek-char nil stream t nil t) #\=)
+	       (read-char stream t nil t)
+	       '/=)
+	      (t
+	       '/))))
+(define-token-operator /
+    :infix `(/ ,left ,(gather-superiors '/ stream))
+    :prefix `(/ ,(gather-superiors '/ stream)))
+(define-token-operator /=
+    :infix `(,(if (symbolp left) 
+		  'setq
+		  'setf)
+	      ,left 
+	      (/ ,left ,(gather-superiors '/= stream))))
+
+(define-character-tokenization #\^
+    #'(lambda (stream char)
+	(declare (ignore char))
+	(cond ((char= (peek-char nil stream t nil t) #\^)
+	       (read-char stream t nil t)
+	       '^^)
+	      (t
+	       '^))))
+(define-token-operator ^
+    :infix `(expt ,left ,(gather-superiors '^ stream)))
+(define-token-operator ^^
+    :infix `(logxor ,left ,(gather-superiors '^^ stream)))
+
+(define-character-tokenization #\|
+    #'(lambda (stream char)
+	(declare (ignore char))
+	(cond ((char= (peek-char nil stream t nil t) #\|)
+	       (read-char stream t nil t)
+	       'or)
+	      (t
+	       '\|))))
+(define-token-operator \|
+    :infix `(logior ,left ,(gather-superiors '\| stream)))
+
+(define-character-tokenization #\&
+    #'(lambda (stream char)
+	(declare (ignore char))
+	(cond ((char= (peek-char nil stream t nil t) #\&)
+	       (read-char stream t nil t)
+	       'and)
+	      (t
+	       '\&))))
+(define-token-operator \&
+    :infix `(logand ,left ,(gather-superiors '\& stream)))
+
+(define-character-tokenization #\%
+    #'(lambda (stream char)
+	(declare (ignore stream char))
+	'\%))
+(define-token-operator \%
+    :infix `(mod ,left ,(gather-superiors '\% stream)))
+
+(define-character-tokenization #\~
+    #'(lambda (stream char)
+	(declare (ignore stream char))
+	'\~))
+(define-token-operator \~
+    :prefix `(lognot ,(gather-superiors '\~ stream)))
+
+(define-character-tokenization #\,
+    #'(lambda (stream char)
+	(declare (ignore stream char))
+	'\,))
+(define-token-operator \,
+    :infix `(progn ,left ,(gather-superiors '\, stream)))
+
+(define-character-tokenization #\=
+    #'(lambda (stream char)
+	(declare (ignore char))
+	(cond ((char= (peek-char nil stream t nil t) #\=)
+	       (read-char stream t nil t)
+	       '==)
+	      (t
+	       '=))))
+(define-token-operator ==
+    :infix `(= ,left ,(gather-superiors '== stream)))
+(define-token-operator =
+    :infix `(,(if (symbolp left) 
+		  'setq
+		  'setf)
+	      ,left
+	      ,(gather-superiors '= stream)))
+
+(define-character-tokenization #\:	
+    #'(lambda (stream char)
+        (declare (ignore char))
+        (cond ((char= (peek-char nil stream t nil t) #\=)
+               (read-char stream t nil t)
+               '|:=|)
+              (t
+               '|:|))))
+(define-token-operator |:=|		
+    :infix `(,(if (symbolp left)
+                  'setq
+                  'setf)
+              ,left
+              ,(gather-superiors '|:=| stream)))
+
+(define-character-tokenization #\<
+    #'(lambda (stream char)
+	(declare (ignore char))
+	(cond ((char= (peek-char nil stream t nil t) #\=)
+	       (read-char stream t nil t)
+	       '<=)
+	      ((char= (peek-char nil stream t nil t) #\<)
+	       (read-char stream t nil t)
+	       '<<)
+	      (t
+	       '<))))
+(define-token-operator <
+    :infix `(< ,left ,(gather-superiors '< stream)))
+(define-token-operator <=
+    :infix `(<= ,left ,(gather-superiors '<= stream)))
+(define-token-operator <<
+    :infix `(ash ,left ,(gather-superiors '<< stream)))
+
+(define-character-tokenization #\>
+    #'(lambda (stream char)
+	(declare (ignore char))
+	(cond ((char= (peek-char nil stream t nil t) #\=)
+	       (read-char stream t nil t)
+	       '>=)
+	      ((char= (peek-char nil stream t nil t) #\>)
+	       (read-char stream t nil t)
+	       '>>)
+	      (t
+	       '>))))
+(define-token-operator >
+    :infix `(> ,left ,(gather-superiors '> stream)))
+(define-token-operator >=
+    :infix `(>= ,left ,(gather-superiors '>= stream)))
+(define-token-operator >>
+    :infix `(ash ,left (- ,(gather-superiors '>> stream))))
+
+(define-character-tokenization #\!
+    #'(lambda (stream char)
+	(declare (ignore char))
+	(cond ((char= (peek-char nil stream t nil t) #\=)
+	       (read-char stream t nil t)
+	       '!=)
+	      (t
+	       '!))))
+(define-token-operator !=
+    :infix `(not (= ,left ,(gather-superiors '!= stream))))
+(define-token-operator !
+    :prefix (read-regular stream))
+
+(define-character-tokenization #\[
+    #'(lambda (stream char)
+	(declare (ignore stream char))
+	'\[))
+(define-token-operator \[
+    :infix (let ((indices (infix-read-delimited-list '\] '\, stream)))
+	     (if (null indices)
+		 (infix-error "No indices found in array reference.")
+		 `(aref ,left ,@indices))))
+
+(define-character-tokenization #\(
+    #'(lambda (stream char)
+	(declare (ignore stream char))
+	'\())
+(define-token-operator \(
+    :infix `(,left ,@(infix-read-delimited-list '\) '\, stream))
+    :prefix (let ((list (infix-read-delimited-list '\) '\, stream)))
+	      (if (null (rest list))
+		  ;; only one element in list. works correctly if list is NIL
+		  (first list)
+		  ;; several elements in list
+		  `(progn ,@list))))
+
+(define-character-tokenization #\]
+    #'(lambda (stream char)
+	(declare (ignore stream char))
+	'\]))
+(define-token-operator \]
+    :infix (infix-error "Extra close brace \"]\" in infix expression"))
+
+(define-character-tokenization #\)
+    #'(lambda (stream char)
+	(declare (ignore stream char))
+	'\)))
+(define-token-operator \)
+    :infix (infix-error "Extra close paren \")\" in infix expression"))
+
+#|
+;;; Commented out because no longer using $ as the macro character.
+(define-character-tokenization #\$
+    #'(lambda (stream char)
+	(declare (ignore stream char))
+	'%infix-end-token%))
+(define-token-operator %infix-end-token%
+    :infix (infix-error "Prematurely terminated infix expression")
+    :prefix (infix-error "Prematurely terminated infix expression"))
+|#
+
+(define-character-tokenization #\;
+    #'(lambda (stream char)
+	(declare (ignore char))
+	(do ((char (peek-char nil stream t nil t)
+		   (peek-char nil stream t nil t)))
+	    ((or (char= char #\newline) (char= char #\return)
+		 ;; was #\$
+;		 (char= char #\))
+		 )
+	     ;; Gobble characters until the end of the line or the
+	     ;; end of the input.
+	     (cond ((or (char= char #\newline) (char= char #\return))
+		    (read-char stream)
+		    (read stream t nil t))
+		   (t
+		    ;; i.e., return %infix-end-token%
+		    (read stream t nil t))))
+	  (read-char stream))))
+
+
+
+;;; ********************************
+;;; Syntactic Modifications ********
+;;; ********************************
+
+;;; Post processes the expression to remove some unsightliness caused
+;;; by the way infix processes the input. Note that it is also required
+;;; for correctness in the a<b<=c case. 
+
+(defun post-process-expression (expression)
+  (if (and (consp expression)
+	   (= (length expression) 3))
+      (destructuring-bind (operator left right) expression
+	(cond ((and (consp left)
+		    (same-operator-p (first left) operator)
+		    (find operator '(+ * / - and or < > <= >= progn)
+			  :test #'same-operator-p))
+	       ;; Flatten the expression if possible
+	       (cond ((and (eq operator '-)
+			   (= (length left) 2))
+		      ;; -a-b --> (+ (- a) (- b)). 
+		      `(+ ,left (- ,right)))
+		     ((and (eq operator '/)
+			   (= (length left) 2))
+		      ;; ditto with /
+		      `(/ (* ,(second left) ,right)))
+		     (t 
+		      ;; merges a+b+c as (+ a b c).	     
+		      (append left (list right)))))
+	      ((and (consp left)
+		    (eq operator '-)
+		    (eq (first left) '+))
+	       ;; merges a+b-c as (+ a b (- c)).
+	       (append left (list `(- ,right))))
+	      ((and (consp left)
+		    (find operator '(< > <= >=))
+		    (find (first left) '(< > <= >=)))
+	       ;; a<b<c --> a<b and b<c
+	       `(and ,left
+		     (,operator ,(first (last left))
+				,right)))
+	      (t
+	       expression)))
+      expression))
+
+
+
+;;; ********************************
+;;; Test Infix *********************
+;;; ********************************
+
+;;; Invoke with (infix:test-infix). 
+;;; Prints out all the tests that fail and a count of the number of failures.
+
+(defparameter *test-cases*
+    ;; Note that in strings, we have to slashify \ as \\.
+    '(("1 * +2"         (* 1 2))
+      ("1 * -2"         (* 1 (- 2)))
+      ("1 * /2"         (* 1 (/ 2)))
+      ("/2"             (/ 2))
+      ("not true"       (not true))
+      ("foo\\-bar"     foo-bar)
+      ("a + b-c"       (+ a b (- c)))
+      ("a + b\\-c"      (+ a b-c))
+      ("f\\oo"          |FoO|)
+      ("!foo-bar * 2"  (* foo-bar 2))
+      ("!(foo bar baz)" (foo bar baz))
+      ("!foo-bar "     foo-bar)
+      ;; The following now longer gives an eof error, since the close
+      ;; parenthesis terminates the token.
+      ("!foo-bar"      foo-bar)		; eof error -- ! eats the close $
+      ("a+-b"          (+ a (- b)))
+      ("a+b"           (+ a b))
+      ("a+b*c"         (+ a (* b c)))
+      ("a+b+c"         (+ a b c))
+      ("a+b-c"         (+ a b (- c)))
+      ("a+b-c+d"       (+ a b (- c) d))
+      ("a+b-c-d"       (+ a b (- c) (- d)))
+      ("a-b"           (- a b))
+      ("a*b"           (* a b))
+      ("a*b*c"         (* a b c))
+      ("a*b+c"         (+ (* a b) c))
+      ("a/b"           (/ a b))
+      ("a^b"           (expt a b))
+      ("foo/-bar"      (/ foo (- bar)))
+      ("1+2*3^4"       (+ 1 (* 2 (expt 3 4))))
+      ("1+2*3^4+5"     (+ 1 (* 2 (expt 3 4)) 5))
+      ("2*3^4+1"       (+ (* 2 (expt 3 4)) 1))
+      ("2+3^4*5"       (+ 2 (* (expt 3 4) 5)))
+      ("2^3^4"         (expt 2 (expt 3 4)))
+      ("x^2 + y^2"     (+ (expt x 2) (expt y 2)))
+      ("(1+2)/3"       (/ (+ 1 2) 3))
+      ("(a=b)"         (setq a b))
+      ("(a=b,b=c)"     (progn (setq a b) (setq b c)))
+      ("1*(2+3)"       (* 1 (+ 2 3)))
+      ("1+2/3"         (+ 1 (/ 2 3)))
+      ("a,b"           (progn a b))
+      ("a,b,c"         (progn a b c))
+      ("foo(a,b,(c,d))" (foo a b (progn c d)))
+      ("foo(a,b,c)"    (foo a b c))
+      ("(a+b,c)"       (progn (+ a b) c))
+      ("1"             1)
+      ("-1"            (- 1))
+      ("+1"            1)
+      ("1."            1)
+      ("1.1"           1.1)
+      ("1e3"           1000.0)
+      ("1e-3"          0.001)
+      ("1f-3"          1f-3)
+      ("1e-3e"         (- 1e 3e))
+      ("!1e-3 "        0.001)
+      ("a and b and c" (and a b c))
+      ("a and b or c"  (or (and a b) c))
+      ("a and b"       (and a b))
+      ("a or b and c"  (or a (and b c)))
+      ("a or b"        (or a b))
+      ("a<b and b<c"   (and (< a b) (< b c)))
+      ("if (if a then b else c) then e" (when (if a b c) e))
+      ("if 1 then 2 else 3+4"  (if 1 2 (+ 3 4)))
+      ("(if 1 then 2 else 3)+4"  (+ (if 1 2 3) 4))
+      ("if a < b then b else a"   (if (< a b) b a))
+      ("if a and b then c and d else e and f"
+       (if (and a b) (and c d) (and e f)))
+      ("if a or b then c or d else e or f" (if (or a b) (or c d) (or e f)))
+      ("if a then (if b then c else d) else e"  (if a (if b c d) e))
+      ("if a then (if b then c) else d"  (if a (when b c) d))
+      ("if a then b else c"       (if a b c))
+      ("if a then b"              (when a b))
+      ("if a then if b then c else d else e" (if a (if b c d) e))
+      ("if a then if b then c else d"  (when a (if b c d)))
+      ("if if a then b else c then e" (when (if a b c) e))
+      ("if not a and not b then c" (when (and (not a) (not b)) c))
+      ("if not a then not b else not c and d"
+       (if (not a) (not b) (and (not c) d)))
+      ("not a and not b" (and (not a) (not b)))
+      ("not a or not b" (or (not a) (not b)))
+      ("not a<b and not b<c"   (and (not (< a b)) (not (< b c))))
+      ("not a<b"       (not (< a b)))
+      ("a[i,k]*b[j,k]"          (* (aref a i k) (aref b j k)))
+      ("foo(bar)=foo[bar,baz]"  (setf (foo bar) (aref foo bar baz)))
+      ("foo(bar,baz)"           (foo bar baz))
+      ("foo[bar,baz]"           (aref foo bar baz))
+      ("foo[bar,baz]=barf"      (setf (aref foo bar baz) barf))
+      ("max = if a < b then b else a"   (setq max (if (< a b) b a)))
+      ("a < b < c"     (< A B C))
+      ("a < b <= c"    (and (< a b) (<= b c)))
+      ("a <= b <= c"   (<= A B C))
+      ("a <= b <= c"   (<= A B C))
+      ("a!=b and b<c"  (and (not (= a b)) (< b c)))
+      ("a!=b"          (not (= a b)))
+      ("a<b"           (< a b))
+      ("a==b"          (= a b))
+      ("a*b(c)+d"      (+ (* a (b c)) d))
+      ("a+b(c)*d"      (+ a (* (b c) d)))
+      ("a+b(c)+d"      (+ a (b c) d))
+      ("d+a*b(c)"      (+ d (* a (b c))))
+      ("+a+b"          (+ a b))
+      ("-a+b"          (+ (- a) b))
+      ("-a-b"          (+ (- a) (- b)))
+      ("-a-b-c"        (+ (- a) (- b) (- c)))
+      ("a*b/c"         (/ (* a b) c))
+      ("a+b-c"         (+ a b (- c)))
+      ("a-b-c"         (- a b c))
+      ("a/b*c"         (* (/ a b) c))
+      ("a/b/c"         (/ a b c))
+      ("/a/b"          (/ (* a b)))
+      ("a^b^c"         (expt a (expt b c)))
+      ("a(d)^b^c"      (expt (a d) (expt b c)))
+      ("a<b+c<d"       (< a (+ b c) d))
+      ("1*~2+3"        (+ (* 1 (lognot 2)) 3)) 
+      ("1+~2*3"        (+ 1 (* (lognot 2) 3))) 
+      ("1+~2+3"        (+ 1 (lognot 2) 3)) 
+      ("f(a)*=g(b)"    (setf (f a) (* (f a) (g b))))
+      ("f(a)+=g(b)"    (incf (f a) (g b)))
+      ("f(a)-=g(b)"    (decf (f a) (g b)))
+      ("f(a)/=g(b)"    (setf (f a) (/ (f a) (g b))))
+      ("a&b"           (logand a b))
+      ("a^^b"          (logxor a b))
+      ("a|b"           (logior a b))
+      ("a<<b"          (ash a b))
+      ("a>>b"          (ash a (- b)))
+      ("~a"            (lognot a))
+      ("a&&b"          (and a b))
+      ("a||b"          (or a b))
+      ("a%b"           (mod a b))
+
+      ;; Comment character -- must have carriage return after semicolon.
+      ("x^2   ; the x coordinate
+        + y^2 ; the y coordinate" :error)
+      ("x^2   ; the x coordinate
+        + y^2 ; the y coordinate
+        "              (+ (expt x 2) (expt y 2)))
+
+      ;; Errors
+      ("foo(bar,baz"   :error)		; premature termination
+      ;; The following no longer gives an error
+      ("foo(bar,baz))" (foo bar baz))	; extra close parenthesis
+      ("foo[bar,baz]]" :error)		; extra close bracket
+      ("[foo,bar]"     :error)		; AREF is not a prefix operator
+      ("and a"         :error)		; AND is not a prefix operator
+      ("< a"           :error)		; < is not a prefix operator
+      ("=bar"         :error)		; SETF is not a prefix operator
+      ("*bar"          :error)		; * is not a prefix operator
+      ("a not b"       :error)		; NOT is not an infix operator
+      ("a if b then c" :error)		; IF is not an infix operator
+      (""              :error)		; premature termination (empty clause)
+      (")a"            :error)		; left parent is not a prefix operator
+      ("]a"            :error)		; left bracket is not a prefix operator
+      ))
+
+(defun test-infix (&optional (tests *test-cases*))
+  (let ((count 0))
+    (dolist (test tests)
+      (destructuring-bind (string result) test
+	(unless (test-infix-case string result)
+	  (incf count))))
+    (format t "~&~:(~R~) test~p failed." count count)
+    (values)))
+
+(defun test-infix-case (string result)
+  (multiple-value-bind (value error)
+      (let ((*package* (find-package "INFIX")))
+	(ignore-errors
+	 (values (read-from-string (concatenate 'string "#I(" string ")")
+				   t nil))))
+    (cond (error
+	   (cond ((eq result :error)
+		  t)
+		 (t
+		  (format t "~&Test #I(~A) failed with ERROR." string)
+		  nil)))
+	  ((eq result :error)
+	   (format t "~&Test #I(~A) failed. ~
+                           ~&   Expected ERROR ~
+                           ~&   but got ~A." 
+		   string value)
+	   nil)
+	  ((not (equal value result))
+	   (format t "~&Test #I(~A) failed. ~
+                           ~&   Expected ~A ~
+                           ~&   but got ~A." 
+		   string result value)
+	   nil)
+	  (t
+	   t))))  
+
+;;; *EOF*
Index: /trunk/contrib/user_man/lisp-documentation.log
===================================================================
--- /trunk/contrib/user_man/lisp-documentation.log	(revision 8)
+++ /trunk/contrib/user_man/lisp-documentation.log	(revision 8)
@@ -0,0 +1,14 @@
+This is TeX, Version 3.14159 (C version 6.1) (format=tex 97.4.20)  28 NOV 1997 17:41
+**lisp-documentation.tex
+(lisp-documentation.tex
+Babel <v3.6h> and hyphenation patterns for american, german, loaded.
+! Undefined control sequence.
+l.30 \newlength
+               {\formnamelen}^^I% length of a name of a form
+? 
+! Emergency stop.
+l.30 \newlength
+               {\formnamelen}^^I% length of a name of a form
+End of file on the terminal!
+
+No pages of output.
Index: /trunk/contrib/user_man/lisp-documentation.tex
===================================================================
--- /trunk/contrib/user_man/lisp-documentation.tex	(revision 8)
+++ /trunk/contrib/user_man/lisp-documentation.tex	(revision 8)
@@ -0,0 +1,52 @@
+% -*- Mode: LaTeX -*-
+
+% lisp-documentation.tex --
+% Environment definition for use in connection with the 'user manual'
+% facility of Common Lisp
+%
+% Author: Marco Antoniotti
+% Address: Robotics Laboratory
+%          Courant Institute of Mathematical Science
+%          New York University
+%          New York, NY, 10012
+%
+% Copyright (c) 1992. All rights reserved.
+%
+% Version: 0.9 beta
+
+%==============================================================================
+% General License Agreement and Lack of Warranty
+%
+% See companion file user-manual.lisp
+
+
+%==============================================================================
+% History:
+% 01.05.93: created.
+
+%==============================================================================
+% Global definitions
+
+\newlength{\formnamelen}	% length of a name of a form
+\newlength{\pboxargslen}	% length of parbox for arguments
+\newlength{\typelen}		% length of the type label for the form
+
+\newcommand{\namestyle}{\sf}	% style for the name (still unused)
+\newcommand{\argsstyle}{\em}	% style for the arguments (still unused)
+
+
+%------------------------------------------------------------------------------
+% lisp:documentation environment
+
+\newenvironment{lisp:documentation}[3]{\paragraph{{\sf #1}}
+\settowidth{\formnamelen}{\sf #1}
+\settowidth{\typelen}{\em #2\/}
+\setlength{\pboxargslen}{\linewidth}
+\addtolength{\pboxargslen}{-1\formnamelen}
+\addtolength{\pboxargslen}{-1.5\typelen}
+\parbox[t]{\pboxargslen}{\em #3\/} \hfill[{\em #2\/}]
+\begin{quote}}{\end{quote}}
+
+% lisp:documentation
+
+% end of file -- lisp-documentation.tex --
Index: /trunk/contrib/user_man/user-manual.lisp
===================================================================
--- /trunk/contrib/user_man/user-manual.lisp	(revision 8)
+++ /trunk/contrib/user_man/user-manual.lisp	(revision 8)
@@ -0,0 +1,1351 @@
+;;;	$Id: user-manual.lisp,v 1.28 1997/12/03 02:38:33 marek Exp $	
+;;; ****************************************************************
+;;; CHANGE LOG:
+;;; * Added package stuff
+;;; * Modified by M. Rychlik (rychlik@math.arizona.edu)
+;;; so that create-manuals accepts a directory prefix
+;;; ****************************************************************
+
+(defpackage "USER-MANUAL"
+  (:export create-user-manual create-manuals text scribe latex))
+(in-package "USER-MANUAL")
+
+;;; Thu Oct 20 20:18:29 1994 by Mark Kantrowitz <mkant@GLINDA.OZ.CS.CMU.EDU>
+;;; user-manual.lisp -- 48831 bytes
+
+;;; ****************************************************************
+;;; Automatic User Manual Creation *********************************
+;;; ****************************************************************
+;;;
+;;; The Automatic User Manual Creation system is a common lisp portable
+;;; system for automatically generating user's guides from the 
+;;; source definitions and their documentation strings. It uses several
+;;; heuristics for formatting the documentation segments nicely.
+;;; If Waters' XP pretty printer is available, it uses that instead to 
+;;; format the argument lists.
+;;;
+;;; The user guide for this file was created using this program and
+;;; provides a good example of its capabilities. It was created by
+;;; evaluating (create-user-manual "user-manual.lisp").
+;;;
+;;; Written by Mark Kantrowitz, December 1990.
+;;;
+;;; Address: Carnegie Mellon University
+;;;          School of Computer Science
+;;;          Pittsburgh, PA 15213
+;;; 
+;;; Copyright (c) 1990. All rights reserved.
+;;; 
+;;; See general license below.
+;;;
+
+
+;;; ****************************************************************
+;;; General License Agreement and Lack of Warranty *****************
+;;; ****************************************************************
+;;;
+;;; This software is distributed in the hope that it will be useful (both
+;;; in and of itself and as an example of lisp programming), but WITHOUT
+;;; ANY WARRANTY. The author(s) do not accept responsibility to anyone for
+;;; the consequences of using it or for whether it serves any particular
+;;; purpose or works at all. No warranty is made about the software or its
+;;; performance. 
+;;; 
+;;; Use and copying of this software and the preparation of derivative
+;;; works based on this software are permitted, so long as the following
+;;; conditions are met:
+;;; 	o  The copyright notice and this entire notice are included intact
+;;; 	   and prominently carried on all copies and supporting documentation.
+;;; 	o  No fees or compensation are charged for use, copies, or
+;;; 	   access to this software. You may charge a nominal
+;;; 	   distribution fee for the physical act of transferring a
+;;; 	   copy, but you may not charge for the program itself. 
+;;; 	o  If you modify this software, you must cause the modified
+;;; 	   file(s) to carry prominent notices (a Change Log)
+;;; 	   describing the changes, who made the changes, and the date
+;;; 	   of those changes.
+;;; 	o  Any work distributed or published that in whole or in part
+;;; 	   contains or is a derivative of this software or any part 
+;;; 	   thereof is subject to the terms of this agreement. The 
+;;; 	   aggregation of another unrelated program with this software
+;;; 	   or its derivative on a volume of storage or distribution
+;;; 	   medium does not bring the other program under the scope
+;;; 	   of these terms.
+;;; 	o  Permission is granted to manufacturers and distributors of
+;;; 	   lisp compilers and interpreters to include this software
+;;; 	   with their distribution. 
+;;; 
+;;; This software is made available AS IS, and is distributed without 
+;;; warranty of any kind, either expressed or implied.
+;;; 
+;;; In no event will the author(s) or their institutions be liable to you
+;;; for damages, including lost profits, lost monies, or other special,
+;;; incidental or consequential damages arising out of or in connection
+;;; with the use or inability to use (including but not limited to loss of
+;;; data or data being rendered inaccurate or losses sustained by third
+;;; parties or a failure of the program to operate as documented) the 
+;;; program, even if you have been advised of the possibility of such
+;;; damanges, or for any claim by any other party, whether in an action of
+;;; contract, negligence, or other tortious action.
+;;; 
+;;; The current version of this software and a variety of related
+;;; utilities may be obtained by anonymous ftp from ftp.cs.cmu.edu
+;;; (128.2.206.173) or any other CS machine in the directory 
+;;;       user/ai/lang/lisp/code/tools/user_man/
+;;; 
+;;; Please send bug reports, comments, questions and suggestions to
+;;; mkant@cs.cmu.edu. We would also appreciate receiving any changes
+;;; or improvements you may make. 
+;;; 
+;;; If you wish to be added to the Lisp-Utilities@cs.cmu.edu mailing list, 
+;;; send email to Lisp-Utilities-Request@cs.cmu.edu with your name, email
+;;; address, and affiliation. This mailing list is primarily for
+;;; notification about major updates, bug fixes, and additions to the lisp
+;;; utilities collection. The mailing list is intended to have low traffic.
+;;;
+
+
+;;; ********************************
+;;; Change Log *********************
+;;; ********************************
+;;;
+;;; mk   = Mark Kantrowitz <mkant@cs.cmu.edu>
+;;; duff = David A. Duff <duff@starbase.MITRE.ORG>
+;;; rit  = Jean-Francois Rit <rit@cs.stanford.edu>
+;;; wds  = William D Smith <smithwd@kona.crd.ge.com>
+;;; dick = Dick Jackson <jackson@ciitip.ciit.nrc.ca>
+;;; ma   = Marco Antoniotti <marcoxa@image.cs.nyu.edu>
+;;; fdmm = Fernando D. Mato Mira <matomira@epfl.ch>
+;;;
+;;; 24-JAN-91 duff  Fixed bug in documentation handler for defstructs.
+;;; 24-JAN-91 duff  Documentation-handlers for Lucid.
+;;; 28-JAN-91 rit   Changed format clauses with @: to :@ in handle-form-output.
+;;;                 Otherwise Franz Allegro CL barfs.
+;;;           mk    Note that CLtL2 specifies that either is OK, although
+;;;                 :@ is traditional. 
+;;; 28-JAN-91 mk    Added Scribe output format in addition to TEXT output
+;;;                 format.
+;;; 31-JAN-91 duff  Doc-handler for define-condition.
+;;; 05-FEB-91 wds   Added doc-handlers for defmethod, defgeneric, defclass,
+;;;                 deftype and defsetf.
+;;; 05-FEB-91 mk    Fixed handler for defmethod to handle qualifiers such 
+;;;                 as :before, :after, and :around. Fixed defsetf handler
+;;;                 to include alternate format. Extended deftype handler. 
+;;; 07-FEB-91 dick  Doc-handlers for CLOS defclass. [This was better than
+;;;                 wds's. I've merged the capabilities of the two.
+;;;                 Also, I added :blank for use in leaving the args
+;;;                 position blank, and fixed split-string to not
+;;;                 trim whitespace in certain circumstances. --mk]
+;;; 08-FEB-91 wds   Specialized the code using conditional read macros
+;;;                 in case XP package not present.
+;;; 05-JAN-93 ma    Changed some of the inner working to add LaTeX
+;;;                 support: defvar, defconstant and defparameter have
+;;;                 their doc-handlers changed when they have nil as
+;;;                 default and support functions have bee added for
+;;;                 LaTeX. Also the structure of handle-form-output
+;;;                 has been slightly changed.
+;;;                 A LaTeX document including entries obtained via
+;;;                 create-user-manual must contain (e.g. by '\input')
+;;;                 the 'lisp:documentation' environment as defined in
+;;;                 the companion file 'lisp-documentation.tex'.
+;;; 03-MAR-93 fdmm  Added doc-handler for ECLOS defconstraint.
+;;; 03-MAR-93 fdmm  Added create-manuals.
+;;; 03-MAR-93 fdmm  Enhanced defclass doc-handler to output metaclass, readers,
+;;;                 writers, initargs and slot type info.
+;;; 04-MAR-93 fdmm  Fixed bug in handle-form-output (let --> let*).
+;;; 05-MAR-93 fdmm  Added basic FrameMaker(tm) support.
+;;; 17-OCT-94 fdmm  Added doc-handler for ECLOS defdaemon.
+;;; 17-OCT-94 fdmm  Accepts now :latex, etc. keywords, to avoid package
+;;;                 problems, but still accepts `bad style' arguments for
+;;;                 backwards compatibility. 
+;;; 20-OCT-94 mk    Added *userman-version* parameter.
+
+
+;;; ********************************
+;;; To Do **************************
+;;; ********************************
+;;;
+;;; Generalize it to also use the definition's comments to create
+;;; even more documentation. Essentially, change the #\; macro
+;;; character so that instead of killing the remainder of the line,
+;;; it processes it for the documentation. By making this program
+;;; understand some sort of structured comments, we can have it
+;;; ignore comment stubs and only include the meaty stuff.
+;;;
+;;; Clean up use of XP pretty printer.
+;;; 
+;;; Need 'latex output-format. In 'scribe mode, need to convert @ to @@.
+;;;
+;;; Note that using :output-format 'scribe and running scribe with
+;;; the -device FILE arguments should produce output similar to 
+;;; :output-format 'text, except without semicolons in the left margin.
+;;;
+
+
+;;; ********************************
+;;; Documentation Types ************
+;;; ********************************
+;;;
+;;; This is a list of the documentation types currently supported:
+;;; + = things in user-manual.lisp
+;;; - = things still missing from user-manual.lisp
+;;;
+;;;  COMMON-LISP forms:
+;;;
+;;;    + (DEFCLASS     name super-types slots &rest options )
+;;;    + (DEFCONSTANT  name initial-value &optional documentation )
+;;;    + (DEFGENERIC   name lambda-list &rest options )
+;;;    + (DEFMACRO     name lambda-list documentation ... )
+;;;    + (DEFMETHOD    name lambda-list documentation ... )
+;;;    -  defpackage
+;;;    + (DEFPARAMETER name initial-value &optional documentation )
+;;;    + (DEFSETF      name function documentation )
+;;;    + (DEFSTRUCT    name+options documentation &rest slots )
+;;;    + (DEFTYPE      name lambda-list documentation ... )
+;;;    + (DEFUN        name lambda-list documentation ... )
+;;;    + (DEFVAR       name &optional initial-value documentation )
+;;;
+;;;  ECLOS forms:
+;;;
+;;;    + (DEFCONSTRAINT name super-types lambda-list documentation ...)
+;;;    + (DEFDAEMON     name super-types lambda-list documentation ...)
+;;;
+
+
+;;; ********************************
+;;; Notes **************************
+;;; ********************************
+;;;
+;;;    USER-MANUAL has been tested (successfully) in the following lisps:
+;;;       CMU Common Lisp (M2.9 15-Aug-90, Compiler M1.8 15-Aug-90)
+;;;       Macintosh Allegro Common Lisp (1.3.2)
+;;;       ExCL (Franz Allegro CL 3.1.12 [DEC 3100] 3/30/90)
+;;;       Lucid CL (Version 2.1 6-DEC-87)
+;;;
+;;;    USER-MANUAL needs to be tested in the following lisps:
+;;;       Symbolics Common Lisp (8.0)
+;;;       Lucid Common Lisp (3.0)
+;;;       Lucid Common Lisp (4.0)
+;;;       KCL (June 3, 1987 or later)
+;;;       AKCL (1.86, June 30, 1987 or later)
+;;;       TI (Release 4.1 or later)
+;;;       Ibuki Common Lisp (01/01, October 15, 1987)
+;;;       Golden Common Lisp (3.1 IBM-PC)
+;;;       VAXLisp (2.0, 3.1)
+;;;       HP Common Lisp (same as Lucid?)
+;;;       Procyon Common Lisp
+
+
+
+;;; ********************************
+;;; User Guide *********************
+;;; ********************************
+;;;
+;;; EXTRACT-DOCUMENTATION (body)                                        [MACRO]
+;;;
+;;; ATOM-OR-CAR (list-or-atom)                                       [FUNCTION]
+;;;
+;;; *DOCUMENTATION-HANDLERS* (make-hash-table :test                  [VARIABLE]
+;;;                           (function equal))
+;;;    Hash table of entries of the form (handler description),
+;;;    where definer is the car of the definition form handled (for
+;;;    example, DEFUN or DEFMACRO), handler is a function which takes the
+;;;    form as input and value-returns the name, argument-list and
+;;;    documentation string, and description is a one-word equivalent of
+;;;    definer (for example, FUNCTION or MACRO).
+;;;
+;;; DEFINE-DOC-HANDLER (definer arglist description &body body)         [MACRO]
+;;;    Defines a new documentation handler. DEFINER is the car of the
+;;;    definition form handled (e.g., defun), DESCRIPTION is a one-word
+;;;    string equivalent of definer (e.g., "function"), and ARGLIST
+;;;    and BODY together define a function that takes the form as input
+;;;    and value-returns the name, argument-list, documentation string,
+;;;    and a list of any qualifiers of the form.
+;;;
+;;; FIND-DOC-HANDLER (definer)                                       [FUNCTION]
+;;;    Given the car of a form, finds the appropriate documentation
+;;;    handler for the form if one exists.
+;;;
+;;; DEFINE-DOC-HANDLER (form)                                     [DOC-HANDLER]
+;;;    Documentation handler for doc-handlers.
+;;;
+;;; DEFVAR (form)                                                 [DOC-HANDLER]
+;;;    Documentation handler for variables.
+;;;
+;;; DEFCONSTANT (form)                                            [DOC-HANDLER]
+;;;    Documentation handler for constants.
+;;;
+;;; DEFPARAMETER (form)                                           [DOC-HANDLER]
+;;;    Documentation handler for parameters.
+;;;
+;;; DEFUN (form)                                                  [DOC-HANDLER]
+;;;    Documentation handler for functions.
+;;;
+;;; DEFMACRO (form)                                               [DOC-HANDLER]
+;;;    Documentation handler for macros.
+;;;
+;;; DEFSTRUCT (form)                                              [DOC-HANDLER]
+;;;    Documentation handler for structures.
+;;;
+;;; DEFINE-CONDITION (form)                                       [DOC-HANDLER]
+;;;    Documentation handler for conditions.
+;;;
+;;; DEFTYPE (form)                                                [DOC-HANDLER]
+;;;    Documentation handler for types.
+;;;
+;;; DEFSETF (form)                                                [DOC-HANDLER]
+;;;    Documentation handler for setf mappings.
+;;;
+;;; DEFMETHOD (form)                                              [DOC-HANDLER]
+;;;    Documentation handler for methods.
+;;;
+;;; DEFGENERIC (form)                                             [DOC-HANDLER]
+;;;    Documentation handler for generic functions.
+;;;
+;;; DEFCLASS (form)                                               [DOC-HANDLER]
+;;;    Documentation handler for classs.
+;;;
+;;; DEFCONSTRAINT (form)                                          [DOC-HANDLER]
+;;;    Documentation handler for constraints.
+;;;
+;;; DEFDAEMON (form)                                              [DOC-HANDLER]
+;;;    Documentation handler for daemons.
+;;;
+;;; *FAILED-DEFINITION-TYPES* "()"                                   [VARIABLE]
+;;;    List of definition types that create-user-manual couldn't handle.
+;;;
+;;; CREATE-USER-MANUAL (filename &key (output-format (quote text))   [FUNCTION]
+;;;                     (output-stream *standard-output*))
+;;;    Automatically creates a user manual for the functions in a file by 
+;;;    collecting the documentation strings and argument lists of the
+;;;    functions and formatting the output nicely. Returns a list of the
+;;;    definition types of the forms it couldn't handle. Output-format
+;;;    may be either 'TEXT or 'SCRIBE.
+;;;
+;;; HANDLE-FORM-OUTPUT (form &optional (output-format (quote text))  [FUNCTION]
+;;;                     (stream *standard-output*))
+;;;    This function takes a form as input and outputs its documentation
+;;;    segment to the output stream.
+;;;
+;;; OUTPUT-TEXT-DOCUMENTATION (name type args documentation          [FUNCTION]
+;;;                            args-tab-pos type-pos
+;;;                            &optional (stream *standard-output*))
+;;;    Prints out the user guide entry for a form in TEXT mode.
+;;;
+;;; OUTPUT-SCRIBE-DOCUMENTATION (name type args documentation        [FUNCTION]
+;;;                              &optional
+;;;                              (stream *standard-output*))
+;;;    Prints out the user guide entry for a form in SCRIBE mode.
+;;;
+;;; XP-SPLIT-STRING (arglist width)                                  [FUNCTION]
+;;;    PPrints the arglist into a string of specified width. Assumes
+;;;    that we're running the XP pretty printer.
+;;;
+;;; SPLIT-STRING (string width &optional arglistp filled             [FUNCTION]
+;;;               (trim-whitespace t))
+;;;    Splits a string into a list of strings, each of which is shorter
+;;;    than the specified width. Tries to be intelligent about where to
+;;;    split the string if it is an argument list. If filled is T,
+;;;    tries to fill out the strings as much as possible. This function
+;;;    is used to break up long argument lists nicely, and to break up
+;;;    wide lines of documentation nicely.
+;;;
+;;; SPLIT-POINT (string max-length &optional arglistp filled)        [FUNCTION]
+;;;    Finds an appropriate point to break the string at given a target
+;;;    length. If arglistp is T, tries to find an intelligent position to
+;;;    break the string. If filled is T, tries to fill out the string as
+;;;    much as possible. 
+;;;
+;;; LAMBDA-LIST-KEYWORD-POSITION (string                             [FUNCTION]
+;;;                               &optional end trailer-only)
+;;;    If the previous symbol is a lambda-list keyword, returns
+;;;    its position. Otherwise returns end.
+;;;
+;;; BALANCED-PARENTHESIS-POSITION (string &optional end)             [FUNCTION]
+;;;    Finds the position of the left parenthesis which is closest to END
+;;;    but leaves the prefix of the string with balanced parentheses or
+;;;    at most 1 unbalanced left parenthesis.
+;;;
+;;; PARSE-WITH-DELIMITER (line &optional (delim #\newline))          [FUNCTION]
+;;;    Breaks LINE into a list of strings, using DELIM as a 
+;;;    breaking point.
+;;;
+
+
+;;; ********************************
+;;; Version Information ************
+;;; ********************************
+
+(defparameter *userman-version* "2.0 20-OCT-94"
+  "Current verison number/date for User-Manual.")
+
+(defun userman-copyright (&optional (stream *standard-output*))
+  "Prints a User Manual copyright notice and header upon startup."
+  (format stream "~%;;; ~V,,,'*A" 73 "*")
+  (format stream "~%;;;   UserMan: Automatic User Manual Creation.")
+  (format stream "~%;;;   Version ~A." *userman-version*)
+  (format stream "~%;;;   Written by Mark Kantrowitz, CMU School of Computer Science.")
+  (format stream "~%;;;   Copyright (c) 1990-94. All rights reserved.")
+  (format stream "~%;;;   Use, copying, modification, and distribution permitted.")
+  (format stream "~%;;;   See the copyright notice in the source for details.")
+  (format stream "~%;;; ~V,,,'*A~%" 73 "*")
+  (force-output stream))
+
+(userman-copyright)
+
+;;; ********************************
+;;; Check for XP *******************
+;;; ********************************
+
+;; If the XP package is available, add :XP to *features* so that
+;; the conditional read macros will work.
+(when (find-package "XP") (push :XP *FEATURES*))
+
+;;; ********************************
+;;; Utilities **********************
+;;; ********************************
+
+(defmacro extract-documentation (body)
+  `(when (and (stringp (car ,body))
+	      (cdr ,body))
+     (pop ,body)))
+
+(defun atom-or-car (list-or-atom)
+  (if (listp list-or-atom)
+      (first list-or-atom)
+      list-or-atom))
+
+;;; ********************************
+;;; Documentation Handlers *********
+;;; ********************************
+(defvar *documentation-handlers* (make-hash-table :test #'equal)
+  "Hash table of entries of the form (handler description),
+   where definer is the car of the definition form handled (for example,
+   DEFUN or DEFMACRO), handler is a function which takes the form as input
+   and value-returns the name, argument-list and documentation string,
+   and description is a one-word equivalent of definer (for example,
+   FUNCTION or MACRO).")
+
+(defmacro define-doc-handler (definer arglist description &body body)
+  "Defines a new documentation handler. DEFINER is the car of the
+   definition form handled (e.g., defun), DESCRIPTION is a one-word
+   string equivalent of definer (e.g., \"function\"), and ARGLIST
+   and BODY together define a function that takes the form as input
+   and value-returns the name, argument-list, documentation string, 
+   and a list of any qualifiers of the form."
+  `(setf (gethash ',definer *documentation-handlers*)
+	 (list #'(lambda ,arglist
+		   ,@body)
+	       ,description)))
+
+(defun find-doc-handler (definer)
+  "Given the car of a form, finds the appropriate documentation
+   handler for the form if one exists."
+  (gethash definer *documentation-handlers*))
+
+(define-doc-handler define-doc-handler (form)
+  "doc-handler"
+  ;; name arglist documentation-string
+  (values (second form)
+	  (third form)
+	  (format nil "Documentation handler for ~A~P."
+		  (fourth form) 2)))
+
+;;; Changed the return form for the arguments in defvar, defconstant
+;;; and defparameter (basically 'listified' them).
+
+(define-doc-handler defvar (form)
+  "variable"
+  ;; name arglist documentation-string
+  (values (second form)
+	  (list (third form))
+	  (fourth form)))
+
+(define-doc-handler defconstant (form)
+  "constant"
+  ;; name arglist documentation-string
+  (values (second form)
+	  (list (third form))
+	  (fourth form)))
+
+(define-doc-handler defparameter (form)
+  "parameter"
+  ;; name arglist documentation-string
+  (values (second form)
+	  (list (third form))
+	  (fourth form)))
+
+(define-doc-handler defun (form)
+  "function"
+  ;; name arglist documentation-string
+  (values (second form)
+	  (third form)
+	  (when (stringp (fourth form)) (fourth form))))
+
+(define-doc-handler defconstraint (form)
+  "constraint"
+  ;; name super-types arglist documentation-string
+  (let ((superclass-names (third form)))
+    (values (second form) 
+	    (fourth  form)
+	    (format nil "~@[~A~]~%Superclasses~%~:[~:(~A~)~;~{~(~A~)~}~]"
+		    (when (stringp (fifth form)) (fifth form))
+		    superclass-names (or superclass-names "None."))))) ; super-types
+
+(define-doc-handler defdaemon (form)
+  "daemon"
+  ;; name super-types arglist documentation-string
+  (let ((superclass-names (third form)))
+    (values (second form)
+	    (fourth  form)
+	    (format nil "~@[~A~]~%Superclasses~%~:[~:(~A~)~;~{~(~A~)~}~]"
+		    (when (stringp (fifth form)) (fifth form))
+		    superclass-names (or superclass-names "None."))))) ; super-types
+
+(define-doc-handler defmacro (form)
+  "macro"
+  ;; name arglist documentation-string
+  (values (second form)
+	  (third form)
+	  (when (stringp (fourth form)) (fourth form))))
+
+(define-doc-handler defstruct (form)
+  "structure"
+  ;; name arglist documentation-string
+  (values (atom-or-car (second form))
+	  (mapcar #'atom-or-car
+		  (if (stringp (third form))
+		      (cdddr form)
+		      (cddr form)))
+	   (third form)))
+
+(define-doc-handler define-condition (form)
+  "condition"
+  (values (cadr form)
+          ;; handled here like defstruct. 
+	  ;; might want to skip this and return nil.
+          (mapcar #'atom-or-car (fourth form))
+          (cadr (find :documentation (nthcdr 4 form) :key #'car))))
+
+(define-doc-handler DEFTYPE (form)
+  "type"
+  (let ((name (second form))
+	(args (third form))
+	doc def)
+    (setq form (cdddr form))
+    (setq doc (extract-documentation form))
+    (when (null (cdr form))
+      (setq def (car form)))
+    ;; We give a try at the type definition if the body of the deftype
+    ;; form consists of a single form.
+    (if def
+	(values name def doc (list args))
+	(values name args doc))))
+
+#|
+(define-doc-handler DEFTYPE (form)
+  "type"
+  (values (second form)
+          (third  form)
+          (fourth form)))
+|#
+
+(define-doc-handler DEFSETF (form)
+  "setf mapping"
+  ;; name args doc. 
+  ;; defsetf has two formats:
+  ;;    (defsetf name update-fn doc)
+  ;;    (defsetf name lambda-list (store-variable) doc-string body)
+  (cond ((listp (third form))
+	 ;; long format
+	 (values `(setf ,(second form))
+		 (fourth form) ; store variable
+		 (fifth form)))
+	(t
+	 ;; short format
+	 (values `(setf ,(second form))
+		 (third  form)
+		 (fourth form)))))
+
+;;; ********************************
+;;; CLOS Related *******************
+;;; ********************************
+
+(define-doc-handler DEFMETHOD (form)
+  "method"
+  ;; name arglist documentation-string
+  ;; (defmethod name {qualifiers}* lambda-list [ {decl}* || doc ] body)
+  (let (name quals args doc)
+    (setf name (second form))
+    (do ((form (cddr form) (cdr form)))
+	((or (null form)
+	     ;; qualifiers are non-nil atoms while lambda-list is a list.
+	     (listp (car form)))
+	 (setq quals (nreverse quals))
+	 (setq args (car form))
+	 (setq form (cdr form))
+	 (setq doc (extract-documentation form))
+	 (values name args doc quals))
+      (when (atom (car form))
+	(push (car form) quals)))))
+
+#|
+(define-doc-handler DEFMETHOD (form)
+  "method"
+  ;; name arglist documentation-string
+  (let* ((name (second form))
+         (qual (when (symbolp (third form)) (third form)))
+         (args (if qual
+                   (cons qual (fourth form))
+                   (third form)))
+         (doc  (if qual (fifth form) (fourth form))))
+    (values name args doc)))
+
+;; Dick's version:
+(define-doc-handler defmethod (form)
+  "method"
+  ;; name arglist documentation-string
+  (if (listp (third form))
+    (values (second form)
+            (third form)
+            (format nil "Primary method~%~A"
+                    (if (stringp (fourth form))
+                      (fourth form)
+                      "")))
+    (values (second form)
+            (fourth form)
+            (format nil ":~A method~%~A"
+                    (third form)
+                    (if (stringp (fifth form))
+                      (fifth form)
+                      "")))))
+
+|#
+
+;;; DEFGENERIC: misses many options (eg, compile optimizations, etc.)
+(define-doc-handler DEFGENERIC (form)
+  "generic function"
+  ;; name arglist documentation-string
+  (values (second form)
+          (third  form)
+          ;; doc-string is embedded in body of DEFGENERIC:
+          (second (assoc :documentation (cdddr form)))))
+
+(defun listify (x)
+  (if (null x)
+      x
+    (if (atom x)
+	(list x)
+      x)))
+
+(defun null-or-cdr (l)
+  (if l
+      (cdr l)
+    l))
+
+(defun null-or-cadr (l)
+  (if l
+      (cadr l)
+    l))
+
+(define-doc-handler DEFCLASS (form)
+  "class"
+  ;; name super-types slots &rest options
+  (let ((class-options (nthcdr 4 form))
+	(class-name (second form))
+	(superclass-names (third form))
+	(slots (fourth form)))
+    (values class-name
+	    :blank			; no args per se
+	    (format nil "~@[~A~]~@[~%Metaclass~%~(~A~)~]~%Superclasses~%~:[~:(~A~)~;~{~(~A~)~}~]~
+                       ~%Initialization Arguments~:[~%None.~;~@[~:{~@[~%The :~(~A~) argument is a ~@[~(~A~)~]~]~}~]~]~
+                       ~%Readers~:[~%None.~;~@[~{~@[~{~@[~{~%~(~A~)~AGeneric Function~
+                                                           ~%~A~(~A~)~
+                                                           ~%Returns ~@[~A~]~
+                                                         ~}~]~
+                                                    ~}~]~
+                                               ~}~]~]~
+                       ~%Writers~:[~%None.~;~@[~{~@[~{~@[~{~%setf (~(~A~) ~(~A~))~AGeneric Setf Form~
+                                                           ~%~A~(~A~)~
+                                                           ~%The ~(~A~) argument should be a ~
+                                                           ~@[~A~]~
+                                                         ~}~]~
+                                                    ~}~]~
+                                               ~}~]~]"   
+		    ;; Class documentation
+		    (second (assoc :documentation class-options))
+		    ;; Metaclass
+		    (second (assoc :metaclass class-options))
+		    ;; Superclasses
+		    superclass-names (or superclass-names "None.")
+		    slots
+		    (mapcar #'(lambda (slot)
+				 (if (atom slot)
+				     nil
+				   (let ((key (null-or-cadr (member :initarg slot))))
+				     (if key
+					 (list key
+					       (null-or-cadr (member :type slot)))
+				       nil))))
+			    slots)
+		    slots
+		    (mapcar #'(lambda (slot)
+				(if (atom slot)
+				    nil
+				  (mapcar #'(lambda (acc)
+					      (list acc #\tab 
+						    #\tab class-name
+						    (null-or-cadr (member :documentation slot))
+						    ))
+					  (append (listify (null-or-cadr (member :reader slot)))
+						  (listify (null-or-cadr (member :accessor slot)))))))
+					  
+			    slots)
+		    slots
+		    (mapcar #'(lambda (slot)
+				(if (atom slot)
+				    nil
+				  (mapcar #'(lambda (acc)
+					      (list acc class-name #\tab 
+						    #\tab acc
+						    acc
+						    (null-or-cadr (member :documentation slot))
+						    ))
+					  (append (listify (null-or-cadr (member :writer slot)))
+						  (listify (null-or-cadr (member :accessor slot)))))))
+					  
+			    slots)
+		    ))))		    
+		    
+
+;;; ********************************
+;;; Doc Handlers for Lucid's FFI ***
+;;; ********************************
+;;; Doc-handlers for Lucid's foreign function interface
+
+#+:lucid
+(define-doc-handler def-foreign-synonym-type (form)
+  "foreign synonym type"
+  (values (second form) (third form) nil))
+
+#+:lucid
+(define-doc-handler def-foreign-struct (form)
+  "foreign synonym type"
+  (values (second form)
+	  (mapcar #'car
+		  (cddr form))
+	  nil))
+
+#+:lucid
+(define-doc-handler def-foreign-function (form)
+  "foreign function"
+  (values (atom-or-car (second form))
+	  (if (stringp (third form))
+	      (cddr form)
+	      (cdddr form))
+	  (third form)))
+
+
+
+
+;;; ********************************
+;;; Create User Manual *************
+;;; ********************************
+(defvar *failed-definition-types* nil
+  "List of definition types that create-user-manual couldn't handle.")
+
+(defun create-user-manual (filename &key
+				    (output-format 'text)
+				    (output-stream *standard-output*)
+				    (purge-latex t)
+				    (purge-latex-in-doc-strings t))
+  "Automatically creates a user manual for the functions in a file by 
+   collecting the documentation strings and argument lists of the 
+   functions and formatting the output nicely. Returns a list of the
+   definition types of the forms it couldn't handle. Output-format may
+   be either 'TEXT, 'SCRIBE or 'LATEX. In this last case the extra
+   keyword 'purge-latex' may be specified: if non nil the latex filter
+   will try to substitute possible dangerous characters like '&', '\\' and
+   '#'."
+  (setq *failed-definition-types* nil)
+  (with-open-file (stream filename :direction :input)
+    (let ((eof (gensym)))
+      (format t "~%;;; Formatting ")
+      (case output-format
+	((text :text) (format t "text"))
+	((scribe :scribe) (format t "SCRIBE"))
+	((latex :latex) (format t "LaTeX")))
+      (format t " manual from Lisp file: ~a" filename)
+      (do ((form (read stream nil eof nil)
+		 (read stream nil eof nil)))
+	  ((eq form eof)
+	   *failed-definition-types*)
+	(when (listp form)
+	  (handle-form-output form
+			      output-format
+			      output-stream
+			      purge-latex
+			      purge-latex-in-doc-strings))))))
+
+(defun handle-form-output (form &optional (output-format 'text)
+					  (stream *standard-output*)
+					  (purge-latex t)
+					  (purge-latex-in-doc-strings t))
+  "This function takes a form as input and outputs its documentation
+   segment to the output stream."
+  (let* ((key (first form))
+	 (handler-entry (find-doc-handler key)))
+    (cond (handler-entry 
+	   (let ((handler (first handler-entry))
+		 (type (second handler-entry))
+		 )
+	     (multiple-value-bind (name args documentation qualifiers) 
+		 (funcall handler form)
+	       (let ((name-length 0)
+		     (args (cond ((stringp args) ; variable
+				  (format nil "~S" args))
+				 ((null args)
+				  "()")
+				 ((eq args :blank) "")
+				 (t args)))
+		     (type-pos (- 80 1)) ; 1 for right margin
+		     (args-list-form args)
+		     )
+		 (setq name (format nil "~:@(~A~)~@[~{ ~S~}~]" name qualifiers)
+		       type (format nil "~:@(~A~)" type)
+		       name-length (length name)
+		       )
+		 ;; subtract the width of [type]
+		 (decf type-pos (+ (length type) 2))
+		 (let ((width (- type-pos (+ 1 4 1 ) name-length)))
+		   (unless (or (eq output-format 'text)
+			       (eq output-format :text))
+		     ;; Add in the width of ";;; " since we use it 
+		     ;; only in text mode.
+		     (incf width 4))
+		   (setq args
+			 #+:XP(xp-split-string args width)
+			 #-:XP(split-string (format nil "~(~S~)" args)
+					    width t)))
+		 (ccase output-format
+		   ((text :text)
+		    (output-text-documentation name type args documentation
+					       name-length type-pos
+					       stream))
+		   ((scribe :scribe)
+		    (output-scribe-documentation name type args documentation
+						 stream))
+		   ((latex :latex)
+		    (output-latex-documentation name type
+						args-list-form
+						documentation
+						stream
+						purge-latex
+						purge-latex-in-doc-strings)))
+		 ))))
+	  ((eq key 'eval-when)
+	   (dolist (f (cddr form))
+	     (handle-form-output f output-format stream)))
+	  (t
+	   (pushnew key *failed-definition-types*)))))
+
+(defun find-keyword (sym)
+  (find-symbol (symbol-name sym) :keyword))
+
+(defun output-frame-documentation (name type args documentation
+				       &optional (stream *standard-output*))
+  "Prints out the user guide entry for a form in FrameMaker(tm) mode." 
+  (format stream "~%~A~A~A~%" name #\tab (string-capitalize (symbol-name type)))
+  (when (and args (not (equal args '(()))))
+    (format stream "Syntax~%")
+    (format stream "~A" name)
+    (format stream "~A" #\tab)
+    (let ((&rest-p nil)
+	  (&key-p nil)
+	  (&aux-p nil)
+	  (&optional-p nil)
+	  (first-&aux-p t)
+	  (first-&key-p t)
+	  (first-&optional-p t))
+      (dolist (arg args)
+	(case arg
+	  (&rest (setf &rest-p t)
+		 (setf &key-p nil)
+		 (setf &optional-p nil)
+		 (format stream "~%~A&rest~A" #\tab #\tab))
+	  (&key (setf &key-p t) 
+		(setf &rest-p nil)
+		(setf &optional-p nil)
+		(format stream "~%~A&key~A" #\tab #\tab))
+	  (&optional (setf &optional-p t) 
+		     (setf &rest-p nil)
+		     (setf &key-p nil)
+		     (format stream "~%~A&optional~A" #\tab #\tab))
+	  (&aux (setf &aux-p t)
+		(setf &rest-p nil)
+		(setf &key-p nil) 
+		(setf &optional-p nil)
+		(format stream "~%~A&aux" #\tab))
+	  (t (cond (&rest-p 
+		    (format stream "~(~A~)" arg))
+		   (&aux-p 
+		    (unless first-&aux-p
+		      (format stream "~%~%~A~A" #\tab #\tab)
+		      (setf first-&aux-p nil))
+		    (format stream "~(~A~)" arg))
+		   (&key-p 
+		    (unless first-&key-p
+		      (format stream "~%~%~A~A" #\tab #\tab)
+		      (setf first-&key-p nil))
+		    (if (listp arg)
+			(let ((key (car arg)))
+			  (if (listp key)
+			      (format stream "~((:~A ~A)~)" 
+				      (car key)
+				      (second arg))
+			    (format stream "(:~(~A~) ~(~A)~)" 
+				    key
+				    (second arg))))
+		      (format stream "~(~A~) " arg)))
+		   (&optional-p
+		    (unless first-&optional-p
+		      (format stream "~%~%~A~A" #\tab #\tab)
+		      (setf first-&optional-p nil))
+		    (format stream "~(~A~) " 
+			    (if (listp arg)
+				(cons (car arg) (cadr arg))
+			      arg)))
+		   (t ;;(if (listp arg)
+		    ;;	  (format stream "(~(~A~) ~(~A~))" (first arg) (second arg))
+		    (format stream "~%~A~(~A~)" #\tab arg)))))))
+    (when args
+      (format stream "~%Arguments")
+      (let ((&rest-p nil)
+	    (&key-p nil)
+	    (&optional-p nil))
+	(dolist (arg args)
+	  (case arg
+	    (&rest (setf &rest-p t))
+	    (&key (setf &key-p t) 
+		  (setf &rest-p nil)
+		  (setf &optional-p nil))
+	    (&optional (setf &optional-p t) 
+		       (setf &rest-p nil)
+		       (setf &key-p nil))
+	    (&aux (setf &rest-p nil)
+		  (setf &key-p nil) 
+		  (setf &optional-p nil))
+	    (&allow-other-keys (setf &rest-p nil))     
+	    (t (cond (&rest-p
+		      (format stream "~%The ~(~A~) argument consists of " arg)
+		      (setf &rest-p nil))
+		     (t (format stream "~%The ")
+			(cond (&key-p 
+			       (if (listp arg)
+				   (let ((key (car arg)))
+				     (format stream ":~(~A~)" 				      
+					     (if (listp key)
+						 (car key)
+					       key)))
+				 (format stream ":~(~A~)" arg)))
+			      (&optional-p
+			       (format stream "~(~A~)" 
+				       (if (listp arg)
+					   (car arg)
+					 arg)))
+			      (t (if (listp arg)
+				     (format stream "~(~A~)" (car arg))
+				   (format stream "~(~A~)" arg))))
+			(format stream " argument is a "))))))))
+    (format stream "~%Values~%The result is ")	
+    (format stream "~%Purpose"))
+  (when (stringp documentation)
+    (format stream "~%")
+    (format stream documentation)))
+
+(defun output-text-documentation (name type args documentation args-tab-pos
+				       type-pos
+				       &optional (stream *standard-output*))
+  "Prints out the user guide entry for a form in TEXT mode." 
+  (format stream "~%;;; ~A ~A ~VT[~A]" name (first args) type-pos type)
+  (dolist (arg (rest args))
+    (format stream "~%;;; ~0,1,V,' @A" 
+	    (+ #+:XP 1 #-:XP 2 args-tab-pos)
+	    arg))
+  (when (stringp documentation)
+    ;; We give a line width of 70 characters for documentation
+    ;; strings. This leaves us room for a left margin of
+    ;; ";;;    " and a right margin of 3 spaces (2 chars left of []).
+    (dolist (string (split-string documentation 70 nil nil nil))
+      (format stream "~&;;;    ~A" string)))
+  (format stream "~%;;;"))
+
+(defun output-scribe-documentation (name type args documentation 
+					 &optional (stream *standard-output*))
+  "Prints out the user guide entry for a form in SCRIBE mode."
+  (format stream "~%@begin(format,group)~%@tabclear()")
+  (format stream "~%@t[~(~A~)] @^~A@>[~:(~A~)]"
+	  name (first args) type)
+  (dolist (arg (rest args))
+    (format stream #+:XP "~%@\\@ ~A" #-:XP "~%@\\~A"
+	    arg))
+  (format stream "~%@tabclear()")
+  ;; (format stream "~%@hinge()")
+  (format stream "~%@begin(quotation,indent 0,size +0)")
+  (when (stringp documentation)
+    (dolist (string (split-string documentation 70 nil nil nil))
+      (format stream "~%~A" string)))
+  (format stream "~%@end(quotation)~%@end(format)~%"))
+
+(defun output-latex-documentation (name type args documentation 
+					 &optional
+					 (stream *standard-output*)
+					 (purge-documentation t)
+					 (purge-documentation-in-doc-strings t))
+  "Prints out the user guide entry for a form in LaTeX mode."
+  (format stream "\\begin{lisp:documentation}")
+  (format stream "{~(~A~)}{~A}" (purge-string-for-latex name purge-documentation) type)
+  (format stream "~:[{\\ }~;{~{~(~A~) ~}}~]~%"
+	  args (preprocess-lisp-latex-clashes args purge-documentation))
+  (if (stringp documentation)
+    (format stream "~{~A~%~}"
+	    (split-string (purge-string-for-latex documentation
+						  purge-documentation-in-doc-strings)
+			  70 nil nil nil))
+    (format stream "{\\ } % NO DOCUMENTATION FOR ~A~%" name))
+  (format stream "\\end{lisp:documentation}~2%"))
+
+(defun purge-string-for-latex (a-string purge-doc)
+  "Tries to purge a string from characters that are potentially
+   dangerous for LaTeX."
+  (if purge-doc
+      (with-input-from-string (a-str a-string)
+	(with-output-to-string (result)
+	  (let ((eos (gensym)))
+	    (do ((c (read-char a-str nil eos nil)
+		    (read-char a-str nil eos nil)))
+		((eq c eos) result)
+	      (case c
+		(#\& (format result "\\&"))
+		(#\\ (format result "$\\backslash$")) ; I have to
+						      ; resort to math
+						      ; mode to do this.
+		(#\# (format result "\\#"))
+		(#\$ (format result "\\$"))
+		(#\% (format result "\\%"))
+		(#\{ (format result "\\{"))
+		(#\} (format result "\\}"))
+		(#\_ (format result "\\_}"))
+		(#\> (format result "$>$"))	      ;how to do this right? (M.R)
+		(#\< (format result "$<$"))
+		(#\^ (format result "\\symbol{94}"))
+		(#\~ (format result "\\symbol{126}"))
+		(t   (format result "~C" c)))))
+	  ))
+      a-string
+      ))
+
+(defun preprocess-lambda-keywords (args)
+  "Unused"
+  (mapcar #'(lambda (arg)
+	      (if (member arg lambda-list-keywords :test #'eq)
+		  (format nil "{\\sf \\~(~A~)}" arg)
+		  arg))
+	  args))
+
+(defun preprocess-lisp-latex-clashes (args purge-doc)
+  "This function is used to make the strings for the arguments of the
+   form digestible for LaTeX, e.g. by removing '#' and '&'."
+  (if (stringp args)
+      (list args)
+      (mapcar #'(lambda (arg)
+		  (cond ((member arg lambda-list-keywords :test #'eq)
+			 (format nil "{\\sf \\~(~A~)}" arg))
+			((listp arg) ; OK OK I am missing cons cells!
+			 (preprocess-specials arg purge-doc))
+			((characterp arg)
+			 (preprocess-character arg))
+			(t (purge-string-for-latex
+			    (format nil "~S" arg)
+			    purge-doc))))
+	      args)))
+
+(defun preprocess-character (c)
+  "Low level processing of single characters, when passed as defaults
+   to optional, key and aux parameters."
+  ;; The stupid LaTeX manual does not tell be how to produce a single
+  ;; '\' without being in math mode, so I have to trick it.
+  (case c
+    (#\newline "\\#$\\backslash${newline}")
+    (#\space "\\#$\\backslash${space}")
+    (#\rubout "\\#$\\backslash${rubout}")
+    (#\page "\\#$\\backslash${page}")
+    (#\backspace "\\#$\\backslash${backspace}")
+    (#\return "\\#$\\backslash${return}")
+    (#\linefeed "\\#$\\backslash${linefeed}")
+    (t c)))
+
+(defun preprocess-specials (list-form purge-doc)
+  "Processing of some 'special' forms. Only 'quote' and 'function' are
+   treated for the time being."
+  (case (first list-form)
+    (function
+     (format nil "\\#'~A"
+	     (purge-string-for-latex
+	      (format nil "~A" (second list-form))
+	      purge-doc)))
+    (quote
+     (format nil "'~A"
+	     (purge-string-for-latex
+	      (format nil "~A" (second list-form))
+	      purge-doc)))
+    (t (preprocess-lisp-latex-clashes list-form purge-doc))))
+
+#+:XP
+(defun xp-split-string (arglist width)
+  "PPrints the arglist into a string of specified width. Assumes
+   that we're running the XP pretty printer."
+  (let ((xp::*default-right-margin* width)
+	(xp::*print-miser-width* 30)
+	string)
+    (cond ((stringp arglist) (list arglist))
+	  (t
+	   (setq string
+		 (with-output-to-string (stream) (pprint arglist stream)))
+	   (setq string (format nil "~(~A~)" string))
+	   (setq string (remove-if #'(lambda (x) (string-equal x ""))
+				   (parse-with-delimiter string #\newline)))
+	   string))))
+
+(defun split-string (string width 
+			    &optional arglistp filled (trim-whitespace t))
+  "Splits a string into a list of strings, each of which is shorter
+   than the specified width. Tries to be intelligent about where to
+   split the string if it is an argument list. If filled is T,
+   tries to fill out the strings as much as possible. This function
+   is used to break up long argument lists nicely, and to break up
+   wide lines of documentation nicely."
+  (let ((string-list (parse-with-delimiter string #\newline))
+	(result nil))
+    (do* ((rest string-list (rest rest))
+	  (s (car rest) (car rest)))
+	((null rest)
+	 (nreverse result))
+      (multiple-value-bind (first second) (split-point s width arglistp filled)
+	(if trim-whitespace
+	    (setf first (string-trim '(#\space #\tab) first))
+	    (when (and (> (length first) 0)
+		       (char= (char first 0) #\space))
+	      (if (and (> (length first) 3)
+		       (char= (char first 1) #\space)
+		       (char= (char first 2) #\space)
+		       (not (char= (char first 3) #\space)))
+		  (setf first (string-trim '(#\space #\tab) first))
+		  (setf first (subseq first 1)))))
+	(when (not (string-equal first ""))
+	  (push first result))
+	(when (and second (not (string-equal second "")))
+	  (setf rest
+		(list* 
+		 nil
+		 (concatenate 'string
+			      (string-trim '(#\space #\tab) second)
+			      " "
+			      (and (cadr rest)
+				   (string-trim '(#\space #\tab)
+						(cadr rest)))) 
+		 (cddr rest))))))))
+
+;;; need some way for the last line from an arglist to possibly
+;;; be split, even if it has a perfect fit.
+(defun split-point (string max-length &optional arglistp filled)
+  "Finds an appropriate point to break the string at given a target length.
+   If arglistp is T, tries to find an intelligent position to break the
+   string. If filled is T, tries to fill out the string as much as possible."
+  ;; we probably should split some strings that are short enough anyway
+  ;; but need a base condition to prevent infinite loops.
+  (cond ((< (length string) max-length)
+	 (let ((lambda (lambda-list-keyword-position string (length string)
+						     t)))
+	   (if (and arglistp lambda (not (zerop lambda)))
+	       (values (subseq string 0 lambda)
+		       (unless (= lambda (length string))
+			 (subseq string lambda)))
+	     string)))
+	(t
+	 ;; Find the first space that breaks the arglist.
+	 ;; If parentheses are not balanced at this point,
+	 ;; go to the first balanced paren that isn't at position
+	 ;; zero (actually, the conditions are much more complex).
+	 ;; Then check if the previous "word" is a lambda-list keyword.
+	 ;; This gives it a preference for lambda-list keywords.
+	 (let* ((space-pos (position #\space string :from-end t 
+				    :end max-length))
+		(pos space-pos))
+	   (when arglistp
+	     (let* ((paren (balanced-parenthesis-position 
+			    string (or space-pos max-length)))
+		    (lambda (lambda-list-keyword-position 
+			     string (or paren max-length))))
+	       (cond ((and lambda paren space-pos arglistp
+			   (not (zerop lambda))
+			   (or (not filled)
+			       (< (- max-length 10) lambda max-length)))
+		      (setq pos lambda))
+		     ((and paren space-pos
+			   arglistp
+			   (not (zerop paren))
+			   (or (not filled)
+			       (< (- max-length 10) paren max-length)))
+		      (setq pos paren)))))
+	   (if pos
+	       (values (subseq string 0 pos)
+		       (unless (= pos (length string))
+			 (subseq string pos)))
+	     string)))))
+
+(defun lambda-list-keyword-position (string &optional end trailer-only)
+  "If the previous symbol is a lambda-list keyword, returns
+   its position. Otherwise returns end."
+  ;; possibly extend this to also search for colons for keywords? 
+  (when (null end) (setf end (length string)))
+  (let ((ampersand (position #\& string :from-end t :end end))
+	(rightmost-space (position #\space string :from-end t :end end)))
+    (if ampersand 
+	(cond ((find (string-trim '(#\space) (subseq string ampersand end))
+		   lambda-list-keywords 
+		   :key #'symbol-name
+		   :test #'string-equal)
+	       ampersand)
+	      ((and rightmost-space (not trailer-only)
+		    (< ampersand rightmost-space)
+		    (find (string-trim '(#\space)
+				       (subseq string
+					       ampersand rightmost-space))
+			  lambda-list-keywords 
+			  :key #'symbol-name
+			  :test #'string-equal))
+	       ampersand)
+	      (t
+	       end))
+      end)))
+
+(defun balanced-parenthesis-position (string &optional end)
+  "Finds the position of the left parenthesis which is closest to END
+   but leaves the prefix of the string with balanced parentheses or 
+   at most 1 unbalanced left parenthesis."
+  (when (null end) (setf end (length string)))
+  (let* ((num-left (count #\( string :end end))
+	 (num-right (count #\) string :end end))
+	 (imbalance (max 0 (- num-left num-right)))
+	 (leftmost-left-paren (position #\( string :end end))
+	 (leftmost-right-paren (position #\) string :end end))
+	 (rightmost-left-paren (position #\( string :end end :from-end t)))
+    (cond ((and leftmost-left-paren leftmost-right-paren
+		(< leftmost-right-paren leftmost-left-paren))
+	   ;; if we have ")(", break after the right paren.
+	   leftmost-left-paren)
+	  ((and leftmost-right-paren (not leftmost-left-paren))
+	   ;; we have a right paren but no left
+	   (1+ (position #\) string :from-end t :end end)))
+	  ((or (= imbalance 0)
+	       (and (or (char= (char string 0) #\()
+			(char= (char string 0) #\&))
+		    (cond (leftmost-right-paren
+			   ;; there's a right paren and the left
+			   ;; parens before it account for the imbalance
+			   ;; actually, we need to do a fancier balancing
+			   ;; operation here to absorb balanced left
+			   ;; parentheses. 
+			   (not (< (1- (count #\( string 
+					  :end leftmost-right-paren))
+			      imbalance)))
+			  ((find #\space string :end rightmost-left-paren)
+			   nil)
+			  (t))))
+	   ;; either we're balanced, or the imbalance is due to
+	   ;; left-parens at the left edge.
+	   end)
+	  (t
+	   ;; let's try to reduce the imbalance
+	   (if (and rightmost-left-paren (not (zerop rightmost-left-paren)))
+	       (balanced-parenthesis-position string rightmost-left-paren)
+	     end)))))
+
+;;; This was a preliminary BUILD-SYMBOL.
+;;; I've given a more complex implementation of this to Mark
+;;; to include in EXTENSIONS or something like that. - fdmm
+(defun um-build-symbol (symbol &key (prefix nil prefix-p)
+				 (suffix nil suffix-p)
+				 (package nil package-p))
+  "Build a symbol concatenating prefix (if not null), symbol, and suffix (if not null).
+   The newly generated symbol is interned in package, if not null, or in the SYMBOL-PACKAGE of symbol, otherwise."
+  (let ((newname (symbol-name symbol)))
+    (when prefix-p
+      (setf newname (concatenate 'string (symbol-name prefix) newname)))
+    (when suffix-p
+      (setf newname (concatenate 'string newname (symbol-name suffix))))
+    (if package-p
+	(intern newname package)
+      (intern newname (symbol-package symbol)))))
+
+(defun create-manuals (files &key (prefix nil)
+				  (extension '.cl)
+				  (output-format 'text)
+				  (purge-latex t)
+				  (purge-latex-in-doc-strings t))
+  (format t "~%;;;~%;;; User manuals will be created in directory ~A~%;;;" (string-downcase prefix))
+  (loop for file in files do
+	(WITH-OPEN-FILE 
+	    (STREAM (string-downcase 
+		     (symbol-name 
+		      (um-build-symbol file 
+				       :prefix prefix
+				       :suffix (case output-format
+						 ((text :text) '.txt)
+					;What would be a `standard' extension for SCRIBE?
+						 ((scribe :scribe) '.scb) 
+						 ((frame :frame) '.fm)
+						 ((latex :latex) '.tex)))))
+		    :DIRECTION :OUTPUT 
+		    :if-does-not-exist :create
+		    :IF-EXISTS :new-version)
+	  (CREATE-USER-MANUAL (string-downcase (symbol-name 
+						(um-build-symbol file
+								 :suffix extension)))
+			       :OUTPUT-STREAM STREAM
+			       :output-format output-format
+			       :purge-latex purge-latex
+			       :purge-latex-in-doc-strings purge-latex-in-doc-strings)))
+  (format t "~%;;;~%;;; END OF MANUAL PROCESSING.~%;;;"))
+
+(defun parse-with-delimiter (line &optional (delim #\newline))
+  "Breaks LINE into a list of strings, using DELIM as a 
+   breaking point."
+  ;; what about #\return instead of #\newline?
+  (let ((pos (position delim line)))
+    (cond (pos
+           (cons (subseq line 0 pos)
+                 (parse-with-delimiter (subseq line (1+ pos)) delim)))
+          (t
+           (list line)))))
+
+;;; ********************************
+;;; Dead Code **********************
+;;; ********************************
+
+#|
+;(split-string "the quick brown fox jumped over the lazy dogs" 20)
+
+(split-string "(((&OPTIONAL (NODE (QUOTE NODE)) (QUEUE (QUOTE QUEUE))
+   (CHILDREN (QUOTE CHILDREN)) VISITED)
+  INITIAL-QUEUE CHILDREN-FORM &OPTIONAL
+  (DEQUEUE-FORM (QUOTE (POP QUEUE)))
+  (MERGE-FORM (QUOTE (SETQ QUEUE (APPEND QUEUE PROGENY))))
+  RESULT-FORM)
+ &BODY BODY)" 30 t)
+
+;(BALANCED-PARENTHESIS-POSITION "foo the (bar baz) (biz" )
+
+|#
+
Index: /trunk/doc/cgb-lisp.txt
===================================================================
--- /trunk/doc/cgb-lisp.txt	(revision 8)
+++ /trunk/doc/cgb-lisp.txt	(revision 8)
@@ -0,0 +1,63 @@
+
+;;; *EXAMPLES* ('((string-grobner                                    [VARIABLE]
+;;;             (string-grobner "[x^2+y,x-y]" '(x y))
+;;;             (string-grobner "[y-x^2,z-x^3]" '(x y z) :order
+;;;             #'grevlex>))
+;;;             (string-grobner-system
+;;;             (string-grobner-system "[u*x+y,x+y]" '(x y) '(u))
+;;;             (string-grobner-system "[u*x+y,x+y]" '(x y) '(u)
+;;;             :cover '(("[u-1]" "[]")))) (string-read-poly
+;;;             (string-read-poly "[x^3+3*x^2+3*x+1]" '(x)))
+;;;             (string-elimination-ideal
+;;;             (string-elimination-ideal "[x^2+y^2-2,x*y-1]" '(x y)
+;;;             1))
+;;;             (string-ideal-saturation-1
+;;;             (string-ideal-saturation-1 "[x^2*y,y^3]" "x" '
+;;;             (x y))) (string-ideal-polysaturation-1
+;;;             (string-ideal-polysaturation-1 "[x^2*y,y^3]" "[x,y]"
+;;;             '(x y))) (string-cond (string-cond '
+;;;             ("[u^2-v]" "[v-1]") '(u v) #'grevlex>))
+;;;             (string-cover (string-cover '(("[u^2-v]" "[u]")
+;;;             ("[u+v]" "[]")) '(u v) #'grevlex>))
+;;;             (string-determine
+;;;             (string-determine "[u*x+y,v*x^2+y^2]" '(x y) '(u v)
+;;;             :cond '("[u,v]" "[v-1]") :main-order #'lex>))
+;;;             (parse-string-to-sorted-alist
+;;;             (parse-string-to-sorted-alist "x^2+y^3" '(x y)
+;;;             #'grevlex>)
+;;;             (parse-string-to-sorted-alist "[x^2+y^3,x-y]" '(x y)
+;;;             #'grevlex>))
+;;;             (translate-statements
+;;;             (translate-statements (collinear a b c)
+;;;             (perpendicular a b a c))) (translate-theorem
+;;;             (translate-theorem ((perpendicular a b c d)
+;;;             (perpendicular c d e f)) ((parallel a b e f)
+;;;             (identical-points c d))) (translate-theorem
+;;;             ((perpendicular a b a c) (midpoint b c m)
+;;;             (midpoint a m o) (collinear b h c)
+;;;             (perpendicular a h b c)) ((equidistant m o h o)
+;;;             (identical-points b c)))) (prove-theorem
+;;;             (prove-theorem ((perpendicular a b c d)
+;;;             (perpendicular c d e f)) ((parallel a b e f)
+;;;             (identical-points c d))) (prove-theorem
+;;;             ((perpendicular a b a c) (midpoint b c m)
+;;;             (midpoint a m o) (collinear b h c)
+;;;             (perpendicular a h b c)) ((equidistant m o h o)
+;;;             (identical-points b c))) (prove-theorem
+;;;             ((perpendicular a b a c) (identical-points b c))
+;;;             ((identical-points a b) (identical-points a c)))
+;;;             (prove-theorem ((perpendicular a b a c)
+;;;             (identical-points b c)) ((identical-points a b)
+;;;             (real-identical-points a c))))))
+;;;    A list of available examples.
+;;;
+;;; EXAMPLE (symbol &optional (stream t))                            [FUNCTION]
+;;;    Run short examples associated with a symbol, which typically is a
+;;;    function name. 
+;;;
+;;; RUN-EXAMPLE (e stream)                                           [FUNCTION]
+;;;    Evaluate a single form E and send output to stream STREAM.
+;;;
+;;; ALL-EXAMPLES (&optional (stream t))                              [FUNCTION]
+;;;    Run all available examples and send output to STREAM.
+;;;
Index: /trunk/doc/coefficient-ring.txt
===================================================================
--- /trunk/doc/coefficient-ring.txt	(revision 8)
+++ /trunk/doc/coefficient-ring.txt	(revision 8)
@@ -0,0 +1,49 @@
+
+;;; RING (+ - * / gcd lcm zerop unit length signum numerator        [STRUCTURE]
+;;;       denominator)
+;;;    The structure whose slots are bound to functions
+;;;    performing usual ring operations. In addition to usual arithmetical
+;;;    operations, bindings for other common operations
+;;;    which increase efficiency of Grobner basis calculations are also
+;;;    included. They are as follows:
+;;;    	GCD	- greatest common divisor;
+;;;    	LCM	- least common multiple;
+;;;    	ZEROP	- test whether an element is zero;
+;;;    	SIGNUM  - the sign of a ring element (+1, -1 or zero);
+;;;    	UNIT	- the unit of the ring;
+;;;    	NUMERATOR - the numerator, if a ring of fractions
+;;;    	DENOMINATOR - the denominator, if a ring of fractions
+;;;    	LENGTH  - an integer giving the approximate length
+;;;    		of the representation; for example, for integers
+;;;    		its default binding is #'integer-length;
+;;;
+;;; *RING-OF-INTEGERS* ((make-ring :+ #'+ :- #'- :* #'* :/ #'floor   [VARIABLE]
+;;;                     :gcd #'gcd :lcm #'lcm :zerop #'zerop :signum
+;;;                     #'signum :unit 1 :length #'integer-length
+;;;                     :numerator #'numerator :denominator
+;;;                     #'denominator))
+;;;    Operations in the ring of integers.
+;;;
+;;; *FIELD-OF-RATIONALS* ((make-ring :+ #'+ :- #'- :* #'* :/ #'/     [VARIABLE]
+;;;                       :gcd #'
+;;;                       (lambda (&rest r) (declare (ignore r)) 1)
+;;;                       :lcm #'(lambda (&rest r) (apply #'* r))
+;;;                       :zerop #'zerop :signum #'signum :unit 1
+;;;                       :length #'
+;;;                       (lambda (x)
+;;;                       (+ (integer-length (numerator x))
+;;;                       (integer-length (denominator x))))
+;;;                       :numerator #'numerator :denominator
+;;;                       #'denominator))
+;;;    Operations on the field of rational numbers.
+;;;
+;;; FIELD-MODULO-PRIME (modulus)                                     [FUNCTION]
+;;;    Return a RING structure with operations bound
+;;;    to the arithmetical operations modulo MODULUS, which
+;;;    should be a prime.
+;;;
+;;; *COEFFICIENT-RING* (*ring-of-integers*)                          [VARIABLE]
+;;;    The default RING structure, used in most operations
+;;;    on the coefficients of polynomials. It should be carefully
+;;;    set if rings other than the default ring is used.
+;;;
Index: /trunk/doc/colored-poly.txt
===================================================================
--- /trunk/doc/colored-poly.txt	(revision 8)
+++ /trunk/doc/colored-poly.txt	(revision 8)
@@ -0,0 +1,349 @@
+
+;;; *COLORED-POLY-DEBUG* (nil)                                       [VARIABLE]
+;;;    If true debugging output is on.
+;;;
+;;; DEBUG-CGB (&rest args)                                              [MACRO]
+;;;
+;;; MAKE-COLORED-POLY (poly k &key (key #'identity)                  [FUNCTION]
+;;;                    (main-order #'lex>) (parameter-order #'lex>)
+;;;                    &aux l)
+;;;    Colored poly is represented as a list
+;;;    	(TERM1 TERM2 ... TERMS)
+;;;    where each term is a triple
+;;;    	(MONOM . (POLY . COLOR))
+;;;    where monoms and polys have common number of variables while color is
+;;;    one of the three: :RED, :GREEN or :WHITE.  This function translates
+;;;    an ordinary polynomial into a colored one by dividing variables into
+;;;    K and N-K, where N is the total number of variables in the polynomial
+;;;    poly; the function KEY can be called to select variables in arbitrary
+;;;    order.
+;;;
+;;; MAKE-COLORED-POLY-LIST (plist &rest rest)                        [FUNCTION]
+;;;    Translate a list of polynomials PLIST into a list of colored
+;;;    polynomials by calling MAKE-COLORED-POLY. Returns the resulting list.
+;;;
+;;; COLOR-POLY-LIST (flist &optional (cond (list nil nil)))          [FUNCTION]
+;;;    Add colors to an ordinary list of polynomials FLIST, according to a
+;;;    condition COND. A condition is a pair of polynomial lists.  Each
+;;;    polynomial in COND is a polynomial in parameters only.  The list
+;;;    (FIRST COND) is called the ``green list'' and it consists of
+;;;    polynomials which vanish for the parameters associated with the
+;;;    condition. The list (SECOND COND) is called the ``red list
+;;;
+;;; COLOR-POLY (f &optional (cond (list nil nil)))                   [FUNCTION]
+;;;    Add color to a single polynomial F, according to condition COND.
+;;;    See the documentation of COLOR-POLY-LIST.
+;;;
+;;; COLORED-POLY-TO-POLY (cpoly)                                     [FUNCTION]
+;;;    For a given colored polynomial CPOLY, removes the colors and
+;;;    it returns the polynomial as an ordinary polynomial with
+;;;    coefficients which are polynomials in parameters.
+;;;
+;;; COLORED-POLY-PRINT (poly vars &key (stream t) (beg t)            [FUNCTION]
+;;;                     (print-green-part nil)
+;;;                     (mark-coefficients nil))
+;;;    Print a colored polynomial POLY. Use variables VARS to represent
+;;;    the variables. Some of the variables are going to be used as
+;;;    parameters, according to the length of the monomials in the main
+;;;    monomial and coefficient part of each term in POLY. The key variable
+;;;    STREAM may be used to redirect the output. If parameter
+;;;    PRINT-GREEN-PART is set then the coefficients which have color :GREEN
+;;;    will be printed, otherwise they are discarded silently. If
+;;;    MARK-COEFFICIENTS is not NIL then every coefficient will be marked
+;;;    according to its color, for instance G(U-1) would mean that U-1 is
+;;;    in the green list. Returns P.
+;;;
+;;; COLORED-POLY-PRINT-LIST (poly-list vars &key (stream t) (beg t)  [FUNCTION]
+;;;                          (print-green-part nil)
+;;;                          (mark-coefficients nil))
+;;;    Pring a list of colored polynomials via a call to
+;;;    COLORED-POLY-PRINT.
+;;;
+;;; DETERMINE (f &optional (cond (list nil nil)) (order #'lex>)      [FUNCTION]
+;;;            (ring *coefficient-ring*))
+;;;    This function takes a list of colored polynomials F and a condition
+;;;    COND, and it returns a list of pairs (COND' F') such that COND' cover
+;;;    COND and F' is a ``determined'' version of the colored polynomial
+;;;    list F, i.e. every polynomial has its leading coefficient determined.
+;;;    This means that some of the initial coefficients in each polynomial
+;;;    in F' are in the green list of COND, and the first non-green
+;;;    coefficient is in the red list of COND. We note that F' differs from
+;;;    F only by different colors: some of the terms marked :WHITE are now
+;;;    marked either :GREEN or :RED. Coloring is done either by explicitly
+;;;    checking membership in red or green list of COND, or implicitly by
+;;;    performing Grobner basis calculations in the polynomial ring over the
+;;;    parameters. The admissible monomial order ORDER is used only in the
+;;;    parameter space. Also, the ring structure RING is used only for
+;;;    calculations on polynomials of the parameters only.
+;;;
+;;; DETERMINE-1 (cond p end gp order ring)                           [FUNCTION]
+;;;    Determine a single colored polynomial  P according to condition COND.
+;;;    Prepend green part GP to P. Cons the result with END, which should be
+;;;    a list of colored polynomials, and return the resulting list of
+;;;    polynomials. This is an auxillary function of DETERMINE.
+;;;
+;;; DETERMINE-WHITE-TERM (cond term restp end gp order ring)         [FUNCTION]
+;;;    This is an auxillary function of DETERMINE.  In this function the
+;;;    parameter COND is a condition.  The parameters TERM, RESTP and GP are
+;;;    three parts of a polynomial being processed, where TERM is colored
+;;;    :WHITE. We test the membership in the red and green list of COND we
+;;;    try to determine whether the term is :RED or :GREEN. This is done by
+;;;    performing ideal membership tests in the polynomial ring. Let C be
+;;;    the coefficient of TERM.  Thus, C is a polynomial in parameters. We
+;;;    find whether C is in the green list by performing a plain ideal
+;;;    membership test. However, to test properly whether C is in the red
+;;;    list, one needs a different strategy.  In fact, we test whether
+;;;    adding C to the red list would produce a non-empty set of parameters
+;;;    in some algebraic extension. The test is whether 1 belongs to the
+;;;    saturation ideal of (FIRST COND) in (CONS C (SECOND COND)). Thus, we
+;;;    use POLY-SATURATION. If we are successful in determining the color of
+;;;    TERM, we simply change the color of the term and return the list
+;;;    ((COND P)) where P is obtained by appending GP, (LIST TERM) and
+;;;    RESTP. If we cannot determine whether TERM is :RED or :GREEN, we
+;;;    return the list ((COND' P') (COND'' P
+;;;
+;;; COND-SYSTEM-PRINT (system vars params &key (suppress-value t)    [FUNCTION]
+;;;                    (print-green-part nil)
+;;;                    (mark-coefficients nil) &aux (label 0))
+;;;    A conditional system SYSTEM is a list of pairs (COND PLIST), where
+;;;    COND is a condition (a pair (GREEN-LIST RED-LIST)) and PLIST is a
+;;;    list of colored polynomials. This function pretty-prints this list of
+;;;    pairs. A conditional system is the data structure returned by 
+;;;    GROBNER-SYSTEM. This function returns SYSTEM, if SUPPRESS-VALUE is
+;;;    non-NIL and no value otherwise. If MARK-COEFFICIENTS is non-NIL
+;;;    coefficients will be marked as in G(u-1)*x+R(2)*y, which means that
+;;;    u-1 is :GREEN and 2 is :RED. 
+;;;
+;;; COND-PRINT (cond params)                                         [FUNCTION]
+;;;    Pretty-print a condition COND, using symbol list PARAMS as parameter
+;;;    names. 
+;;;
+;;; ADD-PAIRS (gs pred)                                              [FUNCTION]
+;;;    The parameter GS shoud be a Grobner system, i.e. a set of pairs
+;;;    (CONDITION POLY-LIST) This functions adds the third component: the
+;;;    list of initial critical pairs (I J), as in the ordinary Grobner
+;;;    basis algorithm. In addition, it adds the length of of the POLY-LIST,
+;;;    less 1, as the fourth component. The resulting list of quadruples is
+;;;    returned.
+;;;
+;;; COND-PART (p)                                                    [FUNCTION]
+;;;    Find the part of a colored polynomial P starting with the first
+;;;     non-green term.
+;;;
+;;; COND-HM (p)                                                      [FUNCTION]
+;;;    Return the conditional head monomial of a colored polynomial P.
+;;;
+;;; DELETE-GREEN-POLYS (gamma)                                       [FUNCTION]
+;;;    Delete totally green polynomials from in a grobner system GAMMA.
+;;;
+;;; GROBNER-SYSTEM (f &key (cover (list '(nil nil))) (main-order     [FUNCTION]
+;;;                 #'lex>)
+;;;                 (parameter-order #'lex>) (reduce t)
+;;;                 (green-reduce t) (top-reduction-only nil)
+;;;                 (ring *coefficient-ring*)
+;;;                 &aux
+;;;                 (cover
+;;;                 (saturate-cover cover parameter-order ring))
+;;;                 (gamma
+;;;                 (delete-green-polys (mapcan #'(lambda (cond)
+;;;                 (determine f cond parameter-order ring))
+;;;                 cover))))
+;;;    This function returns a grobner system, given a list of colored
+;;;    polynomials F, Other parameters are:
+;;;    A cover COVER, i.e. a list of conditions, i.e. pairs of the form
+;;;    (GREEN-LIST RED-LIST), where GREEN-LIST and RED-LIST are to lists of
+;;;    ordinary polynomials in parameters. A monomial order MAIN-ORDER used
+;;;    on main variables (not parameters). A monomial order PARAMETER-ORDER
+;;;    used in calculations with parameters only. REDUCE, a flag deciding
+;;;    whether COLORED-REDUCTION will be performed on the resulting grobner
+;;;    system. GREEN-REDUCE, a flag deciding whether the green list of each
+;;;    condition will be reduced in a form of a reduced Grobner basis.
+;;;    TOP-REDUCTION-ONLY, a flag deciding whether in the internal
+;;;    calculations in the space of parameters top reduction only will be
+;;;    used. RING, a structure as in the package COEFFICIENT-RING, used in
+;;;    operations on the coefficients of the polynomials in parameters.
+;;;
+;;; REORDER-PAIRS (b bnew g pred &optional (sort-first nil))         [FUNCTION]
+;;;    Reorder pairs according to some heuristic. The heuristic at this time
+;;;    is ad hoc, in the future it should be replaced with sugar strategy
+;;;    and a mechanism for implementing new heuristic strategies, as in the
+;;;    GROBNER package. 
+;;;
+;;; COLORED-CRITERION-1 (i j f)                                      [FUNCTION]
+;;;    Buchberger criterion 1 for colored polynomials.
+;;;
+;;; COLORED-CRITERION-2 (i j f b s)                                  [FUNCTION]
+;;;    Buchberger criterion 2 for colored polynomials.
+;;;
+;;; COND-NORMAL-FORM (f fl main-order parameter-order                [FUNCTION]
+;;;                   top-reduction-only ring)
+;;;    Returns the conditional normal form of a colored polynomial F with
+;;;    respect to the list of colored polynomials FL. The list FL is assumed
+;;;    to consist of determined polynomials, i.e. such that the first term
+;;;    which is not marked :GREEN is :RED.
+;;;
+;;; COND-SPOLY (f g main-order parameter-order ring)                 [FUNCTION]
+;;;    Returns the conditional S-polynomial of two colored polynomials F and
+;;;    G. Both polynomials are assumed to be determined.
+;;;
+;;; COND-LM (f)                                                      [FUNCTION]
+;;;    Returns the conditional leading monomial of a colored polynomial F,
+;;;    which is assumed to be determined.
+;;;
+;;; COND-LC (f)                                                      [FUNCTION]
+;;;    Returns the conditional leading coefficient of a colored polynomial
+;;;    F, which is assumed to be determined.
+;;;
+;;; COLORED-TERM-TIMES-POLY (term f order ring)                      [FUNCTION]
+;;;    Returns the product of a colored term TERM and a colored polynomial
+;;;    F. 
+;;;
+;;; COLORED-SCALAR-TIMES-POLY (c f ring)                             [FUNCTION]
+;;;    Returns the product of an element of the coefficient ring C a colored
+;;;    polynomial F. 
+;;;
+;;; COLORED-TERM* (term1 term2 order ring)                           [FUNCTION]
+;;;    Returns the product of two colored terms TERM1 and TERM2.
+;;;
+;;; COLOR* (c1 c2)                                                   [FUNCTION]
+;;;    Returns a product of two colores. Rules:
+;;;    :red * :red yields :red
+;;;    any * :green yields :green
+;;;    otherwise the result is :white.
+;;;
+;;; COLOR+ (c1 c2)                                                   [FUNCTION]
+;;;    Returns a sum of colors. Rules:
+;;;    :green + :green yields :green,
+;;;    :red + :green yields :red
+;;;    any other result is :white.
+;;;
+;;; COLOR- (c1 c2)                                                   [FUNCTION]
+;;;    Identical to COLOR+.
+;;;
+;;; COLORED-POLY+ (p q main-order parameter-order ring)              [FUNCTION]
+;;;    Returns the sum of colored polynomials P and Q.
+;;;
+;;; COLORED-POLY- (p q main-order parameter-order ring)              [FUNCTION]
+;;;    Returns the difference of colored polynomials P and Q.
+;;;
+;;; COLORED-TERM-UMINUS (term ring)                                  [FUNCTION]
+;;;    Returns the negation of a colored term TERM.
+;;;
+;;; COLORED-MINUS-POLY (p ring)                                      [FUNCTION]
+;;;    Returns the negation of a colored polynomial P.
+;;;
+;;; STRING-GROBNER-SYSTEM (f vars params                             [FUNCTION]
+;;;                        &key (cover (list (list "[]" "[]")))
+;;;                        (main-order #'lex>)
+;;;                        (parameter-order #'lex>)
+;;;                        (ring *coefficient-ring*)
+;;;                        (suppress-value t)
+;;;                        (suppress-printing nil)
+;;;                        (mark-coefficients nil) (reduce t)
+;;;                        (green-reduce t)
+;;;                        &aux
+;;;                        (f
+;;;                        (parse-to-colored-poly-list f vars params
+;;;                        main-order parameter-order))
+;;;                        (cover
+;;;                        (string-cover cover params
+;;;                        parameter-order)))
+;;;    An interface to GROBNER-SYSTEM in which polynomials can be specified
+;;;    in infix notations as strings. Lists of polynomials are
+;;;    comma-separated list marked by a matchfix operators [] 
+;;;
+;;; STRING-COND (cond params &optional (order #'lex>))               [FUNCTION]
+;;;    Return the internal representation of a condition COND, specified
+;;;    as pairs of strings (GREEN-LIST RED-LIST). GREEN-LIST and RED-LIST in
+;;;    the input are assumed to be strings which parse to two lists of
+;;;    polynomials with respect to variables whose names are in the list of
+;;;    symbols PARAMS. ORDER is the predicate used to sort the terms of
+;;;    the polynomials.
+;;;
+;;; STRING-COVER (cover params &optional (order #'lex>))             [FUNCTION]
+;;;    Returns the internal representation of COVER, given in the form of
+;;;    a list of conditions. See STRING-COND for description of a condition.
+;;;
+;;; SATURATE-COVER (cover order ring)                                [FUNCTION]
+;;;    Brings every condition of a list of conditions COVER to the form (G
+;;;    R) where G is saturated with respect to R and G is a Grobner basis
+;;;    We could reduce R so that the elements of R are relatively prime,
+;;;    but this is not currently done.
+;;;
+;;; SATURATE-COND (cond order ring)                                  [FUNCTION]
+;;;    Saturate a single condition COND. An auxillary function of
+;;;    SATURATE-COVER. 
+;;;
+;;; STRING-DETERMINE (f vars params &key (cond (quote ("[]" "[]")))  [FUNCTION]
+;;;                   (main-order #'lex>) (parameter-order #'lex>)
+;;;                   (suppress-value t) (suppress-printing nil)
+;;;                   (mark-coefficients nil)
+;;;                   (ring *coefficient-ring*)
+;;;                   &aux
+;;;                   (f
+;;;                   (parse-to-colored-poly-list f vars params
+;;;                   main-order parameter-order))
+;;;                   (cond
+;;;                   (string-cond cond params parameter-order)))
+;;;    A string interface to DETERMINE. See the documentation of
+;;;    STRING-GROBNER-SYSTEM. 
+;;;
+;;; TIDY-GROBNER-SYSTEM (gs main-order parameter-order reduce        [FUNCTION]
+;;;                      green-reduce ring)
+;;;    Apply TIDY-PAIR to every pair of a Grobner system.
+;;;
+;;; TIDY-PAIR (pair main-order parameter-order reduce green-reduce   [FUNCTION]
+;;;            ring &aux gs)
+;;;    Make the output of Grobner system more readable by performing
+;;;    certain simplifications on an element of a Grobner system.
+;;;    If REDUCE is non-NIL then COLORED-reduction will be performed.
+;;;    In addition TIDY-COND is called on the condition part of the pair
+;;;    PAIR. 
+;;;
+;;; TIDY-COND (cond order ring)                                      [FUNCTION]
+;;;    Currently saturates condition COND and does RED-REDUCTION on the red
+;;;    list. 
+;;;
+;;; COLORED-REDUCTION (cond p main-order parameter-order ring        [FUNCTION]
+;;;                    &aux (open (list (list cond nil p))) closed)
+;;;    Reduce a list of colored polynomials P.  The difficulty as compared
+;;;    to the usual Buchberger algorithm is that the polys may have the same
+;;;    leading monomial which may result in cancellations and polynomials
+;;;    which may not be determined. Thus, when we find those, we will have
+;;;    to split the condition by calling determine. Returns a list of pairs
+;;;    (COND' P') where P' is a reduced grobner basis with respect to any
+;;;    parameter choice compatible with condition COND'. Moreover, COND'
+;;;    form a cover of COND.
+;;;
+;;; GREEN-REDUCE-COLORED-POLY (cond f parameter-order ring)          [FUNCTION]
+;;;    It takes a colored polynomial F and it returns a modified
+;;;    polynomial obtained by reducing coefficient of F modulo green list of
+;;;    the condition COND.
+;;;
+;;; GREEN-REDUCE-COLORED-LIST (cond fl parameter-order ring)         [FUNCTION]
+;;;    Apply GREEN-REDUCE-COLORED-POLY to a list of polynomials FL.
+;;;
+;;; COND-SYSTEM-GREEN-REDUCE (gs parameter-order ring)               [FUNCTION]
+;;;    Apply GREEN-REDUCE-COLORED-LIST to every pair of
+;;;    a grobner system GS.
+;;;
+;;; PARSE-TO-COLORED-POLY-LIST (f vars params main-order             [FUNCTION]
+;;;                             parameter-order
+;;;                             &aux (k (length vars)) (vars-params
+;;;                             (append vars params)))
+;;;    Parse a list of polynomials F, given as a string, with respect to
+;;;    a list of variables VARS, given as a list of symbols, to the internal
+;;;    representation of a colored polynomial. The polynomials will be
+;;;    properly sorted by MAIN-ORDER, with the coefficients, which are
+;;;    polynomials in parameters, sorted by PARAMETER-ORDER. Both orders
+;;;    must be admissible monomial orders. This form is suitable for parsing
+;;;    polynomials with integer coefficients.
+;;;
+;;; RED-REDUCTION (p pred ring                                       [FUNCTION]
+;;;                &aux (p (remove-if #'poly-constant-p p)))
+;;;    Takes a family of polynomials and produce a list whose prime factors 
+;;;    are the same but they are relatively prime
+;;;    Repetitively used the following procedure: it finds two elements f, g
+;;;    of P which are not relatively prime; it replaces f and g with
+;;;    f/GCD(f,g), g/ GCD(f,f) and GCD(f,g).
+;;;
Index: /trunk/doc/division.txt
===================================================================
--- /trunk/doc/division.txt	(revision 8)
+++ /trunk/doc/division.txt	(revision 8)
@@ -0,0 +1,14 @@
+
+;;; DIVIDE (f fl &optional (pred #'lex>) (ring *coefficient-ring*)   [FUNCTION]
+;;;         &aux (s (length fl)))
+;;;    Divide polynomial F by a list of polynomials FL; use predicate PRED
+;;;    to sort monomials; assumes that the polynomials have initially been
+;;;    sorted according to PRED. It returnes multiple values. The first
+;;;    value is a list of quotients A.  The second value is the remainder R.
+;;;    These object satisfy the quation F = SUM A[J]*FL[I] + R.
+;;;
+;;; POLY-EXACT-DIVIDE (f g &optional (order #'lex>)                  [FUNCTION]
+;;;                    (ring *coefficient-ring*))
+;;;    Divide a polynomial F by another polynomial G. Assume that exact
+;;;    division with no remainder is possible. Returns the quotient.
+;;;
Index: /trunk/doc/dynamics.txt
===================================================================
--- /trunk/doc/dynamics.txt	(revision 8)
+++ /trunk/doc/dynamics.txt	(revision 8)
@@ -0,0 +1,149 @@
+
+;;; POLY-SCALAR-COMPOSITION (f g &optional (order #'lex>))           [FUNCTION]
+;;;    Returns a polynomial obtained by substituting a list of polynomials
+;;;    G=(G1,G2,...,GN) into a polynomial F(X1,X2,...,XN). All polynomials
+;;;    are assumed to be in the internal form, so variables do not
+;;;    explicitly apprear in the calculation. 
+;;;
+;;; POLY-COMPOSITION (f g &optional (order #'lex>))                  [FUNCTION]
+;;;    Return the composition of a polynomial map F with a polynomial map
+;;;    G. Both maps are represented as lists of polynomials, and each
+;;;    polynomial is in the internal alist representation. The restriction
+;;;    is that the length of the list G must be the number of variables in
+;;;    the list F. 
+;;;
+;;; POLY-DYNAMIC-POWER (f n &optional (order #'lex>))                [FUNCTION]
+;;;    Calculate the composition FoFo...oF (n times), where
+;;;    F is a polynomial map represented as a list of polynomials.
+;;;
+;;; POLY-SCALAR-EVALUATE (f x &optional (order #'lex>))              [FUNCTION]
+;;;    Evaluate a polynomial F at a point X. This operation is implemented
+;;;    through POLY-SCALAR-COMPOSITION.
+;;;
+;;; POLY-EVALUATE (f x &optional (order #'lex>))                     [FUNCTION]
+;;;    Evaluate a polynomial map F, represented as list of polynomials, at a
+;;;    point X. 
+;;;
+;;; FACTORIAL (n &optional (k n) &aux (result 1))                    [FUNCTION]
+;;;    Return N!/(N-K)!=N(N-1)(N-K+1).
+;;;
+;;; POLY-SCALAR-DIFF (f m)                                           [FUNCTION]
+;;;    Return the partial derivative of a polynomial F over multiple
+;;;     variables according to multiindex M.
+;;;
+;;; POLY-DIFF (f m)                                                  [FUNCTION]
+;;;    Return the partial derivative of a polynomial map F, represented as a
+;;;    list of polynomials, with respect to several variables, according to
+;;;    multi-index M. 
+;;;
+;;; STANDARD-VECTOR (n k &optional (coeff 1)                         [FUNCTION]
+;;;                  &aux (v (make-list n :initial-element 0)))
+;;;    Returns vector (0 0 ... 1 ... 0 0) of length N, where 1 appears on
+;;;    K-th place. 
+;;;
+;;; SCALAR-PARTIAL (f k &optional (l 1))                             [FUNCTION]
+;;;    Returns the L-th partial derivative of a polynomial F over the K-th
+;;;    variable. 
+;;;
+;;; PARTIAL (f k &optional (l 1))                                    [FUNCTION]
+;;;    Returns the L-th partial derivative over the K-th variable, of a
+;;;    polynomial map F, represented as a list of polynomials.
+;;;
+;;; DETERMINANT (f &optional (order #'lex>) &aux (result nil))       [FUNCTION]
+;;;    Returns the determinant of a polynomial matrix F, which is a list of
+;;;    rows of the matrix, each row is a list of polynomials.  The algorithm
+;;;    is recursive expansion along columns.
+;;;
+;;; MINOR (f i j &optional (order #'lex>))                           [FUNCTION]
+;;;    Calculate the minor of a polynomial matrix F with respect to entry
+;;;    (I,J). 
+;;;
+;;; DROP-ROW (f i)                                                   [FUNCTION]
+;;;    Discards the I-th row from a polynomial matrix F.
+;;;
+;;; DROP-COLUMN (f j)                                                [FUNCTION]
+;;;    Discards the J-th column from a polynomial matrix F.
+;;;
+;;; DROP-ELT (lst j)                                                 [FUNCTION]
+;;;    Discards the J-th element from a list LST.
+;;;
+;;; MATRIX- (f g &optional (order #'lex>))                           [FUNCTION]
+;;;    Returns difference of two polynomial matrices F and G.
+;;;
+;;; SCALAR-TIMES-MATRIX (s f)                                        [FUNCTION]
+;;;    Returns a product of a polynomial S by a polynomial matrix F.
+;;;
+;;; MONOM-TIMES-MATRIX (m f)                                         [FUNCTION]
+;;;    Returns a product of a monomial M by a polynomial matrix F.
+;;;
+;;; TERM-TIMES-MATRIX (term f)                                       [FUNCTION]
+;;;    Returns a product of a term TERM by a polynomial matrix F.
+;;;
+;;; POLY-LIST- (f g &optional (order #'lex>))                        [FUNCTION]
+;;;    Returns the list of differences of two lists of polynomials
+;;;    F and G (polynomial maps).
+;;;
+;;; SCALAR-TIMES-POLY-LIST (s f)                                     [FUNCTION]
+;;;    Returns the list of products of a polynomial S by the
+;;;    list of polynomials F.
+;;;
+;;; MONOM-TIMES-POLY-LIST (m f)                                      [FUNCTION]
+;;;    Returns the list of products of a monomial M by the
+;;;    list of polynomials F.
+;;;
+;;; TERM-TIMES-POLY-LIST (term f)                                    [FUNCTION]
+;;;    Returns the list of products of a term TERM by the
+;;;    list of polynomials F.
+;;;
+;;; CHARACTERISTIC-COMBINATION (a b &optional (order #'lex>)         [FUNCTION]
+;;;                             &aux (n (length b)))
+;;;    Returns A - U1 * B1 - U2 * B2 - ... - UM * BM where A is a polynomial
+;;;    and B=(B1,B2,...,BM) is a polynomial list, where U1, U2, ... , UM are
+;;;    new variables. These variables will be added to every polynomial
+;;;    A and BI as the last M variables.
+;;;
+;;; CHARACTERISTIC-COMBINATION-POLY-LIST (a b                        [FUNCTION]
+;;;                                       &optional (order #'lex>))
+;;;    Returns A - U1 * B1 - U2 * B2 - ... - UM * BM where A is a polynomial
+;;;    list and B=(B1, B2, ... , BM) is a list of polynomial lists, where
+;;;    U1, U2, ... ,UM are new variables. These variables will be added to
+;;;    every polynomial A and BI as the last M variables. Se also
+;;;    CHARACTERISTIC-COMBINATION. 
+;;;
+;;; CHARACTERISTIC-MATRIX (a &optional (order #'lex>)                [FUNCTION]
+;;;                        (b (list (identity-matrix (length a)
+;;;                        (length (caaaar a))))))
+;;;    Returns A - U1*B1 - U2*B2 - ... - UM * BM where A is a polynomial
+;;;    matrix and B=(B1,B2,...,BM) is a list of polynomial matrices, where
+;;;    U1, U2, .., UM are new variables. These variables will be added to
+;;;    every polynomial A and BI as the last M variables. Se also
+;;;    CHARACTERISTIC-COMBINATION. 
+;;;
+;;; CHARACTERISTIC-POLYNOMIAL (a &optional (order #'lex>)            [FUNCTION]
+;;;                            (b (list (identity-matrix (length a)
+;;;                            (length (caaaar a))))))
+;;;    Returns the generalized characteristic polynomial, i.e. the
+;;;    determinant DET(A - U1 * B1 - U2 * B2 - ... - UM * BM), where A and
+;;;    BI are square polynomial matrices in N variables. The resulting
+;;;    polynomial will have N+M variables, with U1, U2, ..., UM added as the
+;;;    last M variables. 
+;;;
+;;; IDENTITY-MATRIX (dim nvars)                                      [FUNCTION]
+;;;    Return the polynomial matrix which is the identity matrix. DIM is the
+;;;    requested dimension and NVARS is the number of variables of each
+;;;    entry. 
+;;;
+;;; PRINT-MATRIX (f vars)                                            [FUNCTION]
+;;;    Prints a polynomial matrix F, using a list of symbols VARS as
+;;;    variable names. 
+;;;
+;;; JACOBI-MATRIX (f &optional (m (length f)) (n                     [FUNCTION]
+;;;                (length (caaaar f))))
+;;;    Returns the Jacobi matrix of a polynomial list F over the first N
+;;;    variables. 
+;;;
+;;; JACOBIAN (f &optional (order #'lex>) (m (length f))              [FUNCTION]
+;;;           (n (length (caaaar f))))
+;;;    Returns the Jacobian (determinant) of a polynomial list F over the
+;;;    first N variables. 
+;;;
Index: /trunk/doc/grobner.txt
===================================================================
--- /trunk/doc/grobner.txt	(revision 8)
+++ /trunk/doc/grobner.txt	(revision 8)
@@ -0,0 +1,521 @@
+
+;;; *GROBNER-DEBUG* (nil)                                            [VARIABLE]
+;;;    If T, produce debugging and tracing output.
+;;;
+;;; *BUCHBERGER-MERGE-PAIRS* ('buchberger-merge-pairs-smallest-lcm)  [VARIABLE]
+;;;    A variable holding the predicate used to sort critical pairs
+;;;    in the order of decreasing priority for the Buchberger algorithm.
+;;;
+;;; *GEBAUER-MOELLER-MERGE-PAIRS* ('gebauer-moeller-merge-pairs-use-mock-spoly)  [VARIABLE]
+;;;    A variable holding the predicate used to sort critical pairs
+;;;    in the order of decreasing priority for the Gebauer-Moeller algorithm
+;;;
+;;; *GROBNER-FUNCTION* ('buchberger)                                 [VARIABLE]
+;;;    The name of the function used to calculate Grobner basis
+;;;
+;;; SELECT-GROBNER-ALGORITHM (algorithm)                             [FUNCTION]
+;;;    Select one of the several implementations of the Grobner basis
+;;;    algorithm.
+;;;
+;;; GROBNER (f &optional (pred #'lex>) (start 0)                     [FUNCTION]
+;;;          (top-reduction-only nil) (ring *coefficient-ring*))
+;;;    Return Grobner basis of an ideal generated by polynomial list F.
+;;;    Assume that the monomials of each polynomial are ordered according to
+;;;    the admissible monomial order PRED. The result will be a list of
+;;;    polynomials ordered as well according to PRED. The polynomials from 0
+;;;    to START-1 in the list F are assumed to be a Grobner basis, and thus
+;;;    certain critical pairs do not have to be calculated. If
+;;;    TOP-REDUCTION-ONLY is not NIL then only top reductions will be
+;;;    performed, instead of full division, and thus the returned Grobner
+;;;    basis will have its polynomials only top-reduced with respect to the
+;;;    preceding polynomials. RING should be set to the RING structure (see
+;;;    COEFFICIENT-RING package) corresponding to the coefficients of the
+;;;    polynomials in the list F. This function is currently just an
+;;;    interface to several algorithms which fine Grobner bases. Use
+;;;    SELECT-GROBNER-ALGORITHM in order to change the algorithm.
+;;;
+;;; DEBUG-CGB (&rest args)                                              [MACRO]
+;;;    This macro is used in printing debugging and tracing messages
+;;;    and its arguments are analogous to the FORMAT function, except
+;;;    that the stream argument is omitted. By default, the output is
+;;;    sent to *trace-output*, which can be set to produce output 
+;;;    in a file.
+;;;
+;;; SPOLY (f g pred ring)                                            [FUNCTION]
+;;;    Return the S-polynomial of F and G, which should
+;;;    be two polynomials with terms ordered by PRED and
+;;;    coefficients in a ring whose operations are the slots
+;;;    of the RING structure.
+;;;
+;;; GROBNER-PRIMITIVE-PART (p ring)                                  [FUNCTION]
+;;;    Divide polynomial P with integer coefficients by gcd of its
+;;;    coefficients and return the result. Use the RING structure from the
+;;;    COEFFICIENT-RING package to perform the operations on the
+;;;    coefficients.
+;;;
+;;; GROBNER-CONTENT (p ring)                                         [FUNCTION]
+;;;    Greatest common divisor of the coefficients of the polynomial P. Use
+;;;    the RING structure to compute the greatest common divisor.
+;;;
+;;; NORMAL-FORM (f fl pred top-reduction-only ring)                  [FUNCTION]
+;;;    Calculate the normal form of the polynomial F with respect to
+;;;    the polynomial list FL. Destructive to F; thus, copy-tree should be
+;;;    used where F needs to be preserved. It returns multiple values.
+;;;    The first value is the polynomial R which is reduced (or top-reduced
+;;;    if TOP-REDUCTION-ONLY is not NIL). The second value is an integer
+;;;    which is the number of reductions actually performed. The third value
+;;;    is the coefficient by which F needs to be multiplied in order to be
+;;;    able to perform the division without actually having to divide in the
+;;;    coefficient ring (a form of pseudo-division is used). All operations
+;;;    on the coefficients are performed using the RING structure from the
+;;;    COEFFICIENT-RING package.
+;;;
+;;; BUCHBERGER (f pred start top-reduction-only ring                 [FUNCTION]
+;;;             &aux (s (1- (length f))) b m)
+;;;    An implementation of the Buchberger algorithm. Return Grobner
+;;;    basis of the ideal generated by the polynomial list F.
+;;;    The terms of each polynomial are ordered by the admissible
+;;;    monomial order PRED. Polynomials 0 to START-1 are assumed to
+;;;    be a Grobner basis already, so that certain critical pairs
+;;;    will not be examined. If TOP-REDUCTION-ONLY set, top reduction
+;;;    will be preformed. The RING structure is used to perform operations
+;;;    on coefficents (see COEFFICIENT-RING package).
+;;;
+;;; GROBNER-OP (c1 c2 m a b pred ring &aux n a1 a2)                  [FUNCTION]
+;;;    Perform a calculation equivalent to
+;;;    (POLY- (SCALAR-TIMES-POLY C2 A)
+;;;    	 (SCALAR-TIMES-POLY C1 (MONOM-TIMES-POLY M B))
+;;;    	 PRED)
+;;;    but more efficiently; it destructively modifies A and stores the 
+;;;    result in it; A is returned.
+;;;
+;;; BUCHBERGER-SORT-PAIRS (b g pred ring)                            [FUNCTION]
+;;;    Sort critical pairs B by the function which is
+;;;    the value of the vairable *buchberger-merge-pairs*.
+;;;    G is the list of polynomials which the elemnts
+;;;    of B point into. PRED is the admissible monomial order.
+;;;    The RING structure holds operations on the coefficients
+;;;    as described in the COEFFICIENT-RING package.
+;;;
+;;; MOCK-SPOLY (f g pred)                                            [FUNCTION]
+;;;    Returns an upper-bound on the leading
+;;;    monomial of the S-polynomial of F and G, which are two polynomials
+;;;    sorted by the admissible monomial order PRED.
+;;;
+;;; BUCHBERGER-MERGE-PAIRS-USE-MOCK-SPOLY (b c g pred ring)          [FUNCTION]
+;;;    Merges lists of critical pairs B and C into one list. 
+;;;    The pairs are assumed to be ordered according to the
+;;;    increasing value of MOCK-SPOLY, as determined by the admissible
+;;;    monomial order PRED. G is the list of polynomials which the pairs
+;;;    of integers in B and C point into, and RING is the ring structure
+;;;    defined in the COEFFICIENT-RING package.
+;;;
+;;; BUCHBERGER-MERGE-PAIRS-SMALLEST-LCM (b c g pred ring)            [FUNCTION]
+;;;    Merges lists of critical pairs B and C into a single ordered
+;;;    list. Implements a strategy of ordering pairs according to the
+;;;    smallest lcm of the leading monomials of the two polynomials - so
+;;;    called normal strategy.
+;;;
+;;; BUCHBERGER-MERGE-PAIRS-USE-SMALLEST-DEGREE (b c g pred ring)     [FUNCTION]
+;;;    Mergest lists B and C of critical pairs. This strategy is based on
+;;;    ordering the pairs according to the smallest degree of the lcm of
+;;;    the leading monomials of the two polynomials.
+;;;
+;;; BUCHBERGER-MERGE-PAIRS-USE-SMALLEST-LENGTH (b c g pred ring)     [FUNCTION]
+;;;    Mergest lists B and C of critical pairs. This strategy is based on
+;;;    ordering the pairs according to the smallest total length of the 
+;;;    two polynomials, where length is the number of terms.
+;;;
+;;; BUCHBERGER-MERGE-PAIRS-USE-SMALLEST-COEFFICIENT-LENGTH (b c g    [FUNCTION]
+;;;                                                         pred
+;;;                                                         ring)
+;;;    Mergest lists B and C of critical pairs. This strategy is based on
+;;;    ordering the pairs according to the smallest combined length of the 
+;;;    coefficients of the two polynomials.
+;;;
+;;; BUCHBERGER-SET-PAIR-HEURISTIC (method                            [FUNCTION]
+;;;                                &aux (strategy-fn
+;;;                                (ecase method
+;;;                                (:minimal-mock-spoly
+;;;                                #'buchberger-merge-pairs-use-mock-spoly) (:minimal-lcm #'buchberger-merge-pairs-smallest-lcm) (:minimal-total-degree #'buchberger-merge-pairs-use-smallest-degree)
+;;;                                (:minimal-length
+;;;                                #'buchberger-merge-pairs-use-smallest-length) (:minimal-coefficient-length #'buchberger-merge-pairs-use-smallest-coefficient-length))))
+;;;    Simply sets the variable *buchberger-merge-pairs* to the heuristic
+;;;    function STRATEGY-FN implementing one of several strategies
+;;;    introduces before of selecting the most promising. METHOD should be
+;;;    one of the listed keywords.
+;;;
+;;; CRITERION-1 (pair g &aux (i (first pair)) (j (second pair)))     [FUNCTION]
+;;;    Returns T if the leading monomials of the two polynomials
+;;;    in G pointed to by the integers in PAIR have disjoint (relatively
+;;;    prime) monomials. This test is known as the first Buchberger
+;;;    criterion. 
+;;;
+;;; CRITERION-2 (pair g m &aux (i (first pair)) (j (second pair)))   [FUNCTION]
+;;;    Returns T if the leading monomial of some element P of G divides
+;;;    the LCM of the leading monomials of the two polynomials in the
+;;;    polynomial list G, pointed to by the two integers in PAIR, and P
+;;;    paired with each of the polynomials pointed to by the the PAIR has
+;;;    already been treated, as indicated by the hash table M, which stores
+;;;    value T for every treated pair so far.
+;;;
+;;; NORMALIZE-POLY (p ring)                                          [FUNCTION]
+;;;    Divide a polynomial by its leading coefficient. It assumes
+;;;    that the division is possible, which may not always be the
+;;;    case in rings which are not fields. The exact division operator
+;;;    is assumed to be provided by the RING structure of the
+;;;    COEFFICIENT-RING package.
+;;;
+;;; NORMALIZE-BASIS (plist ring)                                     [FUNCTION]
+;;;    Divide every polynomial in a list PLIST by its leading coefficient.
+;;;    Use RING structure to perform the division of the coefficients.
+;;;
+;;; REDUCTION (p pred ring)                                          [FUNCTION]
+;;;    Reduce a list of polynomials P, so that non of the terms in any of
+;;;    the polynomials is divisible by a leading monomial of another
+;;;    polynomial. Return the reduced list.
+;;;
+;;; REDUCED-GROBNER (f &optional (pred #'lex>) (start 0)             [FUNCTION]
+;;;                  (top-reduction-only nil)
+;;;                  (ring *coefficient-ring*))
+;;;    Return the reduced Grobner basis of the ideal generated by a
+;;;    polynomial list F. This combines calls to two functions: GROBNER and
+;;;    REDUCTION. The parameters have the same meaning as in GROBNER or
+;;;    BUCHBERGER. 
+;;;
+;;; MONOM-DEPENDS-P (m k)                                            [FUNCTION]
+;;;    Return T if the monomial M depends on variable number K.
+;;;
+;;; TERM-DEPENDS-P (term k)                                          [FUNCTION]
+;;;    Return T if the term TERM depends on variable number K.
+;;;
+;;; POLY-DEPENDS-P (p k)                                             [FUNCTION]
+;;;    Return T if the term polynomial P depends on variable number K.
+;;;
+;;; RING-INTERSECTION (plist k &key (key #'identity))                [FUNCTION]
+;;;    This function assumes that polynomial list PLIST is a Grobner basis
+;;;    and it calculates the intersection with the ring R[x[k+1],...,x[n]],
+;;;    i.e. it discards polynomials which depend on variables x[0], x[1],
+;;;    ..., x[k]. 
+;;;
+;;; ELIMINATION-IDEAL (flist k &key (primary-order #'lex>)           [FUNCTION]
+;;;                    (secondary-order #'lex>) (start 0)
+;;;                    (order
+;;;                    (elimination-order k :primary-order
+;;;                    primary-order :secondary-order
+;;;                    secondary-order))
+;;;                    (top-reduction-only nil)
+;;;                    (ring *coefficient-ring*))
+;;;    Returns the K-th elimination ideal of the ideal generated by
+;;;    polynomial list FLIST. Thus, a Grobner basis of the ideal generated
+;;;    by FLIST is calculated and polynomials depending on variables 0-K are
+;;;    discarded. The monomial order in the calculation is an elimination
+;;;    order formed by combining two orders: PRIMARY-ORDER used on variables
+;;;    0-K and SECONDARY-ORDER used on variables starting from variable K+1.
+;;;    Thus, if both orders are set to the lexicographic order #'LEX> then
+;;;    the resulting order is simply equivalent to #'LEX>. But one could use
+;;;    arbitrary two orders in this function, for instance, two copies of
+;;;    #'GREVLEX> (see ORDER package). When doing so, the caller must ensure
+;;;    that the same order has been used to sort the terms of the
+;;;    polynomials FLIST. 
+;;;
+;;; IDEAL-INTERSECTION (f g pred top-reduction-only ring)            [FUNCTION]
+;;;    Return the Grobner basis of the intersection of the ideals
+;;;    generated by the polynomial lists F and G. PRED is an admissible
+;;;    monomial order with respect to which the terms of F and G have been
+;;;    sorted. This order is going to be used in the Grobner basis
+;;;    calculation. If TOP-REDUCTION-ONLY is not NIL, internally the Grobner
+;;;    basis algorithm will perform top reduction only.  The RING parameter,
+;;;    as usual, should be set to a structure defined in the package
+;;;    COEFFICIENT-RING, and it will be used to perform all operations on
+;;;    coefficients.
+;;;
+;;; POLY-CONTRACT (f &optional (k 1))                                [FUNCTION]
+;;;    Return a polynomial obtained from polynomial F by dropping the
+;;;    first K variables, if F does not depend on them.  Note that this
+;;;    operation makes the polynomial incompatible for certain arithmetical
+;;;    operations with the original polynomial F. Calling this function on a
+;;;    polynomial F which does depend on variables 0-K will result in error.
+;;;
+;;; POLY-LCM (f g &optional (pred #'lex>)                            [FUNCTION]
+;;;           (ring *coefficient-ring*))
+;;;    Return LCM (least common multiple) of two polynomials F and G.
+;;;    The polynomials must be ordered according to monomial order PRED
+;;;    and their coefficients must be compatible with the RING structure
+;;;    defined in the COEFFICIENT-RING package.
+;;;
+;;; GROBNER-GCD (f g &optional (pred #'lex>)                         [FUNCTION]
+;;;              (ring *coefficient-ring*))
+;;;    Return GCD (greatest common divisor) of two polynomials F and G.
+;;;    The polynomials must be ordered according to monomial order PRED
+;;;    and their coefficients must be compatible with the RING structure
+;;;    defined in the COEFFICIENT-RING package.
+;;;
+;;; GROBNER-EQUAL (g1 g2 &optional (pred #'lex>)                     [FUNCTION]
+;;;                (ring *coefficient-ring*))
+;;;    Returns T if two lists of polynomials G1 and G2, assumed to be
+;;;    Grobner bases, generate  the same ideal, and NIL otherwise.
+;;;
+;;; GROBNER-SUBSETP (g1 g2 &optional (pred #'lex>)                   [FUNCTION]
+;;;                  (ring *coefficient-ring*))
+;;;    Returns T if a list of polynomials G1 generates
+;;;    an ideal contained in the ideal generated by a polynomial list G2,
+;;;    both G1 and G2 assumed to be Grobner bases. Returns NIL otherwise.
+;;;
+;;; GROBNER-MEMBER (p g &optional (pred #'lex>)                      [FUNCTION]
+;;;                 (ring *coefficient-ring*))
+;;;    Returns T if a polynomial P belongs to the ideal generated by the
+;;;    polynomial list G, which is assumed to be a Grobner basis. Returns
+;;;    NIL otherwise. 
+;;;
+;;; IDEAL-EQUAL (f1 f2 pred top-reduction-only ring)                 [FUNCTION]
+;;;    Returns T if two ideals generated by polynomial lists F1 and F2 are
+;;;    identical. Returns NIL otherwise.
+;;;
+;;; IDEAL-SUBSETP (f1 f2 &optional (pred #'lex>)                     [FUNCTION]
+;;;                (ring *coefficient-ring*))
+;;;    Returns T if the ideal spanned by the polynomial list F1 is contained
+;;;    in the ideal spanned by the polynomial list F2. Returns NIL
+;;;    otherwise. 
+;;;
+;;; IDEAL-MEMBER (p plist pred top-reduction-only ring)              [FUNCTION]
+;;;    Returns T if the polynomial P belongs to the ideal spanned by the
+;;;    polynomial list PLIST, and NIL otherwise.
+;;;
+;;; IDEAL-SATURATION-1 (f p pred start top-reduction-only ring       [FUNCTION]
+;;;                     &aux (pred (elimination-order-1 pred)))
+;;;    Returns the reduced Grobner basis of the saturation of the ideal
+;;;    generated by a polynomial list F in the ideal generated by a single
+;;;    polynomial P. The saturation ideal is defined as the set of
+;;;    polynomials H such for some natural number n (* (EXPT P N) H) is in
+;;;    the ideal F. Geometrically, over an algebraically closed field, this
+;;;    is the set of polynomials in the ideal generated by F which do not
+;;;    identically vanish on the variety of P.
+;;;
+;;; ADD-VARIABLES (plist n)                                          [FUNCTION]
+;;;    Add N new variables, adn the first N variables, to every polynomial
+;;;    in polynomial list PLIST. The resulting polynomial will not depend on
+;;;    these N variables. 
+;;;
+;;; EXTEND-POLYNOMIALS (plist &aux (k (length plist)))               [FUNCTION]
+;;;    Returns polynomial list {U1*P1', U2*P2', ... , UK*PK'}
+;;;    where Ui are new variables and PLIST={P1, P2, ... , PK} is a
+;;;    polynomial list. PI' is obtained from PI by adding new variables U1,
+;;;    U2, ..., UN UK as the first K variables. Thus, the resulting list is
+;;;    consists of polynomials whose terms are ordered by the lexicographic
+;;;    order on variables UI, with ties resolved by the monomial order which
+;;;    was used to order the terms of the polynomials in PLIST. We note that
+;;;    the monomial order does not explicitly participate in this
+;;;    calculation, and neither do the variable names.
+;;;
+;;; SATURATION-EXTENSION (f plist ring &aux (k (length plist)) (d    [FUNCTION]
+;;;                       (+ k (length (caaar plist)))))
+;;;    Returns F' union {U1*P1-1,U2*P2-1,...,UK*PK-1} where Ui are new
+;;;    variables and F' is a polynomial list  obtained from F by adding
+;;;    variables U1, U2, ..., Uk as the first K variables to each polynomial
+;;;    in F. Thus, the resulting list is consists of polynomials whose terms
+;;;    are ordered by the lexicographic order on variables Ui, with ties
+;;;    resolved by the monomial order which was used to order the terms of
+;;;    the polynomials in F. We note that the monomial order does not
+;;;    explicitly participate in this calculation, and neither do the
+;;;    variable names. 
+;;;
+;;; POLYSATURATION-EXTENSION (f plist ring &aux (k (length plist))   [FUNCTION]
+;;;                           (d (+ k (length (caaar plist)))))
+;;;    Returns F' union {U1*P1+U2*P2+UK*PK-1} where Ui are new variables
+;;;    and F' is a polynomial list  obtained from F by adding variables U1,
+;;;    U2, ..., Uk as the first K variables to each polynomial in F. Thus,
+;;;    the resulting list is consists of polynomials whose terms are ordered
+;;;    by the lexicographic order on variables Ui, with ties resolved by the
+;;;    monomial order which was used to order the terms of the polynomials
+;;;    in F. We note that the monomial order does not explicitly participate
+;;;    in this calculation, and neither do the variable names. 
+;;;
+;;; SATURATION-EXTENSION-1 (f p ring)                                [FUNCTION]
+;;;    Return the list F' union {U*P-1} where U is a new variable,
+;;;    where F' is obtained from the polynomial list F by adding U as the
+;;;    first variable. The variable U will be added as the first variable,
+;;;    so that it can be easily eliminated.
+;;;
+;;; IDEAL-POLYSATURATION-1 (f plist pred start top-reduction-only    [FUNCTION]
+;;;                         ring)
+;;;    Returns the reduced Grobner basis of the ideal obtained by a
+;;;    sequence of successive saturations in the polynomials
+;;;    of the polynomial list PLIST of the ideal generated by the
+;;;    polynomial list F.
+;;;
+;;; IDEAL-SATURATION (f g pred start top-reduction-only ring         [FUNCTION]
+;;;                   &aux (k (length g)) (pred
+;;;                   (elimination-order k :primary-order #'lex>
+;;;                   :secondary-order pred)))
+;;;    Returns the reduced Grobner basis of the saturation of the ideal
+;;;    generated by a polynomial list F in the ideal generated a polynomial
+;;;    list G The saturation ideal is defined as the set of polynomials H
+;;;    such for some natural number n and some P in the ideal generated by G
+;;;    the polynomial P**N * H is in the ideal spanned by F.  Geometrically,
+;;;    over an algebraically closed field, this is the set of polynomials in
+;;;    the ideal generated by F which do not identically vanish on the
+;;;    variety of G.
+;;;
+;;; IDEAL-POLYSATURATION (f ideal-list pred start                    [FUNCTION]
+;;;                       top-reduction-only ring)
+;;;    Returns the reduced Grobner basis of the ideal obtained by a
+;;;    successive applications of IDEAL-SATURATIONS to F and
+;;;    lists of polynomials in the list IDEAL-LIST.
+;;;
+;;; BUCHBERGER-CRITERION (g pred ring)                               [FUNCTION]
+;;;    Returns T if G is a Grobner basis, by using the Buchberger
+;;;    criterion: for every two polynomials h1 and h2 in G the S-polynomial
+;;;    S(h1,h2) reduces to 0 modulo G.
+;;;
+;;; GROBNER-TEST (g f pred ring)                                     [FUNCTION]
+;;;    Test whether G is a Grobner basis and F is contained in G. Return T
+;;;    upon success and NIL otherwise.
+;;;
+;;; MINIMIZATION (p pred)                                            [FUNCTION]
+;;;    Returns a sublist of the polynomial list P spanning the same
+;;;    monomial ideal as P but minimal, i.e. no leading monomial
+;;;    of a polynomial in the sublist divides the leading monomial
+;;;    of another polynomial.
+;;;
+;;; ADD-MINIMIZED (f gred pred)                                      [FUNCTION]
+;;;    Adds a polynomial f to GRED, reduced Grobner basis, preserving the
+;;;    property described in the documentation for MINIMIZATION.
+;;;
+;;; COLON-IDEAL (f g pred top-reduction-only ring)                   [FUNCTION]
+;;;    Returns the reduced Grobner basis of the colon ideal Id(F):Id(G),
+;;;    where F and G are two lists of polynomials. The colon ideal I:J is
+;;;    defined as the set of polynomials H such that there is a polynomial W
+;;;    in J for which W*H belongs to I.
+;;;
+;;; COLON-IDEAL-1 (f g pred top-reduction-only ring)                 [FUNCTION]
+;;;    Returns the reduced Grobner basis of the colon ideal Id(F):Id({G}),
+;;;    where F is a list of polynomials and G is a polynomial.
+;;;
+;;; PSEUDO-DIVIDE (f fl pred ring)                                   [FUNCTION]
+;;;    Pseudo-divide a polynomial F by the list of polynomials FL. Return
+;;;    multiple values. The first value is a list of quotients A.
+;;;    The second value is the remainder R. The third value is an integer
+;;;    count of the number of reductions performed. Finally, the fourth
+;;;    argument is a scalar coefficient C, such that C*F can be divided by
+;;;    FL within the ring of coefficients, which is not necessarily a field.
+;;;    The resulting objects satisfy the equation:
+;;;     C*F= sum A[i]*FL[i] + R
+;;;
+;;; GEBAUER-MOELLER (f pred start top-reduction-only ring &aux b g   [FUNCTION]
+;;;                  f1)
+;;;    Compute Grobner basis by using the algorithm of Gebauer and Moeller.
+;;;    This algorithm is described as BUCHBERGERNEW2 in the book by
+;;;    Becker-Weispfenning entitled ``Grobner Bases''
+;;;
+;;; UPDATE (g b h pred ring &aux c d e b-new g-new pair)             [FUNCTION]
+;;;    An implementation of the auxillary UPDATE algorithm used by the
+;;;    Gebauer-Moeller algorithm. G is a list of polynomials, B is a list of
+;;;    critical pairs and H is a new polynomial which possibly will be added
+;;;    to G. The naming conventions used are very close to the one used in
+;;;    the book of Becker-Weispfenning.
+;;;
+;;; GEBAUER-MOELLER-MERGE-PAIRS-USE-MOCK-SPOLY (b c pred ring)       [FUNCTION]
+;;;    The merging strategy used by the Gebauer-Moeller algorithm, based
+;;;    on MOCK-SPOLY; see the documentation of
+;;;    BUCHBERGER-MERGE-PAIRS-USE-MOCK-SPOLY.
+;;;
+;;; GEBAUER-MOELLER-MERGE-PAIRS-SMALLEST-LCM (b c pred ring)         [FUNCTION]
+;;;    The merging strategy based on the smallest-lcm (normal strategy); see
+;;;    the documentation of BUCHBERGER-MERGE-PAIRS-SMALLEST-LCM.
+;;;
+;;; GEBAUER-MOELLER-MERGE-PAIRS-USE-SMALLEST-DEGREE (b c pred ring)  [FUNCTION]
+;;;    The merging strategy based on the smallest-lcm (normal strategy); see
+;;;    the documentation of BUCHBERGER-MERGE-PAIRS-USE-SMALLEST-DEGREE.
+;;;
+;;; GEBAUER-MOELLER-MERGE-PAIRS-USE-SMALLEST-LENGTH (b c pred ring)  [FUNCTION]
+;;;
+;;; GEBAUER-MOELLER-MERGE-PAIRS-USE-SMALLEST-COEFFICIENT-LENGTH (b   [FUNCTION]
+;;;                                                              c
+;;;                                                              pred ring)
+;;;    The merging strategy based on the smallest-lcm (normal strategy); see
+;;;    the documentation of
+;;;    BUCHBERGER-MERGE-PAIRS-USE-SMALLEST-COEFFICIENT-LENGTH. 
+;;;
+;;; GEBAUER-MOELLER-SET-PAIR-HEURISTIC (method                       [FUNCTION]
+;;;                                     &aux (strategy-fn
+;;;                                     (ecase method
+;;;                                     (:minimal-mock-spoly
+;;;                                     #'gebauer-moeller-merge-pairs-use-mock-spoly) (:minimal-lcm #'gebauer-moeller-merge-pairs-smallest-lcm) (:minimal-total-degree #'gebauer-moeller-merge-pairs-use-smallest-degree)
+;;;                                     (:minimal-length
+;;;                                     #'gebauer-moeller-merge-pairs-use-smallest-length) (:minimal-coefficient-length #'gebauer-moeller-merge-pairs-use-smallest-coefficient-length))))
+;;;
+;;; SPOLY-SUGAR (f-with-sugar g-with-sugar ring)                     [FUNCTION]
+;;;    Calculate the ``sugar'' of the S-polynomial of two polynomials with
+;;;    sugar. A polynomial with sugar is simply a pair (P . SUGAR) where
+;;;    SUGAR is an integer constant defined according to the following
+;;;    algorighm: the sugar of sum or difference of two polynomials with
+;;;    sugar is the MAX of the sugars of those two polynomials. The sugar of
+;;;    a product of a term and a polynomial is the sum of the degree of the
+;;;    term and the sugar of the polynomial.  The idea is to accumulate
+;;;    sugar as we perform the arithmetic operations, and that polynomials
+;;;    with small (little) sugar should be given priority in the
+;;;    calculations. Thus, the ``sugar strategy'' of the critical pair
+;;;    selection is to select a pair with the smallest value of sugar of the
+;;;    resulting S-polynomial.
+;;;
+;;; SPOLY-WITH-SUGAR (f-with-sugar g-with-sugar pred ring)           [FUNCTION]
+;;;    The S-polynomials of two polynomials with SUGAR strategy.
+;;;
+;;; NORMAL-FORM-WITH-SUGAR (f fl pred top-reduction-only ring)       [FUNCTION]
+;;;    Normal form of the polynomial with sugar F with respect to
+;;;    a list of polynomials with sugar FL. Assumes that FL is not empty.
+;;;    Parameters PRED, TOP-REDUCTION-ONLY and RING have the same meaning as
+;;;    in NORMAL-FORM. The parameter SUGAR-LIMIT should be set to a positive
+;;;    integer. If the sugar limit of the partial remainder exceeds
+;;;    SUGAR-LIMIT then the calculation is stopped and the partial remainder
+;;;    is returned, although it is not fully reduced with respect to FL. 
+;;;
+;;; BUCHBERGER-WITH-SUGAR (f-no-sugar pred start top-reduction-only  [FUNCTION]
+;;;                        ring &aux (s (1- (length f-no-sugar))) b
+;;;                        m f)
+;;;    Returns a Grobner basis of an ideal generated by a list of ordinary
+;;;    polynomials F-NO-SUGAR. Adds initial sugar to the polynomials and
+;;;    performs the Buchberger algorithm with ``sugar strategy''. It returns
+;;;    an ordinary list of polynomials with no sugar. One of the most
+;;;    effective algorithms for Grobner basis calculation.
+;;;
+;;; BUCHBERGER-WITH-SUGAR-MERGE-PAIRS (b c g m pred ring)            [FUNCTION]
+;;;    Merges lists of critical pairs. It orders pairs according to
+;;;    increasing sugar, with ties broken by smaller MOCK-SPOLY value of the
+;;;    two polynomials. In this function B must already be sorted.
+;;;
+;;; BUCHBERGER-WITH-SUGAR-SORT-PAIRS (c g m pred ring)               [FUNCTION]
+;;;    Sorts critical pairs C according to sugar strategy.
+;;;
+;;; CRITERION-1-WITH-SUGAR (pair g &aux (i (first pair)) (j          [FUNCTION]
+;;;                         (second pair)))
+;;;    An implementation of Buchberger's first criterion for polynomials 
+;;;    with sugar. See the documentation of BUCHBERGER-CRITERION-1.
+;;;
+;;; CRITERION-2-WITH-SUGAR (pair g m &aux (i (first pair)) (j        [FUNCTION]
+;;;                         (second pair)))
+;;;    An implementation of Buchberger's first criterion for polynomials 
+;;;    with sugar. See the documentation of BUCHBERGER-CRITERION-2.
+;;;
+;;; GEBAUER-MOELLER-WITH-SUGAR (f pred start top-reduction-only      [FUNCTION]
+;;;                             ring &aux b g f1)
+;;;    Compute Grobner basis by using the algorithm of Gebauer and Moeller.
+;;;    This algorithm is described as BUCHBERGERNEW2 in the book by
+;;;    Becker-Weispfenning entitled ``Grobner Bases''
+;;;
+;;; UPDATE-WITH-SUGAR (g b h pred ring &aux c d e b-new g-new pair)  [FUNCTION]
+;;;    An implementation of the auxillary UPDATE algorithm used by the
+;;;    Gebauer-Moeller algorithm. G is a list of polynomials, B is a list of
+;;;    critical pairs and H is a new polynomial which possibly will be added
+;;;    to G. The naming conventions used are very close to the one used in
+;;;    the book of Becker-Weispfenning. Operates on polynomials with sugar.
+;;;
+;;; GEBAUER-MOELLER-WITH-SUGAR-MERGE-PAIRS (b c pred ring)           [FUNCTION]
+;;;    Merges lists of critical pairs. It orders pairs according to
+;;;    increasing sugar, with ties broken by smaller lcm of head monomials
+;;;    In this function B must already be sorted. Operates on polynomials
+;;;    with sugar. 
+;;;
+;;; GROBNER-PRIMITIVE-PART-WITH-SUGAR (h ring)                       [FUNCTION]
+;;;
Index: /trunk/doc/infix.txt
===================================================================
--- /trunk/doc/infix.txt	(revision 8)
+++ /trunk/doc/infix.txt	(revision 8)
@@ -0,0 +1,193 @@
+
+;;; *VERSION* ("1.3  28-jun-96")                                    [PARAMETER]
+;;;
+;;; *PRINT-INFIX-COPYRIGHT* (t)                                     [PARAMETER]
+;;;    If non-NIL, prints a copyright notice upon loading this file.
+;;;
+;;; INFIX-COPYRIGHT (&optional (stream *standard-output*))           [FUNCTION]
+;;;    Prints an INFIX copyright notice and header upon startup.
+;;;
+;;; *INFIX-READTABLE* ((copy-readtable nil))                        [PARAMETER]
+;;;
+;;; *NORMAL-READTABLE* ((copy-readtable nil))                       [PARAMETER]
+;;;
+;;; INFIX-ERROR (format-string &rest args)                              [MACRO]
+;;;
+;;; INFIX-READER (stream subchar arg)                                [FUNCTION]
+;;;
+;;; STRING->PREFIX (string)                                          [FUNCTION]
+;;;    Convert a string to a prefix s-expression using the infix reader.
+;;;     If the argument is not a string, just return it as is.
+;;;
+;;; READ-INFIX (stream)                                              [FUNCTION]
+;;;
+;;; READ-REGULAR (stream)                                            [FUNCTION]
+;;;
+;;; SAME-OPERATOR-P (x y)                                            [FUNCTION]
+;;;
+;;; SAME-TOKEN-P (x y)                                               [FUNCTION]
+;;;
+;;; *PEEKED-TOKEN* (nil)                                             [VARIABLE]
+;;;
+;;; READ-TOKEN (stream)                                              [FUNCTION]
+;;;
+;;; PEEK-TOKEN (stream)                                              [FUNCTION]
+;;;
+;;; FANCY-NUMBER-FORMAT-P (left operator stream)                     [FUNCTION]
+;;;
+;;; VALID-NUMBERP (string)                                           [FUNCTION]
+;;;
+;;; GATHER-SUPERIORS (previous-operator stream)                      [FUNCTION]
+;;;    Gathers an expression whose operators all exceed the precedence of
+;;;    the operator to the left.
+;;;
+;;; GET-FIRST-TOKEN (stream)                                         [FUNCTION]
+;;;
+;;; APPLY-TOKEN-PREFIX-OPERATOR (token stream)                       [FUNCTION]
+;;;
+;;; GET-NEXT-TOKEN (stream left)                                     [FUNCTION]
+;;;
+;;; APPLY-TOKEN-INFIX-OPERATOR (token left stream)                   [FUNCTION]
+;;;
+;;; INFIX-READ-DELIMITED-LIST (end-token delimiter-token stream)     [FUNCTION]
+;;;
+;;; *OPERATOR-ORDERING* ('(([ |(| !) (^) (~) (* / %) (+ -) (<< >>)  [PARAMETER]
+;;;                      (< == > <= != >=) (&) (^^) (|\||) (not)
+;;;                      (and) (or) (= |:=| += -= *= /=) (|,|) (if)
+;;;                      (then else) (] |)|) (%infix-end-token%)))
+;;;    Ordered list of operators of equal precedence.
+;;;
+;;; OPERATOR-LESSP (op1 op2)                                         [FUNCTION]
+;;;
+;;; *RIGHT-ASSOCIATIVE-OPERATORS* ('(^ =))                          [PARAMETER]
+;;;
+;;; OPERATOR-RIGHT-ASSOCIATIVE-P (operator)                          [FUNCTION]
+;;;
+;;; *TOKEN-OPERATORS* (nil)                                          [VARIABLE]
+;;;
+;;; *TOKEN-PREFIX-OPERATOR-TABLE* ((make-hash-table))                [VARIABLE]
+;;;
+;;; *TOKEN-INFIX-OPERATOR-TABLE* ((make-hash-table))                 [VARIABLE]
+;;;
+;;; TOKEN-OPERATOR-P (token)                                         [FUNCTION]
+;;;
+;;; GET-TOKEN-PREFIX-OPERATOR (token)                                [FUNCTION]
+;;;
+;;; GET-TOKEN-INFIX-OPERATOR (token)                                 [FUNCTION]
+;;;
+;;; DEFINE-TOKEN-OPERATOR (operator-name &key (prefix nil prefix-p)     [MACRO]
+;;;                        (infix nil infix-p))
+;;;
+;;; DEFINE-CHARACTER-TOKENIZATION (char function)                       [MACRO]
+;;;
+;;; POST-PROCESS-EXPRESSION (expression)                             [FUNCTION]
+;;;
+;;; *TEST-CASES* ('(("1 * +2" (* 1 2)) ("1 * -2" (* 1 (- 2))) ("1   [PARAMETER]
+;;;               * /2" (* 1 (/ 2))) ("/2" (/ 2)) ("not true"
+;;;               (not true)) ("foo\\-bar" foo-bar) ("a + b-c"
+;;;               (+ a b (- c))) ("a + b\\-c" (+ a b-c)) ("f\\oo"
+;;;               |foo|)
+;;;               ("!foo-bar * 2" (* foo-bar 2)) ("!(foo bar baz)"
+;;;               (foo bar baz)) ("!foo-bar " foo-bar) ("!foo-bar"
+;;;               foo-bar)
+;;;               ("a+-b" (+ a (- b))) ("a+b" (+ a b)) ("a+b*c" (+
+;;;               a (* b c))) ("a+b+c" (+ a b c)) ("a+b-c" (+ a b
+;;;               (- c))) ("a+b-c+d" (+ a b (- c) d)) ("a+b-c-d" (+
+;;;               a b (- c) (- d))) ("a-b" (- a b)) ("a*b" (* a b))
+;;;               ("a*b*c" (* a b c)) ("a*b+c" (+ (* a b) c))
+;;;               ("a/b" (/ a b)) ("a^b" (expt a b)) ("foo/-bar"
+;;;               (/ foo (- bar))) ("1+2*3^4" (+ 1
+;;;               (* 2 (expt 3 4)))) ("1+2*3^4+5" (+ 1 (* 2
+;;;               (expt 3 4)) 5)) ("2*3^4+1" (+ (* 2 (expt 3 4))
+;;;               1))
+;;;               ("2+3^4*5" (+ 2 (* (expt 3 4) 5))) ("2^3^4" (expt
+;;;               2 (expt 3 4))) ("x^2 + y^2" (+ (expt x 2)
+;;;               (expt y 2))) ("(1+2)/3" (/ (+ 1 2) 3)) ("(a=b)"
+;;;               (setq a b)) ("(a=b,b=c)"
+;;;               (progn (setq a b) (setq b c))) ("1*(2+3)" (* 1
+;;;               (+ 2 3))) ("1+2/3" (+ 1 (/ 2 3))) ("a,b" (progn a
+;;;               b))
+;;;               ("a,b,c" (progn a b c)) ("foo(a,b,(c,d))"
+;;;               (foo a b (progn c d))) ("foo(a,b,c)" (foo a b c))
+;;;               ("(a+b,c)" (progn (+ a b) c)) ("1" 1) ("-1"
+;;;               (- 1)) ("+1" 1) ("1." 1) ("1.1" 1.1) ("1e3"
+;;;               1000.0)
+;;;               ("1e-3" 0.001) ("1f-3" 0.001) ("1e-3e" (- 1e 3e))
+;;;               ("!1e-3 " 0.001) ("a and b and c" (and a b c))
+;;;               ("a and b or c" (or (and a b) c)) ("a and b" (and
+;;;               a b))
+;;;               ("a or b and c" (or a (and b c))) ("a or b" (or a
+;;;               b))
+;;;               ("a<b and b<c" (and (< a b) (< b c))) ("if (if a
+;;;               then b else c) then e"
+;;;               (when (if a b c) e)) ("if 1 then 2 else 3+4" (if
+;;;               1 2 (+ 3 4))) ("(if 1 then 2 else 3)+4" (+
+;;;               (if 1 2 3) 4)) ("if a < b then b else a" (if
+;;;               (< a b) b a)) ("if a and b then c and d else e
+;;;               and f" (if (and a b) (and c d) (and e f))) ("if a
+;;;               or b then c or d else e or f"
+;;;               (if (or a b) (or c d) (or e f))) ("if a then (if
+;;;               b then c else d) else e"
+;;;               (if a (if b c d) e)) ("if a then (if b then c)
+;;;               else d" (if a (when b c) d)) ("if a then b else
+;;;               c" (if a b c)) ("if a then b" (when a b)) ("if a
+;;;               then if b then c else d else e"
+;;;               (if a (if b c d) e)) ("if a then if b then c else
+;;;               d" (when a (if b c d))) ("if if a then b else c
+;;;               then e" (when (if a b c) e)) ("if not a and not b
+;;;               then c" (when (and (not a) (not b)) c)) ("if not
+;;;               a then not b else not c and d"
+;;;               (if (not a) (not b) (and (not c) d))) ("not a and
+;;;               not b" (and (not a) (not b))) ("not a or not b"
+;;;               (or (not a) (not b))) ("not a<b and not b<c" (and
+;;;               (not (< a b)) (not (< b c)))) ("not a<b" (not (<
+;;;               a b)))
+;;;               ("a[i,k]*b[j,k]" (* (aref a i k) (aref b j k)))
+;;;               ("foo(bar)=foo[bar,baz]"
+;;;               (setf (foo bar) (aref foo bar baz)))
+;;;               ("foo(bar,baz)" (foo bar baz)) ("foo[bar,baz]"
+;;;               (aref foo bar baz)) ("foo[bar,baz]=barf"
+;;;               (setf (aref foo bar baz) barf)) ("max = if a < b
+;;;               then b else a" (setq max (if (< a b) b a))) ("a <
+;;;               b < c" (< a b c)) ("a < b <= c"
+;;;               (and (< a b) (<= b c))) ("a <= b <= c" (<= a b
+;;;               c))
+;;;               ("a <= b <= c" (<= a b c)) ("a!=b and b<c"
+;;;               (and (not (= a b)) (< b c))) ("a!=b" (not (= a
+;;;               b)))
+;;;               ("a<b" (< a b)) ("a==b" (= a b)) ("a*b(c)+d"
+;;;               (+ (* a (b c)) d)) ("a+b(c)*d" (+ a (* (b c) d)))
+;;;               ("a+b(c)+d" (+ a (b c) d)) ("d+a*b(c)"
+;;;               (+ d (* a (b c)))) ("+a+b" (+ a b)) ("-a+b" (+ (-
+;;;               a) b))
+;;;               ("-a-b" (+ (- a) (- b))) ("-a-b-c" (+ (- a) (- b)
+;;;               (- c))) ("a*b/c" (/ (* a b) c)) ("a+b-c" (+ a b
+;;;               (- c))) ("a-b-c" (- a b c)) ("a/b*c" (* (/ a b)
+;;;               c))
+;;;               ("a/b/c" (/ a b c)) ("/a/b" (/ (* a b))) ("a^b^c"
+;;;               (expt a (expt b c))) ("a(d)^b^c" (expt (a d)
+;;;               (expt b c))) ("a<b+c<d" (< a (+ b c) d))
+;;;               ("1*~2+3" (+ (* 1 (lognot 2)) 3)) ("1+~2*3" (+ 1
+;;;               (* (lognot 2) 3))) ("1+~2+3" (+ 1 (lognot 2) 3))
+;;;               ("f(a)*=g(b)" (setf (f a) (* (f a) (g b))))
+;;;               ("f(a)+=g(b)" (incf (f a) (g b))) ("f(a)-=g(b)"
+;;;               (decf (f a) (g b))) ("f(a)/=g(b)" (setf (f a)
+;;;               (/ (f a) (g b)))) ("a&b" (logand a b)) ("a^^b"
+;;;               (logxor a b)) ("a|b" (logior a b)) ("a<<b"
+;;;               (ash a b)) ("a>>b" (ash a (- b))) ("~a"
+;;;               (lognot a)) ("a&&b" (and a b)) ("a||b" (or a b))
+;;;               ("a%b" (mod a b)) ("x^2   ; the x coordinate +
+;;;               y^2 ; the y coordinate" :error)
+;;;               ("x^2   ; the x coordinate + y^2 ; the y
+;;;               coordinate " (+ (expt x 2) (expt y 2)))
+;;;               ("foo(bar,baz" :error) ("foo(bar,baz))"
+;;;               (foo bar baz)) ("foo[bar,baz]]" :error)
+;;;               ("[foo,bar]" :error) ("and a" :error)
+;;;               ("< a" :error) ("=bar" :error) ("*bar" :error)
+;;;               ("a not b" :error) ("a if b then c" :error)
+;;;               ("" :error) (")a" :error) ("]a" :error)))
+;;;
+;;; TEST-INFIX (&optional (tests *test-cases*))                      [FUNCTION]
+;;;
+;;; TEST-INFIX-CASE (string result)                                  [FUNCTION]
+;;;
Index: /trunk/doc/makelist.txt
===================================================================
--- /trunk/doc/makelist.txt	(revision 8)
+++ /trunk/doc/makelist.txt	(revision 8)
@@ -0,0 +1,21 @@
+
+;;; MAKELIST-1 (expr var lo hi &optional (step 1))                      [MACRO]
+;;;
+;;; MAKELIST (expr (var lo hi &optional (step 1)) &rest more)           [MACRO]
+;;;
+;;; SUM (&body body)                                                    [MACRO]
+;;;
+;;; LIST-OF (expr (var lst) &rest more)                                 [MACRO]
+;;;
+;;; LIST-OF-1 (expr var lst)                                            [MACRO]
+;;;
+;;; UNION-OF (expr (var lst) &rest more)                                [MACRO]
+;;;
+;;; UNION-OF-1 (expr var lst)                                           [MACRO]
+;;;
+;;; SET-OF (expr (var lst) &rest more)                                  [MACRO]
+;;;
+;;; SET-OF-1 (expr var lst)                                             [MACRO]
+;;;
+;;; SELECT (ind lst)                                                 [FUNCTION]
+;;;
Index: /trunk/doc/modular-poly.txt
===================================================================
--- /trunk/doc/modular-poly.txt	(revision 8)
+++ /trunk/doc/modular-poly.txt	(revision 8)
@@ -0,0 +1,11 @@
+
+;;; MODULAR-TRACE (plist modulus)                                    [FUNCTION]
+;;;    Return PLIST with coefficients reduced modulo prime MODULUS.
+;;;
+;;; MODULAR-TRACE-1 (p modulus)                                      [FUNCTION]
+;;;    Return a polynomial P with coefficients reduced modulo prime MODULUS.
+;;;
+;;; FROBENIUS-KERNEL (n modulus)                                     [FUNCTION]
+;;;    Return a list of N polynomials of the form XI**MODULUS-XI, where
+;;;    XI is the I-th variable. Work in internal alist representation.
+;;;
Index: /trunk/doc/modular.txt
===================================================================
--- /trunk/doc/modular.txt	(revision 8)
+++ /trunk/doc/modular.txt	(revision 8)
@@ -0,0 +1,22 @@
+
+;;; MODULAR-INVERSE (x p)                                            [FUNCTION]
+;;;    Find the inverse of X modulo prime P, using Euclid algorithm.
+;;;
+;;; MODULAR-DIVISION (x y p)                                         [FUNCTION]
+;;;    Divide X by Y modulo prime P.
+;;;
+;;; *INVERSE-BY-LOOKUP-LIMIT* (100000)                               [VARIABLE]
+;;;    If prime modulus is < this number then the division algorithm
+;;;    will use a lookup table of inverses created at the time when
+;;;    field-modulo-prime is called. 
+;;;
+;;; MAKE-INVERSE-TABLE (modulus &aux (table (list 0)))               [FUNCTION]
+;;;    Make a vector of length MODULUS containing all inverses modulo
+;;;    MODULUS, which should be a prime number. The inverse of 0 is 0.
+;;;
+;;; MAKE-MODULAR-DIVISION (modulus)                                  [FUNCTION]
+;;;    Return a function of two arguments which will perform division
+;;;    modulo MODULUS. Currently, if MODULUS is < *INVERSE-BY-LOOKUP-LIMIT*
+;;;    then the returned function does table lookup, otherwise it uses
+;;;    the Euclid algorithm to find the inverse.
+;;;
Index: /trunk/doc/monom.txt
===================================================================
--- /trunk/doc/monom.txt	(revision 8)
+++ /trunk/doc/monom.txt	(revision 8)
@@ -0,0 +1,29 @@
+
+;;; MONOM/ (m1 m2)                                                   [FUNCTION]
+;;;    Divide monomial M1 by monomial M2.
+;;;
+;;; MONOM* (m1 m2)                                                   [FUNCTION]
+;;;    Multiply monomial M1 by monomial M2.
+;;;
+;;; NMONOM* (m1 m2)                                                  [FUNCTION]
+;;;    Multiply monomials M1 and M2 - destructive version.
+;;;     M1 is destructively modified, M2 is not modified.
+;;;
+;;; MONOM-DIVIDES-P (m1 m2)                                          [FUNCTION]
+;;;    Returns T if monomial M1 divides monomial M2, NIL otherwise.
+;;;
+;;; MONOM-DIVISIBLE-BY-P (m1 m2)                                     [FUNCTION]
+;;;    Returns T if monomial M1 is divisible by monomial M2, NIL otherwise.
+;;;
+;;; MONOM-REL-PRIME (m1 m2)                                          [FUNCTION]
+;;;    Returns T if two monomials M1 and M2 are relatively prime (disjoint).
+;;;
+;;; MONOM-EQUAL (m1 m2)                                              [FUNCTION]
+;;;    Returns T if two monomials M1 and M2 are equal.
+;;;
+;;; MONOM-LCM (m1 m2)                                                [FUNCTION]
+;;;    Returns least common multiple of monomials M1 and M2.
+;;;
+;;; MONOM-GCD (m1 m2)                                                [FUNCTION]
+;;;    Returns greatest common divisor of monomials M1 and M2.
+;;;
Index: /trunk/doc/order.txt
===================================================================
--- /trunk/doc/order.txt	(revision 8)
+++ /trunk/doc/order.txt	(revision 8)
@@ -0,0 +1,39 @@
+
+;;; LEX> (p q &optional (start 0) (end (length p)))                  [FUNCTION]
+;;;    Return T if P>Q with respect to lexicographic order, otherwise NIL. 
+;;;    The second returned value is T if P=Q, otherwise it is NIL.
+;;;
+;;; TOTAL-DEGREE (m &optional (start 0) (end (length m)))            [FUNCTION]
+;;;    Return the todal degree of a monomoal M.
+;;;
+;;; GRLEX> (p q &optional (start 0) (end (length p)))                [FUNCTION]
+;;;    Return T if P>Q with respect to graded lexicographic order, otherwise
+;;;    NIL. The second returned value is T if P=Q, otherwise it is NIL.
+;;;
+;;; GREVLEX> (p q &optional (start 0) (end (length p)))              [FUNCTION]
+;;;    Return T if P>Q with respect to graded reverse lexicographic order,
+;;;    NIL otherwise. The second returned value is T if P=Q, otherwise it is
+;;;    NIL. 
+;;;
+;;; REVLEX> (p q &optional (start 0) (end (length p)))               [FUNCTION]
+;;;    Return T if P>Q with respect to reverse lexicographic order, NIL
+;;;    otherwise.  The second returned value is T if P=Q, otherwise it is
+;;;    NIL. This is not and admissible monomial order because some sets do
+;;;    not have a minimal element. This order is useful in constructing
+;;;    other orders.
+;;;
+;;; INVLEX> (p q &optional (start 0) (end (length p)))               [FUNCTION]
+;;;    Return T if P>Q with respect to inverse lexicographic order, NIL
+;;;    otherwise The second returned value is T if P=Q, otherwise it is NIL.
+;;;
+;;; ELIMINATION-ORDER (k &key (primary-order #'lex>)                 [FUNCTION]
+;;;                    (secondary-order #'lex>))
+;;;    Return a predicate which compares monomials according to the
+;;;    K-th elimination order. Two optional arguments are PRIMARY-ORDER
+;;;    and SECONDARY-ORDER and they should be term orders which are used
+;;;    on the first K and the remaining variables.
+;;;
+;;; ELIMINATION-ORDER-1 (order)                                      [FUNCTION]
+;;;    A special case of the ELIMINATION-ORDER when there is only
+;;;    one primary variable.
+;;;
Index: /trunk/doc/parse.txt
===================================================================
--- /trunk/doc/parse.txt	(revision 8)
+++ /trunk/doc/parse.txt	(revision 8)
@@ -0,0 +1,152 @@
+
+;;; PARSE (&optional stream)                                         [FUNCTION]
+;;;    Parser of infis expressions with integer/rational coefficients
+;;;    The parser will recognize two kinds of polynomial expressions:
+;;;    - polynomials in fully expanded forms with coefficients
+;;;     written in front of symbolic expressions; constants can be
+;;;    optionally enclosed in (); for example, the infix form
+;;;     	X^2-Y^2+(-4/3)*U^2*W^3-5
+;;;     parses to
+;;;    	(+ (- (EXPT X 2) (EXPT Y 2)) (* (- (/ 4 3)) (EXPT U 2) (EXPT W 3))
+;;;    (- 5)) 
+;;;    - lists of polynomials; for example
+;;;           [X-Y, X^2+3*Z]          
+;;;     parses to
+;;;    	  (:[ (- X Y) (+ (EXPT X 2) (* 3 Z)))
+;;;     where the first symbol [ marks a list of polynomials.
+;;;    -other infix expressions, for example
+;;;           [(X-Y)*(X+Y)/Z,(X+1)^2]
+;;;    parses to:
+;;;    	(:[ (/ (* (- X Y) (+ X Y)) Z) (EXPT (+ X 1) 2))
+;;;    Currently this function is implemented using M. Kantrowitz's INFIX
+;;;    package. 
+;;;
+;;; ALIST-FORM (plist vars)                                          [FUNCTION]
+;;;    Translates an expression PLIST, which should be a list of polynomials
+;;;    in variables VARS, to an alist representation of a polynomial.
+;;;    It returns the alist. See also PARSE-TO-ALIST.
+;;;
+;;; ALIST-FORM-1 (p vars                                             [FUNCTION]
+;;;               &aux (ht (make-hash-table :test #'equal :size 16))
+;;;               stack)
+;;;
+;;; POWERS (monom vars                                               [FUNCTION]
+;;;         &aux (tab (pairlis vars (make-list (length vars)
+;;;         :initial-element 0))))
+;;;
+;;; PARSE-TO-ALIST (vars &optional stream)                           [FUNCTION]
+;;;    Parse an expression already in prefix form to an association list
+;;;    form according to the internal CGBlisp polynomial syntax: a
+;;;    polynomial is an alist of pairs (MONOM . COEFFICIENT). For example:
+;;;     (WITH-INPUT-FROM-STRING (S "X^2-Y^2+(-4/3)*U^2*W^3-5")
+;;;    	(PARSE-TO-ALIST '(X Y U W) S))
+;;;    evaluates to
+;;;    (((0 0 2 3) . -4/3) ((0 2 0 0) . -1) ((2 0 0 0) . 1) ((0 0 0 0) .
+;;;    -5)) 
+;;;
+;;; PARSE-STRING-TO-ALIST (str vars)                                 [FUNCTION]
+;;;    Parse string STR and return a polynomial as a sorted association
+;;;    list of pairs (MONOM . COEFFICIENT). For example:
+;;;    (parse-string-to-alist "[x^2-y^2+(-4/3)*u^2*w^3-5,y]" '(x y u w))
+;;;    ([ (((0 0 2 3) . -4/3) ((0 2 0 0) . -1) ((2 0 0 0) . 1)
+;;;        ((0 0 0 0) . -5))
+;;;       (((0 1 0 0) . 1)))
+;;;    The functions PARSE-TO-SORTED-ALIST and PARSE-STRING-TO-SORTED-ALIST
+;;;    sort terms by the predicate defined in the ORDER package.
+;;;
+;;; PARSE-TO-SORTED-ALIST (vars &optional (order #'lex>)             [FUNCTION]
+;;;                        (stream t))
+;;;    Parses streasm STREAM and returns a polynomial represented as 
+;;;    a sorted alist. For example:
+;;;    (WITH-INPUT-FROM-STRING (S "X^2-Y^2+(-4/3)*U^2*W^3-5")
+;;;     (PARSE-TO-SORTED-ALIST '(X Y U W) S))
+;;;    returns
+;;;    (((2 0 0 0) . 1) ((0 2 0 0) . -1) ((0 0 2 3) . -4/3) ((0 0 0 0) .
+;;;    -5)) and
+;;;    (WITH-INPUT-FROM-STRING (S "X^2-Y^2+(-4/3)*U^2*W^3-5")
+;;;     (PARSE-TO-SORTED-ALIST '(X Y U W) T #'GRLEX>) S)
+;;;    returns
+;;;    (((0 0 2 3) . -4/3) ((2 0 0 0) . 1) ((0 2 0 0) . -1) ((0 0 0 0) .
+;;;    -5)) 
+;;;
+;;; PARSE-STRING-TO-SORTED-ALIST (str vars                           [FUNCTION]
+;;;                               &optional (order #'lex>))
+;;;    Parse a string to a sorted alist form, the internal representation
+;;;    of polynomials used by our system.
+;;;
+;;; SORT-POLY-1 (p order)                                            [FUNCTION]
+;;;    Sort the terms of a single polynomial P using an admissible monomial
+;;;    order ORDER. Returns the sorted polynomial. Destructively modifies P.
+;;;
+;;; SORT-POLY (poly-or-poly-list &optional (order #'lex>))           [FUNCTION]
+;;;    Sort POLY-OR-POLY-LIST, which could be either a single polynomial
+;;;    or a list of polynomials in internal alist representation, using
+;;;    admissible monomial order ORDER. Each polynomial is sorted using
+;;;    SORT-POLY-1.
+;;;
+;;; POLY-EVAL-1 (expr vars order ring &aux (n (length vars)))        [FUNCTION]
+;;;    Evaluate an expression EXPR as polynomial
+;;;    by substituting operators + - * expt with
+;;;    corresponding polynomial operators
+;;;    and variables VARS with monomials (1 0 ... 0), (0 1 ... 0) etc.
+;;;    We use special versions of binary
+;;;    operators $poly+, $poly-, $minus-poly, $poly* and $poly-expt
+;;;    which work like the corresponding functions in the
+;;;    POLY package, but accept scalars as arguments as well.
+;;;
+;;; POLY-EVAL (expr vars &optional (order #'lex>)                    [FUNCTION]
+;;;            (ring *coefficient-ring*))
+;;;    Evaluate an expression EXPR, which should be a polynomial
+;;;    expression or a list of polynomial expressions (a list of expressions
+;;;    marked by prepending keyword :[ to it) given in lisp prefix notation,
+;;;    in variables VARS, which should be a list of symbols. The result of
+;;;    the evaluation is a polynomial or a list of polynomials (marked by
+;;;    prepending symbol '[) in the internal alist form. This evaluator is
+;;;    used by the PARSE package to convert input from strings directly to
+;;;    internal form.
+;;;
+;;; MONOM-BASIS (n                                                   [FUNCTION]
+;;;              &aux
+;;;              (basis
+;;;              (copy-tree
+;;;              (make-list n :initial-element
+;;;              (list 'quote
+;;;              (list (cons (make-list n :initial-element 0)
+;;;              1)))))))
+;;;    Generate a list of monomials ((1 0 ... 0) (0 1 0 ... 0) ... (0 0 ...
+;;;    1) which correspond to linear monomials X1, X2, ... XN.
+;;;
+;;; CONVERT-NUMBER (number-or-poly n)                                [FUNCTION]
+;;;    Returns NUMBER-OR-POLY, if it is a polynomial. If it is a number,
+;;;    it converts it to the constant monomial in N variables. If the result
+;;;    is a number then convert it to a polynomial in N variables.
+;;;
+;;; $POLY+ (p q n order ring)                                        [FUNCTION]
+;;;    Add two polynomials P and Q, where each polynomial is either a
+;;;    numeric constant or a polynomial in internal representation. If the
+;;;    result is a number then convert it to a polynomial in N variables.
+;;;
+;;; $POLY- (p q n order ring)                                        [FUNCTION]
+;;;    Subtract two polynomials P and Q, where each polynomial is either a
+;;;    numeric constant or a polynomial in internal representation. If the
+;;;    result is a number then convert it to a polynomial in N variables.
+;;;
+;;; $MINUS-POLY (p n ring)                                           [FUNCTION]
+;;;    Negation of P is a polynomial is either a numeric constant or a
+;;;    polynomial in internal representation. If the result is a number then
+;;;    convert it to a polynomial in N variables.
+;;;
+;;; $POLY* (p q n order ring)                                        [FUNCTION]
+;;;    Multiply two polynomials P and Q, where each polynomial is either a
+;;;    numeric constant or a polynomial in internal representation. If the
+;;;    result is a number then convert it to a polynomial in N variables.
+;;;
+;;; $POLY/ (p q ring)                                                [FUNCTION]
+;;;    Divide a polynomials P which is either a numeric constant or a
+;;;    polynomial in internal representation, by a number Q.
+;;;
+;;; $POLY-EXPT (p l n order ring)                                    [FUNCTION]
+;;;    Raise polynomial P, which is a polynomial in internal
+;;;    representation or a numeric constant, to power L. If P is a number,
+;;;    convert the result to a polynomial in N variables.
+;;;
Index: /trunk/doc/poly-gcd.txt
===================================================================
--- /trunk/doc/poly-gcd.txt	(revision 8)
+++ /trunk/doc/poly-gcd.txt	(revision 8)
@@ -0,0 +1,19 @@
+
+;;; POLY-GCD (a b)                                                   [FUNCTION]
+;;;
+;;; POLY-PSEUDO-DIVIDE (f g)                                         [FUNCTION]
+;;;
+;;; POLY-PSEUDO-REMAINDER (f g)                                      [FUNCTION]
+;;;
+;;; MDEG (b)                                                         [FUNCTION]
+;;;
+;;; LCOEFF (b)                                                       [FUNCTION]
+;;;
+;;; LREST (b)                                                        [FUNCTION]
+;;;
+;;; LPART (b)                                                        [FUNCTION]
+;;;
+;;; POLY-PRIMITIVE-PART (f)                                          [FUNCTION]
+;;;
+;;; POLY-CONTENT (f)                                                 [FUNCTION]
+;;;
Index: /trunk/doc/poly-with-sugar.txt
===================================================================
--- /trunk/doc/poly-with-sugar.txt	(revision 8)
+++ /trunk/doc/poly-with-sugar.txt	(revision 8)
@@ -0,0 +1,47 @@
+
+;;; POLY-WITH-SUGAR-POLY (p)                                         [FUNCTION]
+;;;
+;;; POLY-WITH-SUGAR-SUGAR (p)                                        [FUNCTION]
+;;;
+;;; POLY-WITH-SUGAR-TAIL (p)                                         [FUNCTION]
+;;;
+;;; (SETF POLY-WITH-SUGAR-POLY) (poly)                           [SETF MAPPING]
+;;;
+;;; (SETF POLY-WITH-SUGAR-SUGAR) (sugar)                         [SETF MAPPING]
+;;;
+;;; (SETF POLY-WITH-SUGAR-TAIL) (tail)                           [SETF MAPPING]
+;;;
+;;; MONOM-SUGAR (m)                                                  [FUNCTION]
+;;;
+;;; COEFFICIENT-SUGAR (c ring)                                       [FUNCTION]
+;;;
+;;; TERM-SUGAR (term ring)                                           [FUNCTION]
+;;;
+;;; POLY-ADD-SUGAR (poly ring)                                       [FUNCTION]
+;;;
+;;; SCALAR-TIMES-POLY-WITH-SUGAR (c p ring)                          [FUNCTION]
+;;;
+;;; TERM-TIMES-POLY-WITH-SUGAR (term f ring)                         [FUNCTION]
+;;;
+;;; MONOM-TIMES-POLY-WITH-SUGAR (m f)                                [FUNCTION]
+;;;
+;;; MINUS-POLY-WITH-SUGAR (f ring)                                   [FUNCTION]
+;;;
+;;; POLY-WITH-SUGAR+ (p q pred ring)                                 [FUNCTION]
+;;;
+;;; POLY-WITH-SUGAR- (p q pred ring)                                 [FUNCTION]
+;;;
+;;; POLY-WITH-SUGAR-OP (f term g pred ring)                          [FUNCTION]
+;;;
+;;; POLY-WITH-SUGAR-NREVERSE (p)                                     [FUNCTION]
+;;;
+;;; POLY-WITH-SUGAR-APPEND (p q)                                     [FUNCTION]
+;;;
+;;; POLY-WITH-SUGAR-ZEROP (p)                                        [FUNCTION]
+;;;
+;;; POLY-WITH-SUGAR-LM (p)                                           [FUNCTION]
+;;;
+;;; POLY-WITH-SUGAR-LC (p)                                           [FUNCTION]
+;;;
+;;; POLY-WITH-SUGAR-LT (p)                                           [FUNCTION]
+;;;
Index: /trunk/doc/poly.txt
===================================================================
--- /trunk/doc/poly.txt	(revision 8)
+++ /trunk/doc/poly.txt	(revision 8)
@@ -0,0 +1,77 @@
+
+;;; SCALAR-TIMES-POLY (c p &optional (ring *coefficient-ring*))      [FUNCTION]
+;;;    Return product of a scalar C by a polynomial P with coefficient ring
+;;;    RING. 
+;;;
+;;; TERM-TIMES-POLY (term f &optional (ring *coefficient-ring*))     [FUNCTION]
+;;;    Return product of a term TERM by a polynomial F with coefficient ring
+;;;    RING. 
+;;;
+;;; MONOM-TIMES-POLY (m f)                                           [FUNCTION]
+;;;    Return product of a monomial M by a polynomial F with coefficient
+;;;    ring RING. 
+;;;
+;;; MINUS-POLY (f &optional (ring *coefficient-ring*))               [FUNCTION]
+;;;    Changes the sign of a polynomial F with coefficients in coefficient
+;;;    ring RING, and returns the result.
+;;;
+;;; SORT-POLY (poly &optional (pred #'lex>) (start 0)                [FUNCTION]
+;;;            (end (unless (null poly) (length (caar poly)))))
+;;;    Destructively Sorts a polynomial POLY by predicate PRED; the
+;;;    predicate is assumed to take arguments START and END in addition to
+;;;    the pair of monomials, as the functions in the ORDER package do.
+;;;
+;;; POLY+ (p q &optional (pred #'lex>) (ring *coefficient-ring*))    [FUNCTION]
+;;;    Returns the sum of two polynomials P and Q with coefficients in
+;;;    ring RING, with terms ordered according to monomial order PRED.
+;;;
+;;; POLY- (p q &optional (pred #'lex>) (ring *coefficient-ring*))    [FUNCTION]
+;;;    Returns the difference of two polynomials P and Q with coefficients
+;;;    in ring RING, with terms ordered according to monomial order PRED.
+;;;
+;;; POLY* (p q &optional (pred #'lex>) (ring *coefficient-ring*))    [FUNCTION]
+;;;    Returns the product of two polynomials P and Q with coefficients in
+;;;    ring RING, with terms ordered according to monomial order PRED.
+;;;
+;;; POLY-OP (f m g pred ring)                                        [FUNCTION]
+;;;    Returns F-M*G, where F and G are polynomials with coefficients in
+;;;    ring RING, ordered according to monomial order PRED and M is a
+;;;    monomial.
+;;;
+;;; POLY-EXPT (poly n &optional (pred #'lex>)                        [FUNCTION]
+;;;            (ring *coefficient-ring*))
+;;;    Exponentiate a polynomial POLY to power N. The terms of the
+;;;    polynomial are assumed to be ordered by monomial order PRED and with
+;;;    coefficients in ring RING.  Use the Chinese algorithm; assume N>=0
+;;;    and POLY is non-zero (not NIL).
+;;;
+;;; POLY-MEXPT (plist monom &optional (pred #'lex>)                  [FUNCTION]
+;;;             (ring *coefficient-ring*))
+;;;    Raise a polynomial vector represented ad a list of polynomials
+;;;    PLIST to power MULTIINDEX.  Every polynomial has its terms ordered by
+;;;    predicate PRED and coefficients in the ring RING.
+;;;
+;;; POLY-CONSTANT-P (p)                                              [FUNCTION]
+;;;    Returns T if P is a constant polynomial.
+;;;
+;;; POLY-EXTEND (p &optional (m (list 0)))                           [FUNCTION]
+;;;    Given a polynomial P in k[x[r+1],...,xn], it returns the same
+;;;    polynomial as an element of k[x1,...,xn], optionally multiplying it
+;;;    by a monomial x1^m1*x2^m2*...*xr^mr, where m=(m1,m2,...,mr) is a
+;;;    multiindex.
+;;;
+;;; POLY-EXTEND-END (p &optional (m (list 0)))                       [FUNCTION]
+;;;    Similar to POLY-EXTEND, but it adds new variables at the end.
+;;;
+;;; POLY-ZEROP (p)                                                   [FUNCTION]
+;;;    Returns T if P is a zero polynomial.
+;;;
+;;; LT (p)                                                           [FUNCTION]
+;;;    Returns the leading term of a polynomial P.
+;;;
+;;; LM (p)                                                           [FUNCTION]
+;;;    Returns the leading monomial of a polynomial P.
+;;;
+;;; LC (p)                                                           [FUNCTION]
+;;;    Returns the leading coefficient of a polynomial P.
+;;;
Index: /trunk/doc/printer.txt
===================================================================
--- /trunk/doc/printer.txt	(revision 8)
+++ /trunk/doc/printer.txt	(revision 8)
@@ -0,0 +1,24 @@
+
+;;; POLY-PRINT (plist vars &optional (stream t))                     [FUNCTION]
+;;;    Prints a polynomial or  a list of polynomials PLIST using infix
+;;;    syntax compatible with most software systems. The following data
+;;;    representations are assumed: 1) Polynomial list is ([ poly1 poly2
+;;;    ...) 2) Polynomial is a list (term1 term2 ...)
+;;;    3) Term is (monom . number)
+;;;    4) Monom is (number1 number2 ...) and is a list of powers at
+;;;    corresponding variables
+;;;    Variable names must be provided to the printer explicitly.
+;;;
+;;; POLY-PRINT-1 (p vars &optional (stream t))                       [FUNCTION]
+;;;    An auxillary function of POLY-PRINT. It prints a single polynomial P.
+;;;
+;;; POLY-PRINT-2 (plist vars stream &optional (beg t))               [FUNCTION]
+;;;    An auxillary function of POLY-PRINT. It prints a comma-separated list
+;;;    of polynomials PLIST. 
+;;;
+;;; PRINT-TERM (l vars &optional (stream t) beg)                     [FUNCTION]
+;;;    An auxillary function of POLY-PRINT. It prints a single term L.
+;;;
+;;; PRINT-MONOM (l vars &optional (stream t) beg)                    [FUNCTION]
+;;;    An auxillary function of POLY-PRINT. It prints a single monomial L.
+;;;
Index: /trunk/doc/prover.txt
===================================================================
--- /trunk/doc/prover.txt	(revision 8)
+++ /trunk/doc/prover.txt	(revision 8)
@@ -0,0 +1,83 @@
+
+;;; *PROVER-ORDER* (#'grevlex>)                                      [VARIABLE]
+;;;    Admissible monomial order used internally in the proofs of theorems.
+;;;
+;;; CSYM (symbol number)                                             [FUNCTION]
+;;;    Return symbol whose name is a concatenation of (SYMBOL-NAME SYMBOL)
+;;;    and a number NUMBER.
+;;;
+;;; REAL-IDENTICAL-POINTS (a b)                                         [MACRO]
+;;;    Return [ (A1-B1)**2 + (A2-B2)**2 ] in lisp (prefix) notation.
+;;;    The second value is the list of variables (A1 B1 A2 B2). Note that
+;;;    if the distance between two complex points A, B is zero, it does not
+;;;    mean that the points are identical. Use IDENTICAL-POINTS to express
+;;;    the fact that A and B are really identical. Use this macro in
+;;;    conclusions of theorems, as it may not be possible to prove that A
+;;;    and B are trully identical in the complex domain.
+;;;
+;;; IDENTICAL-POINTS (a b)                                              [MACRO]
+;;;    Return [ A1-B1, A2-B2 ] in lisp (prefix) notation.
+;;;    The second value is the list of variables (A1 B1 A2 B2). Note that
+;;;    sometimes one is able to prove only that (A1-B1)**2 + (A2-B2)**2 = 0.
+;;;    This equation in the complex domain has solutions with A and B
+;;;    distinct. Use REAL-IDENTICAL-POINTS to express the fact that the
+;;;    distance between two points is 0. Use this macro in assumptions of
+;;;    theorems, although this is seldom necessary because we assume most of
+;;;    the time that in assumptions all points are distinct if they are
+;;;    denoted by different symbols. 
+;;;
+;;; PERPENDICULAR (a b c d)                                             [MACRO]
+;;;    Return [ (A1-B1) * (C1-D1) + (A2-B2) * (C2-D2) ] in lisp (prefix)
+;;;    notation. The second value is the list of variables (A1 A2 B1 B2 C1
+;;;    C2 D1 D2). 
+;;;
+;;; PARALLEL (a b c d)                                                  [MACRO]
+;;;    Return [ (A1-B1) * (C2-D2) - (A2-B2) * (C1-D1) ] in lisp (prefix)
+;;;    notation. The second value is the list of variables (A1 A2 B1 B2 C1
+;;;    C2 D1 D2). 
+;;;
+;;; COLLINEAR (a b c)                                                   [MACRO]
+;;;    Return the determinant det([[A1,A2,1],[B1,B2,1],[C1,C2,1]]) in lisp
+;;;    (prefix) notation. The second value is the list of variables (A1 A2
+;;;    B1 B2 C1 C2). 
+;;;
+;;; EQUIDISTANT (a b c d)                                               [MACRO]
+;;;    Return the polynomial [(A1-B1)**2+(A2-B2)**2-(C1-D1)**2-(C2-D2)**2]
+;;;    in lisp (prefix) notation. The second value is the list of variables
+;;;    (A1 A2 B1 B2 C1 C2 D1 D2). 
+;;;
+;;; EUCLIDEAN-DISTANCE (a b r)                                          [MACRO]
+;;;    Return the polynomial [(A1-B1)**2+(A2-B2)**2-R^2] in lisp (prefix)
+;;;    notation. The second value is the list of variables (A1 A2 B1 B2 R).
+;;;
+;;; MIDPOINT (a b c)                                                    [MACRO]
+;;;    Express the fact that C is a midpoint of the segment AB.
+;;;    Returns the list [ 2*C1-A1-B1, 2*C2-A2-B2 ]. The second value
+;;;    returned is the list of variables (A1 A2 B1 B2 C1 C2).
+;;;
+;;; TRANSLATE-STATEMENTS (&rest statements)                             [MACRO]
+;;;
+;;; TRANSLATE-ASSUMPTIONS (&rest assumptions)                           [MACRO]
+;;;
+;;; TRANSLATE-CONCLUSIONS (&rest conclusions)                           [MACRO]
+;;;
+;;; TRANSLATE-THEOREM ((&rest assumptions) (&rest conclusions))         [MACRO]
+;;;    Translates a planar geometry theorem into a system of polynomial
+;;;    equations. Each assumption or conclusion takes form of a declaration
+;;;    (RELATION-NAME A B C ...) where A B C are points, entered as symbols
+;;;    and RELATION-NAME is a name of a geometric relation, for example,
+;;;    (COLLINEAR A B C) means that points A, B, C are all collinear. The
+;;;    translated equations use the convention that (A1,A2) are the
+;;;    coordinates of the point A. This macro returns multiple values. The
+;;;    first value is a list of polynomial expressions and the second value
+;;;    is an automatically generated list of variables from points A, B, C,
+;;;    etc. For convenience, several macros have been defined in order to
+;;;    make specifying common geometric relations easy. 
+;;;
+;;; PROVE-THEOREM ((&rest assumptions) (&rest conclusions)              [MACRO]
+;;;                &key (order *prover-order*))
+;;;    Proves a geometric theorem, specified in the same manner as in
+;;;    the macro TRANSLATE-THEOREM. The proof is achieved by a call to
+;;;    IDEAL-POLYSATURATION. The theorem is true if the returned value
+;;;    is a trivial ideal containing 1.
+;;;
Index: /trunk/doc/rat.txt
===================================================================
--- /trunk/doc/rat.txt	(revision 8)
+++ /trunk/doc/rat.txt	(revision 8)
@@ -0,0 +1,34 @@
+
+;;; NUM (p)                                                          [FUNCTION]
+;;;
+;;; DENOM (p)                                                        [FUNCTION]
+;;;
+;;; RAT-SIMPLIFY-2 (num denom)                                       [FUNCTION]
+;;;
+;;; RAT-SIMPLIFY (p)                                                 [FUNCTION]
+;;;
+;;; RAT+ (p q)                                                       [FUNCTION]
+;;;
+;;; RAT- (p q)                                                       [FUNCTION]
+;;;
+;;; RAT* (p q)                                                       [FUNCTION]
+;;;
+;;; RAT/ (p q)                                                       [FUNCTION]
+;;;
+;;; SCALAR-TIMES-RAT (scalar p)                                      [FUNCTION]
+;;;
+;;; SCALAR-DIV-RAT (scalar p)                                        [FUNCTION]
+;;;
+;;; RAT-ZEROP (p)                                                    [FUNCTION]
+;;;
+;;; RAT-UMINUS (p)                                                   [FUNCTION]
+;;;
+;;; RAT-EXPT (p n)                                                   [FUNCTION]
+;;;
+;;; RAT-CONSTANT (c n)                                               [FUNCTION]
+;;;    Make a constant rational function equal to c with n variables
+;;;
+;;; RAT-TO-POLY (p)                                                  [FUNCTION]
+;;;    Attempt to convert a rational function to a polynomial by
+;;;    dividing numerator by denominator. Error if not divisible
+;;;
Index: /trunk/doc/ratpoly.txt
===================================================================
--- /trunk/doc/ratpoly.txt	(revision 8)
+++ /trunk/doc/ratpoly.txt	(revision 8)
@@ -0,0 +1,67 @@
+
+;;; RATPOLY+ (p q)                                                   [FUNCTION]
+;;;    Add polynomials P and Q.
+;;;
+;;; RATPOLY- (p q)                                                   [FUNCTION]
+;;;
+;;; RATPOLY-UMINUS (p)                                               [FUNCTION]
+;;;
+;;; RATPOLY* (p q)                                                   [FUNCTION]
+;;;    Multiply polynomials P and Q.
+;;;
+;;; SCALAR-TIMES-RATPOLY (scalar p)                                  [FUNCTION]
+;;;    Multiply scalar SCALAR by a polynomial P.
+;;;
+;;; RAT-TIMES-RATPOLY (scalar p)                                     [FUNCTION]
+;;;    Multiply rational function SCALAR by a polynomial P.
+;;;
+;;; RATPOLY-DIVIDE (f g)                                             [FUNCTION]
+;;;    Divide polynomial F by G. Return quotient and remainder as multiple
+;;;    values. 
+;;;
+;;; RATPOLY-REMAINDER (f g)                                          [FUNCTION]
+;;;    The remainder of the division of a polynomial F by G.
+;;;
+;;; RATPOLY-GCD (f g)                                                [FUNCTION]
+;;;    Return GCD of polynomials F and G.
+;;;
+;;; RATPOLY-DIFF (f)                                                 [FUNCTION]
+;;;    Differentiate a polynomial.
+;;;
+;;; RATPOLY-SQUARE-FREE (f)                                          [FUNCTION]
+;;;    Return the square-free part of a polynomial F.
+;;;
+;;; RATPOLY-NORMALIZE (f)                                            [FUNCTION]
+;;;    Divide a non-zero polynomial by the coefficient at the highest power.
+;;;
+;;; RATPOLY-RESULTANT (f g)                                          [FUNCTION]
+;;;    Return the resultant of polynomials F and G.
+;;;
+;;; DEG (s)                                                          [FUNCTION]
+;;;
+;;; LEAD (s)                                                         [FUNCTION]
+;;;
+;;; RATPOLY-DISCRIMINANT (p &aux (l (deg p)))                        [FUNCTION]
+;;;    The discriminant of a polynomial P.
+;;;
+;;; RATPOLY-PRINT (p vars &optional (stream t) (beg t) (p-orig p))   [FUNCTION]
+;;;
+;;; POLY-TO-RATPOLY (p)                                              [FUNCTION]
+;;;
+;;; POLY-TO-POLY1 (p &aux (htab (make-hash-table)) q)                [FUNCTION]
+;;;
+;;; POLY1-TO-RATPOLY (p)                                             [FUNCTION]
+;;;
+;;; RATPOLY-TO-POLY1 (p)                                             [FUNCTION]
+;;;    Convert every coefficient of ratpoly to polynomial if possible
+;;;
+;;; POLY1-TO-POLY (p)                                                [FUNCTION]
+;;;    Convert a ratpoly, whose coeffs have been converted to poly,
+;;;    into a poly structure, i.e. tack in powers of first variable.
+;;;
+;;; RATPOLY-TO-POLY (p)                                              [FUNCTION]
+;;;
+;;; POLY-RESULTANT (f g)                                             [FUNCTION]
+;;;    Calculate resultant of F and G given in poly i.e. alist
+;;;    representation. 
+;;;
Index: /trunk/doc/string-grobner.txt
===================================================================
--- /trunk/doc/string-grobner.txt	(revision 8)
+++ /trunk/doc/string-grobner.txt	(revision 8)
@@ -0,0 +1,110 @@
+
+;;; STRING-NORMAL-FORM (f fl vars &key (stream t) (print t)          [FUNCTION]
+;;;                     (order #'lex>) (top-reduction-only nil)
+;;;                     (ring *coefficient-ring*) (suppress-value t)
+;;;                     &aux (vars (read-vars vars)))
+;;;
+;;; STRING-GROBNER (plist vars &key (order #'lex>) (start 0)         [FUNCTION]
+;;;                 (stream t) (reduce t) (reduce-before t)
+;;;                 (suppress-value t) (top-reduction-only nil)
+;;;                 (ring *coefficient-ring*) (print t)
+;;;                 &aux (vars (read-vars vars)))
+;;;
+;;; STRING-ELIMINATION-IDEAL (flist vars k &key (stream t)           [FUNCTION]
+;;;                           (key #'identity)
+;;;                           (primary-order #'grevlex>)
+;;;                           (secondary-order #'grevlex>)
+;;;                           (suppress-value t)
+;;;                           (order
+;;;                           (elimination-order k :primary-order
+;;;                           primary-order :secondary-order
+;;;                           secondary-order))
+;;;                           &aux (vars (read-vars vars)))
+;;;
+;;; STRING-IDEAL-INTERSECTION (f g vars &key (order #'lex>)          [FUNCTION]
+;;;                            (top-reduction-only nil)
+;;;                            (ring *coefficient-ring*) (stream t)
+;;;                            (suppress-value t)
+;;;                            &aux (vars (read-vars vars)) (f
+;;;                            (parse-string-to-sorted-alist f vars
+;;;                            order))
+;;;                            (g
+;;;                            (parse-string-to-sorted-alist g vars
+;;;                            order)))
+;;;
+;;; STRING-POLY-LCM (f g vars &key (order #'lex>)                    [FUNCTION]
+;;;                  (ring *coefficient-ring*) (stream t)
+;;;                  (suppress-value t) &aux (vars (read-vars vars))
+;;;                  (f (parse-string-to-sorted-alist f vars order))
+;;;                  (g
+;;;                  (parse-string-to-sorted-alist g vars order)))
+;;;
+;;; STRING-IDEAL-SATURATION-1 (f p vars &key (order #'lex>)          [FUNCTION]
+;;;                            (start 0) (top-reduction-only nil)
+;;;                            (ring *coefficient-ring*) (stream t)
+;;;                            (suppress-value t)
+;;;                            &aux (vars (read-vars vars)) (f
+;;;                            (parse-string-to-sorted-alist f vars
+;;;                            order))
+;;;                            (p
+;;;                            (parse-string-to-sorted-alist p vars
+;;;                            order)))
+;;;
+;;; STRING-IDEAL-POLYSATURATION-1 (f plist vars &key (order #'lex>)  [FUNCTION]
+;;;                                (start 0)
+;;;                                (top-reduction-only nil)
+;;;                                (ring *coefficient-ring*)
+;;;                                (stream t) (suppress-value t)
+;;;                                &aux (vars (read-vars vars)) (f
+;;;                                (parse-string-to-sorted-alist f
+;;;                                vars order))
+;;;                                (plist
+;;;                                (parse-string-to-sorted-alist
+;;;                                plist vars order)))
+;;;
+;;; STRING-IDEAL-SATURATION (f g vars &key (order #'lex>) (start 0)  [FUNCTION]
+;;;                          (top-reduction-only nil)
+;;;                          (ring *coefficient-ring*) (stream t)
+;;;                          (suppress-value t)
+;;;                          &aux (vars (read-vars vars)) (f
+;;;                          (parse-string-to-sorted-alist f vars
+;;;                          order))
+;;;                          (g
+;;;                          (parse-string-to-sorted-alist g vars
+;;;                          order)))
+;;;
+;;; STRING-IDEAL-POLYSATURATION (f ideal-list vars                   [FUNCTION]
+;;;                              &key (order #'lex>) (start 0)
+;;;                              (top-reduction-only nil)
+;;;                              (ring *coefficient-ring*)
+;;;                              (stream t) (suppress-value t)
+;;;                              &aux (vars (read-vars vars)) (f
+;;;                              (parse-string-to-sorted-alist f
+;;;                              vars order))
+;;;                              (ideal-list (mapcar #'(lambda (g)
+;;;                              (parse-string-to-sorted-alist g
+;;;                              vars order)) ideal-list)))
+;;;
+;;; STRING-COLON-IDEAL (f g vars &key (top-reduction-only nil)       [FUNCTION]
+;;;                     (ring *coefficient-ring*) (stream t)
+;;;                     (order #'lex>) (suppress-value t)
+;;;                     &aux (vars (read-vars vars)) (f
+;;;                     (parse-string-to-sorted-alist f vars order))
+;;;                     (g
+;;;                     (parse-string-to-sorted-alist g vars
+;;;                     order)))
+;;;
+;;; STRING-READ-POLY (f vars &key (order #'lex>)                     [FUNCTION]
+;;;                   (suppress-value nil) (stream t)
+;;;                   (convert-rational-to-integer t)
+;;;                   &aux (vars (read-vars vars)) (f
+;;;                   (parse-string-to-sorted-alist f vars order)))
+;;;
+;;; POLY-RATIONAL-TO-INTEGER (p                                      [FUNCTION]
+;;;                           &optional (ring *coefficient-ring*))
+;;;
+;;; READ-VARS (string-or-list)                                       [FUNCTION]
+;;;    Read a list of variables, specified either as a list of symbols or a
+;;;    string listing variables in the form of a comma-separated list,
+;;;    delimited by [,] 
+;;;
Index: /trunk/doc/term.txt
===================================================================
--- /trunk/doc/term.txt	(revision 8)
+++ /trunk/doc/term.txt	(revision 8)
@@ -0,0 +1,17 @@
+
+;;; TERM* (term1 term2 &optional (ring *coefficient-ring*))          [FUNCTION]
+;;;
+;;; TERM/ (term1 term2 &optional (ring *coefficient-ring*))          [FUNCTION]
+;;;
+;;; MONOM-TIMES-TERM (m term)                                        [FUNCTION]
+;;;
+;;; TERM-DIVIDES-P (term1 term2)                                     [FUNCTION]
+;;;
+;;; TERM-MONOM (term)                                                   [MACRO]
+;;;
+;;; TERM-COEFFICIENT (term)                                             [MACRO]
+;;;
+;;; (SETF TERM-MONOM) (monom)                                    [SETF MAPPING]
+;;;
+;;; (SETF TERM-COEFFICIENT) (coefficient)                        [SETF MAPPING]
+;;;
Index: /trunk/doc/xgcd.txt
===================================================================
--- /trunk/doc/xgcd.txt	(revision 8)
+++ /trunk/doc/xgcd.txt	(revision 8)
@@ -0,0 +1,11 @@
+
+;;; XGCD (x y)                                                       [FUNCTION]
+;;;    Extended gcd; the call
+;;;         (xgcd X Y)
+;;;    returns a multiple value list:
+;;;    - GCD
+;;;    - U,V  such that they solve the equation
+;;;        GCD=U*X+V*Y
+;;;    - U1,V1 such that
+;;;        LCM=U1*X=V1*Y (up to the sign).
+;;;
Index: /trunk/examples/TAGS
===================================================================
--- /trunk/examples/TAGS	(revision 8)
+++ /trunk/examples/TAGS	(revision 8)
@@ -0,0 +1,125 @@
+
+
+alt.lisp,0
+
+
+alt2.lisp,0
+
+
+alt3.lisp,0
+
+
+apollonius.lisp,0
+
+
+apollonius0.lisp,0
+
+
+apollonius2.lisp,0
+
+
+apollonius3.lisp,0
+
+
+bifurcation.lisp,252
+(defun f-composition 12,345
+(defun g 16,471
+(defun df 17,529
+(defun ideal 19,581
+(defun print-ideal 21,632
+(defun bifurcation 23,706
+(defun resultant-bifurcation 26,790
+(defun print-bifurcation 29,885
+(defun print-resultant-bifurcation 33,973
+
+
+billiard0.lisp,0
+
+
+billiard1.lisp,0
+
+
+billiard2.lisp,0
+
+
+chemistry.lisp,0
+
+
+euler.lisp,0
+
+
+euler2.lisp,0
+
+
+galois3.lisp,0
+
+
+henon-bifurcation.lisp,210
+(defun f-composition 19,524
+(defun g 23,656
+(defun f-jacobian 25,756
+(defun flip-value 27,858
+(defun ideal 33,1021
+(defun print-ideal 35,1068
+(defun bifurcation 37,1146
+(defun print-bifurcation 43,1282
+
+
+klee.lisp,0
+
+
+klee2.lisp,0
+
+
+klee3.lisp,0
+
+
+midpoints.lisp,0
+
+
+pappus.lisp,0
+
+
+pappus0.lisp,0
+
+
+pappus2.lisp,0
+
+
+pappus3.lisp,0
+
+
+pappus4.lisp,0
+
+
+parallelogram.lisp,0
+
+
+pilgrim1.lisp,0
+
+
+pilgrim2.lisp,0
+
+
+pilgrim3.lisp,0
+
+
+prover-apollonius.lisp,0
+
+
+robot.lisp,0
+
+
+robot2.lisp,0
+
+
+shash2.lisp,0
+
+
+shosh.lisp,0
+
+
+trisector.lisp,0
+
+
+trisector2.lisp,0
Index: /trunk/examples/alt
===================================================================
--- /trunk/examples/alt	(revision 8)
+++ /trunk/examples/alt	(revision 8)
@@ -0,0 +1,2 @@
+
+[U1*Y-V1*X,-X2*Y+U2*Y+V2*X2-V2*X,X*Y3-U3*Y3-X3*Y+U3*Y+V3*X3-V3*X,V1*Y3+U1*X3-U1*X2,V2*Y3-X2*X3+U2*X3,U3*X2-X2*X3];
Index: /trunk/examples/alt.lisp
===================================================================
--- /trunk/examples/alt.lisp	(revision 8)
+++ /trunk/examples/alt.lisp	(revision 8)
@@ -0,0 +1,9 @@
+;; This is supposed to prove that the 3 altitudes of a triangle
+;; intersect at a single point
+(string-grobner-system
+"[U1*Y-V1*X,-X2*Y+U2*Y+V2*X2-V2*X,X*Y3-U3*Y3-X3*Y+U3*Y+V3*X3-V3*X,V1*Y3+U1*X3-U1*X2,V2*Y3-X2*X3+U2*X3,U3*X2-X2*X3]"
+'(x y u1 v1 u2 v2 u3 v3)
+'(x2 x3 y3)
+:main-order #'lex>
+:parameter-order #'grevlex>)
+
Index: /trunk/examples/alt.macsyma
===================================================================
--- /trunk/examples/alt.macsyma	(revision 8)
+++ /trunk/examples/alt.macsyma	(revision 8)
@@ -0,0 +1,22 @@
+if get('geometry,'version)=false then load(geometry);
+x1:0;
+y1:0;
+y2:0;
+
+/* Triangle */
+A:[x1,y1];
+B:[x2,y2];
+C:[x3,y3];
+M:[x,y];
+P:[u1,v1];
+Q:[u2,v2];
+R:[u3,v3];
+eqns:[
+	collinear(M,A,P),
+	collinear(M,B,Q),
+	collinear(M,C,R),
+	perp(A,P,B,C),
+	perp(B,Q,A,C),
+	perp(C,R,A,B)
+];
+
Index: /trunk/examples/alt.result
===================================================================
--- /trunk/examples/alt.result	(revision 8)
+++ /trunk/examples/alt.result	(revision 8)
@@ -0,0 +1,49 @@
+>(load "alt")
+Loading alt.lisp
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [ X2, X3, Y3 ]
+  Red list: [  ]
+ Basis: [ ( - 1) * X * V1 + (1) * Y * U1, ( - 1) * X * V2 + (1) * Y * U2, ( - 1) * X * V3 + (1) * Y * U3, ( - 1) * Y * U2 * V3 + (1) * Y * V2 * U3, ( - 1) * Y * U1 * V3 + (1) * Y * V1 * U3, ( - 1) * Y * U1 * V2 + (1) * Y * V1 * U2 ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [ X2, X3 ]
+  Red list: [ Y3 ]
+ Basis: [ ( - 1) * X * V3 + (Y3) * X + (1) * Y * U3 + ( - Y3) * U3, (Y3) * V1, (Y3) * V2, (Y3) * Y * U2, ( - Y3) * Y * U1 ]
+------------------- CASE 3 -------------------
+Condition:
+  Green list: [ X2 ]
+  Red list: [ X2 - X3, X3 ]
+ Basis: [ (X3) * X * V1 + (Y3) * Y * V1, ( - X3) * X * V2 + ( - Y3) * Y * V2, ( - 1) * X * V3 + (Y3) * X + (1) * Y * U3 + ( - X3) * Y + ( - Y3) * U3 + (X3) * V3, (X3) * U1 + (Y3) * V1, (X3) * U2 + (Y3) * V2, (X3) * Y * V2 * U3 + (Y3) * Y * V2 * V3 + ( - X3^2 - Y3^2) * Y * V2 + ( - X3 * Y3) * V2 * U3 + (X3^2) * V2 * V3, ( - X3) * Y * V1 * U3 + ( - Y3) * Y * V1 * V3 + (X3^2 + Y3^2) * Y * V1 + (X3 * Y3) * V1 * U3 + ( - X3^2) * V1 * V3 ]
+------------------- CASE 4 -------------------
+Condition:
+  Green list: [ X3, Y3 ]
+  Red list: [ X2, X2 - X3 ]
+ Basis: [ ( - X2) * X * V1, ( - 1) * X * V2 + (1) * Y * U2 + ( - X2) * Y + (X2) * V2, (X2) * X * V3, ( - X2) * U1, (X2) * U3, (X2) * Y * U2 * V3 + ( - X2^2) * Y * V3 + (X2^2) * V2 * V3, ( - X2) * Y * V1 * U2 + (X2^2) * Y * V1 + ( - X2^2) * V1 * V2 ]
+------------------- CASE 5 -------------------
+Condition:
+  Green list: [ X3 ]
+  Red list: [ Y3, X2, X2 - X3 ]
+ Basis: [ ( - X2) * X * V1 + (Y3) * Y * V1, (X2) * X * V3 + ( - X2 * Y3) * X, ( - X2) * U1 + (Y3) * V1, (Y3) * V2, (X2) * U3, (Y3) * Y * U2 + ( - X2 * Y3) * Y, (X2 * Y3) * Y * V1 * V3 + ( - X2 * Y3^2) * Y * V1 ]
+------------------- CASE 6 -------------------
+Condition:
+  Green list: [ X2 - X3, Y3 ]
+  Red list: [ X3, X2 ]
+ Basis: [ ( - 1) * X * V1 + (1) * Y * U1, ( - X3) * X * V2 + (X3^2) * V2, (X3) * X * V3 + ( - X3^2) * V3, (X3) * U2 + ( - X3^2), (X3) * U3 + ( - X3^2), (X3) * Y * U1 * V3 + ( - X3^2) * V1 * V3, ( - X3) * Y * U1 * V2 + (X3^2) * V1 * V2 ]
+------------------- CASE 7 -------------------
+Condition:
+  Green list: [ X2 - X3 ]
+  Red list: [ Y3, X2, X3 ]
+ Basis: [ ( - X3) * X * V2 + ( - Y3) * Y * V2 + (X3^2) * V2, (X3) * X * V3 + ( - X3 * Y3) * X + ( - X3^2) * V3 + (X3^2 * Y3), (Y3) * V1, (X3) * U2 + (Y3) * V2 + ( - X3^2), (X3) * U3 + ( - X3^2), ( - Y3) * Y * U1, ( - X3 * Y3) * Y * V2 * V3 + (X3 * Y3^2) * Y * V2 ]
+------------------- CASE 8 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ X2, Y3, X3, X2 - X3 ]
+ Basis: [ ( - X2 + X3) * X * V1 + (Y3) * Y * V1, ( - X3) * X * V2 + ( - Y3) * Y * V2 + (X2 * X3) * V2, (X2) * X * V3 + ( - X2 * Y3) * X + ( - X2 * X3) * V3 + (X2 * X3 * Y3), ( - X2 + X3) * U1 + (Y3) * V1, (X3) * U2 + (Y3) * V2 + ( - X2 * X3), (X2) * U3 + ( - X2 * X3), ( - X2 * Y3) * Y * V2 * V3 + (X2 * Y3^2) * Y * V2 + (X2^2 * X3 - X2 * X3^2) * V2 * V3 + ( - X2^2 * X3 * Y3 + X2 * X3^2 * Y3) * V2, (X2 * Y3) * Y * V1 * V3 + ( - X2 * Y3^2) * Y * V1 + ( - X2^2 * X3 + X2 * X3^2) * V1 * V3 + (X2^2 * X3 * Y3 - X2 * X3^2 * Y3) * V1, ( - X2 * Y3) * Y * V1 * V2 + (X2^2 * X3 - X2 * X3^2) * V1 * V2 ]
+------------------- CASE 9 -------------------
+Condition:
+  Green list: [ Y3 ]
+  Red list: [ X2, X3, X2 - X3 ]
+ Basis: [ ( - X2 + X3) * X * V1, ( - X3) * X * V2 + (X2 * X3) * V2, (X2) * X * V3 + ( - X2 * X3) * V3, ( - X2 + X3) * U1, (X3) * U2 + ( - X2 * X3), (X2) * U3 + ( - X2 * X3), (X2^2 * X3 - X2 * X3^2) * V2 * V3, ( - X2^2 * X3 + X2 * X3^2) * V1 * V3, (X2^2 * X3 - X2 * X3^2) * V1 * V2 ]
+Finished loading alt.lisp
+T
Index: /trunk/examples/alt2.lisp
===================================================================
--- /trunk/examples/alt2.lisp	(revision 8)
+++ /trunk/examples/alt2.lisp	(revision 8)
@@ -0,0 +1,12 @@
+;; This is supposed to prove that the 3 altitudes of a triangle
+;; intersect at a single point; if consistent, then the altitudes have
+;; a common point (x,y). Only x3 y3 are treated as parameters, i.e.
+;; we vary only one vertex; adding all three vertices produces 6 parameters,
+;; too much to swallow for the software
+(string-grobner-system
+"[X*Y1-U1*Y1-X1*Y+U1*Y+V1*X1-V1*X,X*Y2-U2*Y2-X2*Y+U2*Y+V2*X2-V2*X,X*Y3-U3*Y3-X3*Y+U3*Y+V3*X3-V3*X,-Y1*Y3+V1*Y3+Y1*Y2-V1*Y2-X1*X3+U1*X3+X1*X2-U1*X2,-Y2*Y3+V2*Y3+Y1*Y2-V2*Y1-X2*X3+U2*X3+X1*X2-U2*X1,-Y2*Y3+Y1*Y3+V3*Y2-V3*Y1-X2*X3+X1*X3+U3*X2-U3*X1]"
+'(x y u1 v1 u2 v2 u3 v3 x1 y1 x2 y2)
+'(x3 y3)
+:main-order #'lex>
+:parameter-order #'lex>)
+
Index: /trunk/examples/alt2.result
===================================================================
--- /trunk/examples/alt2.result	(revision 8)
+++ /trunk/examples/alt2.result	(revision 8)
@@ -0,0 +1,11 @@
+>(load "alt2")
+Loading alt2.lisp
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [  ]
+ Basis: [ ( - 1) * X * V1 + (1) * X * Y1 + (1) * Y * U1 + ( - 1) * Y * X1 + ( - 1) * U1 * Y1 + (1) * V1 * X1, ( - 1) * X * V2 + (1) * X * Y2 + (1) * Y * U2 + ( - 1) * Y * X2 + ( - 1) * U2 * Y2 + (1) * V2 * X2, ( - 1) * X * V3 + (Y3) * X + (1) * Y * U3 + ( - X3) * Y + ( - Y3) * U3 + (X3) * V3, ( - 1) * U1 * X2 + (X3) * U1 + ( - 1) * V1 * Y2 + (Y3) * V1 + (1) * X1 * X2 + ( - X3) * X1 + (1) * Y1 * Y2 + ( - Y3) * Y1, ( - 1) * U2 * X1 + (X3) * U2 + ( - 1) * V2 * Y1 + (Y3) * V2 + (1) * X1 * X2 + (1) * Y1 * Y2 + ( - X3) * X2 + ( - Y3) * Y2, ( - 1) * U3 * X1 + (1) * U3 * X2 + ( - 1) * V3 * Y1 + (1) * V3 * Y2 + (X3) * X1 + (Y3) * Y1 + ( - X3) * X2 + ( - Y3) * Y2, ( - 1) * U2 * U3 * X2 + (X3) * U2 * U3 + (1) * U2 * V3 * Y1 + ( - 1) * U2 * V3 * Y2 + ( - Y3) * U2 * Y1 + (X3) * U2 * X2 + (Y3) * U2 * Y2 + ( - X3^2) * U2 + ( - 1) * V2 * U3 * Y1 + (Y3) * V2 * U3 + (X3) * V2 * Y1 + ( - X3 * Y3) * V2 + (1) * U3 * Y1 * Y2 + (1) * U3 * X2^2 + ( - X3) * U3 * X2 + ( - Y3) * U3 * Y2 + ( - 1) * V3 * Y1 * X2 + (1) * V3 * X2 * Y2 + (Y3) * Y1 * X2 + ( - X3) * Y1 * Y2 + ( - X3) * X2^2 + ( - Y3) * X2 * Y2 + (X3^2) * X2 + (X3 * Y3) * Y2, (1) * Y * U2 * V3 + ( - Y3) * Y * U2 + ( - 1) * Y * V2 * U3 + (X3) * Y * V2 + (1) * Y * U3 * Y2 + ( - 1) * Y * V3 * X2 + (Y3) * Y * X2 + ( - X3) * Y * Y2 + ( - 1) * U2 * V3 * Y2 + (Y3) * U2 * Y2 + (Y3) * V2 * U3 + (1) * V2 * V3 * X2 + ( - X3) * V2 * V3 + ( - Y3) * V2 * X2 + ( - Y3) * U3 * Y2 + (X3) * V3 * Y2, (1) * Y * U1 * V3 + ( - Y3) * Y * U1 + ( - 1) * Y * V1 * U3 + (X3) * Y * V1 + (1) * Y * U3 * Y1 + ( - 1) * Y * V3 * X1 + (Y3) * Y * X1 + ( - X3) * Y * Y1 + ( - 1) * U1 * V3 * Y1 + (Y3) * U1 * Y1 + (Y3) * V1 * U3 + (1) * V1 * V3 * X1 + ( - X3) * V1 * V3 + ( - Y3) * V1 * X1 + ( - Y3) * U3 * Y1 + (X3) * V3 * Y1, (1) * Y * U1 * V2 + ( - 1) * Y * U1 * Y2 + ( - 1) * Y * V1 * U2 + (1) * Y * V1 * X2 + (1) * Y * U2 * Y1 + ( - 1) * Y * V2 * X1 + (1) * Y * X1 * Y2 + ( - 1) * Y * Y1 * X2 + ( - 1) * U1 * V2 * Y1 + (1) * U1 * Y1 * Y2 + (1) * V1 * U2 * Y2 + (1) * V1 * V2 * X1 + ( - 1) * V1 * V2 * X2 + ( - 1) * V1 * X1 * Y2 + ( - 1) * U2 * Y1 * Y2 + (1) * V2 * Y1 * X2, ( - 1) * U1 * U2 * V3 * Y1 + (1) * U1 * U2 * V3 * Y2 + (Y3) * U1 * U2 * Y1 + ( - Y3) * U1 * U2 * Y2 + (1) * U1 * V2 * U3 * Y1 + ( - Y3) * U1 * V2 * U3 + ( - X3) * U1 * V2 * Y1 + (X3 * Y3) * U1 * V2 + ( - 1) * U1 * U3 * Y1 * Y2 + (Y3) * U1 * U3 * Y2 + (X3) * U1 * V3 * Y1 + ( - X3) * U1 * V3 * Y2 + (X3) * U1 * Y1 * Y2 + ( - X3 * Y3) * U1 * Y1 + ( - 1) * V1 * U2 * U3 * Y2 + (Y3) * V1 * U2 * U3 + (X3) * V1 * U2 * Y2 + ( - X3 * Y3) * V1 * U2 + (1) * V1 * U3 * X2 * Y2 + ( - Y3) * V1 * U3 * X2 + ( - 1) * V1 * V3 * Y1 * Y2 + (Y3) * V1 * V3 * Y1 + (1) * V1 * V3 * Y2^2 + ( - Y3) * V1 * V3 * Y2 + (Y3) * V1 * Y1 * Y2 + ( - Y3^2) * V1 * Y1 + ( - X3) * V1 * X2 * Y2 + (X3 * Y3) * V1 * X2 + ( - Y3) * V1 * Y2^2 + (Y3^2) * V1 * Y2 + (1) * U2 * U3 * Y1 * Y2 + ( - Y3) * U2 * U3 * Y1 + (X3) * U2 * V3 * Y1 + ( - X3) * U2 * V3 * Y2 + ( - X3) * U2 * Y1 * Y2 + (X3 * Y3) * U2 * Y2 + ( - 1) * V2 * U3 * Y1 * X2 + (Y3) * V2 * U3 * X2 + (X3) * V2 * Y1 * X2 + ( - X3 * Y3) * V2 * X2 + (Y3) * U3 * Y1 * X2 + ( - Y3) * U3 * X2 * Y2 + (1) * V3 * X1 * Y1 * X2 + ( - X3) * V3 * X1 * Y1 + ( - 1) * V3 * X1 * X2 * Y2 + (X3) * V3 * X1 * Y2 + (1) * V3 * Y1^2 * Y2 + ( - Y3) * V3 * Y1^2 + ( - X3) * V3 * Y1 * X2 + ( - 1) * V3 * Y1 * Y2^2 + (Y3) * V3 * Y1 * Y2 + (X3) * V3 * X2 * Y2 + ( - Y3) * X1 * Y1 * X2 + (X3 * Y3) * X1 * Y1 + (Y3) * X1 * X2 * Y2 + ( - X3 * Y3) * X1 * Y2 + ( - Y3) * Y1^2 * Y2 + (Y3^2) * Y1^2 + (Y3) * Y1 * Y2^2 + ( - Y3^2) * Y1 * Y2, (1) * Y * V2 * U3 * X2 + ( - X3) * Y * V2 * U3 + (1) * Y * V2 * V3 * Y2 + ( - Y3) * Y * V2 * V3 + ( - X3) * Y * V2 * X2 + ( - Y3) * Y * V2 * Y2 + (X3^2 + Y3^2) * Y * V2 + ( - 1) * Y * U3 * X2 * Y2 + (X3) * Y * U3 * Y2 + ( - 1) * Y * V3 * Y2^2 + (Y3) * Y * V3 * Y2 + (X3) * Y * X2 * Y2 + (Y3) * Y * Y2^2 + ( - X3^2 - Y3^2) * Y * Y2 + ( - Y3) * V2 * U3 * X2 + (X3 * Y3) * V2 * U3 + ( - 1) * V2 * V3 * X1 * X2 + (X3) * V2 * V3 * X1 + ( - 1) * V2 * V3 * Y1 * Y2 + (Y3) * V2 * V3 * Y1 + (X3) * V2 * V3 * X2 + ( - X3^2) * V2 * V3 + (Y3) * V2 * X1 * X2 + ( - X3 * Y3) * V2 * X1 + (Y3) * V2 * Y1 * Y2 + ( - Y3^2) * V2 * Y1 + (Y3) * U3 * X2 * Y2 + ( - X3 * Y3) * U3 * Y2 + (1) * V3 * X1 * X2 * Y2 + ( - X3) * V3 * X1 * Y2 + (1) * V3 * Y1 * Y2^2 + ( - Y3) * V3 * Y1 * Y2 + ( - X3) * V3 * X2 * Y2 + (X3^2) * V3 * Y2 + ( - Y3) * X1 * X2 * Y2 + (X3 * Y3) * X1 * Y2 + ( - Y3) * Y1 * Y2^2 + (Y3^2) * Y1 * Y2, ( - 1) * Y * V1 * U3 * X2 + (X3) * Y * V1 * U3 + ( - 1) * Y * V1 * V3 * Y2 + (Y3) * Y * V1 * V3 + (X3) * Y * V1 * X2 + (Y3) * Y * V1 * Y2 + ( - X3^2 - Y3^2) * Y * V1 + (1) * Y * U3 * Y1 * X2 + ( - X3) * Y * U3 * Y1 + (1) * Y * V3 * Y1 * Y2 + ( - Y3) * Y * V3 * Y1 + ( - X3) * Y * Y1 * X2 + ( - Y3) * Y * Y1 * Y2 + (X3^2 + Y3^2) * Y * Y1 + (Y3) * V1 * U3 * X2 + ( - X3 * Y3) * V1 * U3 + (1) * V1 * V3 * X1 * X2 + ( - X3) * V1 * V3 * X1 + (1) * V1 * V3 * Y1 * Y2 + ( - Y3) * V1 * V3 * Y1 + ( - X3) * V1 * V3 * X2 + (X3^2) * V1 * V3 + ( - Y3) * V1 * X1 * X2 + (X3 * Y3) * V1 * X1 + ( - Y3) * V1 * Y1 * Y2 + (Y3^2) * V1 * Y1 + ( - Y3) * U3 * Y1 * X2 + (X3 * Y3) * U3 * Y1 + ( - 1) * V3 * X1 * Y1 * X2 + (X3) * V3 * X1 * Y1 + ( - 1) * V3 * Y1^2 * Y2 + (Y3) * V3 * Y1^2 + (X3) * V3 * Y1 * X2 + ( - X3^2) * V3 * Y1 + (Y3) * X1 * Y1 * X2 + ( - X3 * Y3) * X1 * Y1 + (Y3) * Y1^2 * Y2 + ( - Y3^2) * Y1^2, ( - 1) * Y * V1 * U2 * X2 + (X3) * Y * V1 * U2 + ( - 1) * Y * V1 * V2 * Y2 + (Y3) * Y * V1 * V2 + (1) * Y * V1 * X2^2 + ( - X3) * Y * V1 * X2 + (1) * Y * V1 * Y2^2 + ( - Y3) * Y * V1 * Y2 + (1) * Y * U2 * Y1 * X2 + ( - X3) * Y * U2 * Y1 + (1) * Y * V2 * Y1 * Y2 + ( - Y3) * Y * V2 * Y1 + ( - 1) * Y * Y1 * X2^2 + (X3) * Y * Y1 * X2 + ( - 1) * Y * Y1 * Y2^2 + (Y3) * Y * Y1 * Y2 + (1) * V1 * U2 * X2 * Y2 + ( - X3) * V1 * U2 * Y2 + (1) * V1 * V2 * X1 * X2 + ( - X3) * V1 * V2 * X1 + (1) * V1 * V2 * Y1 * Y2 + ( - Y3) * V1 * V2 * Y1 + ( - 1) * V1 * V2 * X2^2 + (X3) * V1 * V2 * X2 + ( - 1) * V1 * X1 * X2 * Y2 + (X3) * V1 * X1 * Y2 + ( - 1) * V1 * Y1 * Y2^2 + (Y3) * V1 * Y1 * Y2 + ( - 1) * U2 * Y1 * X2 * Y2 + (X3) * U2 * Y1 * Y2 + ( - 1) * V2 * X1 * Y1 * X2 + (X3) * V2 * X1 * Y1 + ( - 1) * V2 * Y1^2 * Y2 + (Y3) * V2 * Y1^2 + (1) * V2 * Y1 * X2^2 + ( - X3) * V2 * Y1 * X2 + (1) * X1 * Y1 * X2 * Y2 + ( - X3) * X1 * Y1 * Y2 + (1) * Y1^2 * Y2^2 + ( - Y3) * Y1^2 * Y2, ( - 1) * Y * V2 * V3 * X1 * Y2 + (Y3) * Y * V2 * V3 * X1 + (1) * Y * V2 * V3 * Y1 * X2 + ( - X3) * Y * V2 * V3 * Y1 + ( - Y3) * Y * V2 * V3 * X2 + (X3) * Y * V2 * V3 * Y2 + (Y3) * Y * V2 * X1 * Y2 + ( - Y3^2) * Y * V2 * X1 + ( - Y3) * Y * V2 * Y1 * X2 + (X3 * Y3) * Y * V2 * Y1 + (Y3^2) * Y * V2 * X2 + ( - X3 * Y3) * Y * V2 * Y2 + (1) * Y * V3 * X1 * Y2^2 + ( - Y3) * Y * V3 * X1 * Y2 + ( - 1) * Y * V3 * Y1 * X2 * Y2 + (X3) * Y * V3 * Y1 * Y2 + (Y3) * Y * V3 * X2 * Y2 + ( - X3) * Y * V3 * Y2^2 + ( - Y3) * Y * X1 * Y2^2 + (Y3^2) * Y * X1 * Y2 + (Y3) * Y * Y1 * X2 * Y2 + ( - X3 * Y3) * Y * Y1 * Y2 + ( - Y3^2) * Y * X2 * Y2 + (X3 * Y3) * Y * Y2^2 + (1) * V2 * V3 * X1^2 * X2 + ( - X3) * V2 * V3 * X1^2 + (1) * V2 * V3 * X1 * Y1 * Y2 + ( - Y3) * V2 * V3 * X1 * Y1 + ( - 1) * V2 * V3 * X1 * X2^2 + (X3^2) * V2 * V3 * X1 + ( - 1) * V2 * V3 * Y1 * X2 * Y2 + (X3 * Y3) * V2 * V3 * Y1 + (X3) * V2 * V3 * X2^2 + (Y3) * V2 * V3 * X2 * Y2 + ( - X3^2) * V2 * V3 * X2 + ( - X3 * Y3) * V2 * V3 * Y2 + ( - Y3) * V2 * X1^2 * X2 + (X3 * Y3) * V2 * X1^2 + ( - Y3) * V2 * X1 * Y1 * Y2 + (Y3^2) * V2 * X1 * Y1 + (Y3) * V2 * X1 * X2^2 + ( - X3^2 * Y3) * V2 * X1 + (Y3) * V2 * Y1 * X2 * Y2 + ( - X3 * Y3^2) * V2 * Y1 + ( - X3 * Y3) * V2 * X2^2 + ( - Y3^2) * V2 * X2 * Y2 + (X3^2 * Y3) * V2 * X2 + (X3 * Y3^2) * V2 * Y2 + ( - 1) * V3 * X1^2 * X2 * Y2 + (X3) * V3 * X1^2 * Y2 + ( - 1) * V3 * X1 * Y1 * Y2^2 + (Y3) * V3 * X1 * Y1 * Y2 + (1) * V3 * X1 * X2^2 * Y2 + ( - X3^2) * V3 * X1 * Y2 + (1) * V3 * Y1 * X2 * Y2^2 + ( - X3 * Y3) * V3 * Y1 * Y2 + ( - X3) * V3 * X2^2 * Y2 + ( - Y3) * V3 * X2 * Y2^2 + (X3^2) * V3 * X2 * Y2 + (X3 * Y3) * V3 * Y2^2 + (Y3) * X1^2 * X2 * Y2 + ( - X3 * Y3) * X1^2 * Y2 + (Y3) * X1 * Y1 * Y2^2 + ( - Y3^2) * X1 * Y1 * Y2 + ( - Y3) * X1 * X2^2 * Y2 + (X3^2 * Y3) * X1 * Y2 + ( - Y3) * Y1 * X2 * Y2^2 + (X3 * Y3^2) * Y1 * Y2 + (X3 * Y3) * X2^2 * Y2 + (Y3^2) * X2 * Y2^2 + ( - X3^2 * Y3) * X2 * Y2 + ( - X3 * Y3^2) * Y2^2, ( - 1) * Y * V1 * V3 * X1 * Y2 + (Y3) * Y * V1 * V3 * X1 + (1) * Y * V1 * V3 * Y1 * X2 + ( - X3) * Y * V1 * V3 * Y1 + ( - Y3) * Y * V1 * V3 * X2 + (X3) * Y * V1 * V3 * Y2 + (Y3) * Y * V1 * X1 * Y2 + ( - Y3^2) * Y * V1 * X1 + ( - Y3) * Y * V1 * Y1 * X2 + (X3 * Y3) * Y * V1 * Y1 + (Y3^2) * Y * V1 * X2 + ( - X3 * Y3) * Y * V1 * Y2 + (1) * Y * V3 * X1 * Y1 * Y2 + ( - Y3) * Y * V3 * X1 * Y1 + ( - 1) * Y * V3 * Y1^2 * X2 + (X3) * Y * V3 * Y1^2 + (Y3) * Y * V3 * Y1 * X2 + ( - X3) * Y * V3 * Y1 * Y2 + ( - Y3) * Y * X1 * Y1 * Y2 + (Y3^2) * Y * X1 * Y1 + (Y3) * Y * Y1^2 * X2 + ( - X3 * Y3) * Y * Y1^2 + ( - Y3^2) * Y * Y1 * X2 + (X3 * Y3) * Y * Y1 * Y2 + (1) * V1 * V3 * X1^2 * X2 + ( - X3) * V1 * V3 * X1^2 + (1) * V1 * V3 * X1 * Y1 * Y2 + ( - Y3) * V1 * V3 * X1 * Y1 + ( - 1) * V1 * V3 * X1 * X2^2 + (X3^2) * V1 * V3 * X1 + ( - 1) * V1 * V3 * Y1 * X2 * Y2 + (X3 * Y3) * V1 * V3 * Y1 + (X3) * V1 * V3 * X2^2 + (Y3) * V1 * V3 * X2 * Y2 + ( - X3^2) * V1 * V3 * X2 + ( - X3 * Y3) * V1 * V3 * Y2 + ( - Y3) * V1 * X1^2 * X2 + (X3 * Y3) * V1 * X1^2 + ( - Y3) * V1 * X1 * Y1 * Y2 + (Y3^2) * V1 * X1 * Y1 + (Y3) * V1 * X1 * X2^2 + ( - X3^2 * Y3) * V1 * X1 + (Y3) * V1 * Y1 * X2 * Y2 + ( - X3 * Y3^2) * V1 * Y1 + ( - X3 * Y3) * V1 * X2^2 + ( - Y3^2) * V1 * X2 * Y2 + (X3^2 * Y3) * V1 * X2 + (X3 * Y3^2) * V1 * Y2 + ( - 1) * V3 * X1^2 * Y1 * X2 + (X3) * V3 * X1^2 * Y1 + ( - 1) * V3 * X1 * Y1^2 * Y2 + (Y3) * V3 * X1 * Y1^2 + (1) * V3 * X1 * Y1 * X2^2 + ( - X3^2) * V3 * X1 * Y1 + (1) * V3 * Y1^2 * X2 * Y2 + ( - X3 * Y3) * V3 * Y1^2 + ( - X3) * V3 * Y1 * X2^2 + ( - Y3) * V3 * Y1 * X2 * Y2 + (X3^2) * V3 * Y1 * X2 + (X3 * Y3) * V3 * Y1 * Y2 + (Y3) * X1^2 * Y1 * X2 + ( - X3 * Y3) * X1^2 * Y1 + (Y3) * X1 * Y1^2 * Y2 + ( - Y3^2) * X1 * Y1^2 + ( - Y3) * X1 * Y1 * X2^2 + (X3^2 * Y3) * X1 * Y1 + ( - Y3) * Y1^2 * X2 * Y2 + (X3 * Y3^2) * Y1^2 + (X3 * Y3) * Y1 * X2^2 + (Y3^2) * Y1 * X2 * Y2 + ( - X3^2 * Y3) * Y1 * X2 + ( - X3 * Y3^2) * Y1 * Y2, ( - 1) * Y * V1 * V2 * X1 * Y2 + (Y3) * Y * V1 * V2 * X1 + (1) * Y * V1 * V2 * Y1 * X2 + ( - X3) * Y * V1 * V2 * Y1 + ( - Y3) * Y * V1 * V2 * X2 + (X3) * Y * V1 * V2 * Y2 + (1) * Y * V1 * X1 * Y2^2 + ( - Y3) * Y * V1 * X1 * Y2 + ( - 1) * Y * V1 * Y1 * X2 * Y2 + (X3) * Y * V1 * Y1 * Y2 + (Y3) * Y * V1 * X2 * Y2 + ( - X3) * Y * V1 * Y2^2 + (1) * Y * V2 * X1 * Y1 * Y2 + ( - Y3) * Y * V2 * X1 * Y1 + ( - 1) * Y * V2 * Y1^2 * X2 + (X3) * Y * V2 * Y1^2 + (Y3) * Y * V2 * Y1 * X2 + ( - X3) * Y * V2 * Y1 * Y2 + ( - 1) * Y * X1 * Y1 * Y2^2 + (Y3) * Y * X1 * Y1 * Y2 + (1) * Y * Y1^2 * X2 * Y2 + ( - X3) * Y * Y1^2 * Y2 + ( - Y3) * Y * Y1 * X2 * Y2 + (X3) * Y * Y1 * Y2^2 + (1) * V1 * V2 * X1^2 * X2 + ( - X3) * V1 * V2 * X1^2 + (1) * V1 * V2 * X1 * Y1 * Y2 + ( - Y3) * V1 * V2 * X1 * Y1 + ( - 1) * V1 * V2 * X1 * X2^2 + (X3^2) * V1 * V2 * X1 + ( - 1) * V1 * V2 * Y1 * X2 * Y2 + (X3 * Y3) * V1 * V2 * Y1 + (X3) * V1 * V2 * X2^2 + (Y3) * V1 * V2 * X2 * Y2 + ( - X3^2) * V1 * V2 * X2 + ( - X3 * Y3) * V1 * V2 * Y2 + ( - 1) * V1 * X1^2 * X2 * Y2 + (X3) * V1 * X1^2 * Y2 + ( - 1) * V1 * X1 * Y1 * Y2^2 + (Y3) * V1 * X1 * Y1 * Y2 + (1) * V1 * X1 * X2^2 * Y2 + ( - X3^2) * V1 * X1 * Y2 + (1) * V1 * Y1 * X2 * Y2^2 + ( - X3 * Y3) * V1 * Y1 * Y2 + ( - X3) * V1 * X2^2 * Y2 + ( - Y3) * V1 * X2 * Y2^2 + (X3^2) * V1 * X2 * Y2 + (X3 * Y3) * V1 * Y2^2 + ( - 1) * V2 * X1^2 * Y1 * X2 + (X3) * V2 * X1^2 * Y1 + ( - 1) * V2 * X1 * Y1^2 * Y2 + (Y3) * V2 * X1 * Y1^2 + (1) * V2 * X1 * Y1 * X2^2 + ( - X3^2) * V2 * X1 * Y1 + (1) * V2 * Y1^2 * X2 * Y2 + ( - X3 * Y3) * V2 * Y1^2 + ( - X3) * V2 * Y1 * X2^2 + ( - Y3) * V2 * Y1 * X2 * Y2 + (X3^2) * V2 * Y1 * X2 + (X3 * Y3) * V2 * Y1 * Y2 + (1) * X1^2 * Y1 * X2 * Y2 + ( - X3) * X1^2 * Y1 * Y2 + (1) * X1 * Y1^2 * Y2^2 + ( - Y3) * X1 * Y1^2 * Y2 + ( - 1) * X1 * Y1 * X2^2 * Y2 + (X3^2) * X1 * Y1 * Y2 + ( - 1) * Y1^2 * X2 * Y2^2 + (X3 * Y3) * Y1^2 * Y2 + (X3) * Y1 * X2^2 * Y2 + (Y3) * Y1 * X2 * Y2^2 + ( - X3^2) * Y1 * X2 * Y2 + ( - X3 * Y3) * Y1 * Y2^2 ]
+Finished loading alt2.lisp
+T
+
+>
Index: /trunk/examples/alt3.lisp
===================================================================
--- /trunk/examples/alt3.lisp	(revision 8)
+++ /trunk/examples/alt3.lisp	(revision 8)
@@ -0,0 +1,12 @@
+;; This is supposed to prove that the 3 altitudes of a triangle
+;; intersect at a single point; if consistent, then the altitudes have
+;; a common point (x,y). Only x3 y3 are treated as parameters, i.e.
+;; we vary only one vertex; adding all three vertices produces 6 parameters,
+;; too much to swallow for the software
+(string-grobner-system
+"[X*Y1-U1*Y1-X1*Y+U1*Y+V1*X1-V1*X,X*Y2-U2*Y2-X2*Y+U2*Y+V2*X2-V2*X,X*Y3-U3*Y3-X3*Y+U3*Y+V3*X3-V3*X,-Y1*Y3+V1*Y3+Y1*Y2-V1*Y2-X1*X3+U1*X3+X1*X2-U1*X2,-Y2*Y3+V2*Y3+Y1*Y2-V2*Y1-X2*X3+U2*X3+X1*X2-U2*X1,-Y2*Y3+Y1*Y3+V3*Y2-V3*Y1-X2*X3+X1*X3+U3*X2-U3*X1]"
+'(x y u1 v1 u2 v2 u3 v3)
+'(x1 y1 x2 y2 x3 y3)
+:main-order #'lex>
+:parameter-order #'lex>)
+
Index: /trunk/examples/apollonius.lisp
===================================================================
--- /trunk/examples/apollonius.lisp	(revision 8)
+++ /trunk/examples/apollonius.lisp	(revision 8)
@@ -0,0 +1,7 @@
+(warn "Test 6 - Circle of Apollonius")
+(string-grobner-system 
+ "[2*x1-u1,2*x2-u2,2*x3-u1,2*x4-u2,x5*u1-x6*u2,x5*u2+x6*u1-u1*u2,x1^2-2*x1*x7+x7^2+x8^2-x7^2-x8^2+2*x8*x2-x2^2,x1^2-2*x1*x7+x7^2+x6^2-2*x6*x8+x8^2-x3^2+2*x3*x7-x7^2-x4^2+2*x4*x8-x8^2,1-s*x5^2+2*s*x5*x7-s*x7^2-s*x6^2+2*s*x6*x8-s*x8^2+s*x1^2-2*s*x1*x7+s*x7^2+s*x8^2]"
+ '(s x1 x2 x3 x4 x5 x6 x7 x8)		;vars
+ '(u1 u2)				;parameters
+ :cover (list (list "[]" "[u1,u2]"))
+ )
Index: /trunk/examples/apollonius.macsyma
===================================================================
--- /trunk/examples/apollonius.macsyma	(revision 8)
+++ /trunk/examples/apollonius.macsyma	(revision 8)
@@ -0,0 +1,27 @@
+if get('geometry,'version)=false then load(geometry);
+
+/* Points */
+A:[0,0];
+B:[u1,0];
+C:[0,u2];
+M1:[x1,0];
+M2:[0,x2];
+M3:[x3,x4];
+H:[x5,x6];
+O:[x7,x8];
+
+/* Equations */
+eqns:append(
+	append(
+		midpoint(M1,A,B),
+		midpoint(M2,A,C),
+		midpoint(M3,B,C)
+	),
+	[
+		perp(A,H,B,C),
+		collinear(B,H,C),
+		eqlen(O,A,O,M1),
+		eqlen(O,A,O,M2),
+		eqlen(O,A,O,M3),
+		eqlen(O,A,O,H)
+	]);
Index: /trunk/examples/apollonius0.lisp
===================================================================
--- /trunk/examples/apollonius0.lisp	(revision 8)
+++ /trunk/examples/apollonius0.lisp	(revision 8)
@@ -0,0 +1,10 @@
+;; An automatic proof of the Apollonius Circle Theorem
+;; Encoding by hand
+(setf vars '(x1 x2))
+(setf params '(u1 u2))
+(setf allvars (append vars params))
+(setf hypotheses "[x1*u1-x2*u2, -x1*u2-u1*x2+u1*u2]")
+(setf conclusions  "[2*x2^2-u2*x2+2*x1^2-u1*x1,u1,u2]")
+;; Saturation test
+(string-ideal-polysaturation-1 hypotheses conclusions allvars)
+
Index: /trunk/examples/apollonius1.lisp
===================================================================
--- /trunk/examples/apollonius1.lisp	(revision 8)
+++ /trunk/examples/apollonius1.lisp	(revision 8)
@@ -0,0 +1,5 @@
+;; An automatic proof of the Apollonius Circle Theorem
+;; Comprehensive Grobner Basis approach
+(string-grobner-system "[x1*u1-x2*u2, -x1*u2-u1*x2+u1*u2,
+        1-s*(2*x2^2-u2*x2+2*x1^2-u1*x1)]"
+        '(s x1 x2) '(u1 u2))
Index: /trunk/examples/apollonius2.lisp
===================================================================
--- /trunk/examples/apollonius2.lisp	(revision 8)
+++ /trunk/examples/apollonius2.lisp	(revision 8)
@@ -0,0 +1,8 @@
+(string-grobner-system
+ "[2*X1-U1,0,0,2*X2-U2,2*X3-U1,2*X4-U2,U2*X6-U1*X5,U1*X6+U2*X5-U1*U2,2*X1*X7-X1^2,2*X2*X8-X2^2,2*X4*X8+2*X3*X7-X4^2-X3^2,2*X6*X8+2*X5*X7-X6^2-X5^2]"
+ '(s x1 x2 x3 x4 x5 x6 x7 x8)		;vars
+ '(u1 u2)				;parameters
+ :cover (list (list "[]" "[u1,u2]"))
+ :main-order #'grevlex>
+ :parameter-order #'grevlex>
+ )
Index: /trunk/examples/apollonius3.lisp
===================================================================
--- /trunk/examples/apollonius3.lisp	(revision 8)
+++ /trunk/examples/apollonius3.lisp	(revision 8)
@@ -0,0 +1,7 @@
+(warn "Test 6 - Circle of Apollonius")
+(string-grobner-system 
+ "[2*x1-u1,2*x2-u2,2*x3-u1,2*x4-u2,x5*u1-x6*u2,x5*u2+x6*u1-u1*u2,x1^2-2*x1*x7+x7^2+x8^2-x7^2-x8^2+2*x8*x2-x2^2,x1^2-2*x1*x7+x7^2+x6^2-2*x6*x8+x8^2-x3^2+2*x3*x7-x7^2-x4^2+2*x4*x8-x8^2,1-s*x5^2+2*s*x5*x7-s*x7^2-s*x6^2+2*s*x6*x8-s*x8^2+s*x1^2-2*s*x1*x7+s*x7^2+s*x8^2]"
+ '(s x1 x2 x3 x4 x5 x6 x7 x8 u1)	;vars
+ '(u2)					;parameters
+ :cover (list (list "[]" "[u2]"))
+ )
Index: /trunk/examples/bifurcation.lisp
===================================================================
--- /trunk/examples/bifurcation.lisp	(revision 8)
+++ /trunk/examples/bifurcation.lisp	(revision 8)
@@ -0,0 +1,49 @@
+;; A computation of the places at which flip bifurcation occurrs in
+;; the quadratic family. Note: period 3 finished quite easily, period 4
+;; runs forever. Two methods: grobner and resultant
+;;
+;;Define the map f: (z,c)->(z^2+c,c)
+(setf f (cdr (string-read-poly "[z^2+c,c]" '(z c))))
+;;
+;;Define the identity map as a polynomial
+(setf id (cdr (string-read-poly "[z,c]" '(z c))))
+;;
+;;Define a constant polynomial 1 in variables z and c
+(setf one (string-read-poly "1" '(z c)))
+;;
+;;(f-composition n) returns f o g o ... o f (n-times) as polynomial
+(defun f-composition (n) (poly-dynamic-power f n))
+;;
+;; g = f^n-id
+(defun g (n) (car (mapcar #'poly- (f-composition n) id)))
+;;
+;; (f^n)' (derivative over z = 0-th variable)
+(defun df (n) (car (partial (f-composition n) 0)))
+;;
+;; Flip bifurcations occur when derivative is -1 at some fixed point
+;; (ideal n) is the ideal spanned by f^n-id and f'+1 and its zeros
+;; are clearly the locus of flip bifurcations
+(defun ideal (n) (list (g n) (poly+ (df n) one)))
+;;
+;; Printer of the n-th ideal
+(defun print-ideal (n) (poly-print (cons '[ (ideal n)) '(z c)) (terpri))
+;;
+;; Eliminate z from the equations, because we are just after the values of
+;; the parameter c
+(defun bifurcation (n)
+  (mapcar #'poly-contract (elimination-ideal (ideal n) 1)))
+;;
+;; The same, but elimination done using resultant
+(defun resultant-bifurcation (n)
+  (poly-contract (poly-resultant (g n) (poly+ (df n) one))))
+;;
+;; Print the polynomial whose zeros are the values of c
+;; for which flip bifurcation occurrs
+(defun print-bifurcation (n)
+  (poly-print (cons '[ (bifurcation n)) '(c))
+  (terpri))
+;;
+;; Same for resultant version
+(defun print-resultant-bifurcation (n)
+  (poly-print (resultant-bifurcation n) '(c))
+  (terpri))
Index: /trunk/examples/billiard0.lisp
===================================================================
--- /trunk/examples/billiard0.lisp	(revision 8)
+++ /trunk/examples/billiard0.lisp	(revision 8)
@@ -0,0 +1,10 @@
+;; Triangular billiard orbits (xi,yi) reflecting off of 3 circles
+;; with centers (ui,vi) and radii ri
+;;(trace grobner-gcd)
+(setf *colored-poly-debug* t)
+(string-grobner
+"[-Y0^2-X0^2+R0^2,-Y1^2-X1^2+2*X1+R1^2-1,-Y2^2+2*V2*Y2-X2^2+2*U2*X2-V2^2-U2^2+R2^2,-Y1^2+2*Y0*Y1-Y0^2-X1^2+2*X0*X1-X0^2+L0^2,-Y2^2+2*Y1*Y2-Y1^2-X2^2+2*X1*X2-X1^2+L1^2,-Y2^2+2*Y0*Y2-Y0^2-X2^2+2*X0*X2-X0^2+L2^2,SIN0^2+COS0^2-1,-Y0^2-X0^2+R0^2,-Y1^2+2*Y0*Y1-Y0^2-X1^2+2*X0*X1-X0^2+L0^2,Y0*Y1-Y0^2+X0*X1-X0^2+COS0*L0*R0,-X0*Y1+X1*Y0+L0*R0*SIN0,SIN1^2+COS1^2-1,-Y1^2-X1^2+2*X1+R1^2-1,-Y2^2+2*Y1*Y2-Y1^2-X2^2+2*X1*X2-X1^2+L1^2,Y1*Y2-Y1^2+X1*X2-X2-X1^2+X1+COS1*L1*R1,-X1*Y2+Y2+X2*Y1-Y1+L1*R1*SIN1,SIN2^2+COS2^2-1,-Y2^2+2*V2*Y2-X2^2+2*U2*X2-V2^2-U2^2+R2^2,-Y2^2+2*Y0*Y2-Y0^2-X2^2+2*X0*X2-X0^2+L2^2,-Y2^2+Y0*Y2+V2*Y2-V2*Y0-X2^2+X0*X2+U2*X2-U2*X0+COS2*L2*R2,X0*Y2-U2*Y2-X2*Y0+U2*Y0+V2*X2-V2*X0+L2*R2*SIN2,SIN0^2+COS0^2-1,-Y2^2+2*Y0*Y2-Y0^2-X2^2+2*X0*X2-X0^2+L2^2,-Y0^2-X0^2+R0^2,Y0*Y2-Y0^2+X0*X2-X0^2+COS0*L2*R0,X0*Y2-X2*Y0+L2*R0*SIN0,SIN1^2+COS1^2-1,-Y1^2+2*Y0*Y1-Y0^2-X1^2+2*X0*X1-X0^2+L0^2,-Y1^2-X1^2+2*X1+R1^2-1,-Y1^2+Y0*Y1-X1^2+X0*X1+X1-X0+COS1*L0*R1,-X0*Y1+Y1+X1*Y0-Y0+L0*R1*SIN1,SIN2^2+COS2^2-1,-Y2^2+2*Y1*Y2-Y1^2-X2^2+2*X1*X2-X1^2+L1^2,-Y2^2+2*V2*Y2-X2^2+2*U2*X2-V2^2-U2^2+R2^2,-Y2^2+Y1*Y2+V2*Y2-V2*Y1-X2^2+X1*X2+U2*X2-U2*X1+COS2*L1*R2,-X1*Y2+U2*Y2+X2*Y1-U2*Y1-V2*X2+V2*X1+L1*R2*SIN2]"
+'(COS0 SIN0 COS1 SIN1 COS2 SIN2 X0 Y0 X1 Y1 x2 y2 L0 L1 l2
+r0 r1 r2 u2 v2)
+:order #'grevlex>
+)
Index: /trunk/examples/billiard1.dribble
===================================================================
--- /trunk/examples/billiard1.dribble	(revision 8)
+++ /trunk/examples/billiard1.dribble	(revision 8)
@@ -0,0 +1,22 @@
+Starts dribbling to billiard1.dribble (1995/4/26, 15:1:37).
+NIL
+
+>
+(trace grobner-gcd)(GROBNER-GCD)
+
+>
+(string-grobner-system
+"[-Y1^2+2*V1*Y1-X1^2+2*U1*X1-V1^2-U1^2+R1^2,-Y1^2-X1^2+L0^2,-Y1^2-X1^2+L1^2,SIN0^2+COS0^2-1,-Y1^2-X1^2+L0^2,COS0*L0-X1,Y1+L0*SIN0,SIN1^2+COS1^2-1,-Y1^2+2*V1*Y1-X1^2+2*U1*X1-V1^2-U1^2+R1^2,-Y1^2-X1^2+L1^2,-Y1^2+V1*Y1-X1^2+U1*X1+COS1*L1*R1,-U1*Y1+V1*X1+L1*R1*SIN1,SIN0^2+COS0^2-1,-Y1^2-X1^2+L1^2,COS0*L1-X1,L1*SIN0-Y1,SIN1^2+COS1^2-1,-Y1^2-X1^2+L0^2,-Y1^2+2*V1*Y1-X1^2+2*U1*X1-V1^2-U1^2+R1^2,-Y1^2+V1*Y1-X1^2+U1*X1+COS1*L0*R1,U1*Y1-V1*X1+L0*R1*SIN1]"
+'(X1 Y1 L0 L1 COS0 SIN0 COS1 SIN1) ;variables
+'(r1 u1 v1) ;parameters
+:main-order #'grevlex>
+:parameter-order #'grevlex>
+:cover '(("[]" "[]"))
+)
+Correctable error: Console interrupt.
+Signalled by STRING-GROBNER-SYSTEM.
+If continued: Type :r to resume execution, or :q to quit to top level.
+Broken at SYSTEM:TERMINAL-INTERRUPT.  Type :H for Help.
+>>
+
+(dribble)
Index: /trunk/examples/billiard1.lisp
===================================================================
--- /trunk/examples/billiard1.lisp	(revision 8)
+++ /trunk/examples/billiard1.lisp	(revision 8)
@@ -0,0 +1,12 @@
+;; Triangular billiard orbits (xi,yi) reflecting off of 3 circles
+;; with centers (ui,vi) and radii ri
+;;(trace grobner-gcd)
+(setf *colored-poly-debug* t)
+(string-grobner-system
+"[-Y0^2-X0^2+R0^2,-Y1^2-X1^2+2*X1+R1^2-1,-Y2^2+2*V2*Y2-X2^2+2*U2*X2-V2^2-U2^2+R2^2,-Y1^2+2*Y0*Y1-Y0^2-X1^2+2*X0*X1-X0^2+L0^2,-Y2^2+2*Y1*Y2-Y1^2-X2^2+2*X1*X2-X1^2+L1^2,-Y2^2+2*Y0*Y2-Y0^2-X2^2+2*X0*X2-X0^2+L2^2,SIN0^2+COS0^2-1,-Y0^2-X0^2+R0^2,-Y1^2+2*Y0*Y1-Y0^2-X1^2+2*X0*X1-X0^2+L0^2,Y0*Y1-Y0^2+X0*X1-X0^2+COS0*L0*R0,-X0*Y1+X1*Y0+L0*R0*SIN0,SIN1^2+COS1^2-1,-Y1^2-X1^2+2*X1+R1^2-1,-Y2^2+2*Y1*Y2-Y1^2-X2^2+2*X1*X2-X1^2+L1^2,Y1*Y2-Y1^2+X1*X2-X2-X1^2+X1+COS1*L1*R1,-X1*Y2+Y2+X2*Y1-Y1+L1*R1*SIN1,SIN2^2+COS2^2-1,-Y2^2+2*V2*Y2-X2^2+2*U2*X2-V2^2-U2^2+R2^2,-Y2^2+2*Y0*Y2-Y0^2-X2^2+2*X0*X2-X0^2+L2^2,-Y2^2+Y0*Y2+V2*Y2-V2*Y0-X2^2+X0*X2+U2*X2-U2*X0+COS2*L2*R2,X0*Y2-U2*Y2-X2*Y0+U2*Y0+V2*X2-V2*X0+L2*R2*SIN2,SIN0^2+COS0^2-1,-Y2^2+2*Y0*Y2-Y0^2-X2^2+2*X0*X2-X0^2+L2^2,-Y0^2-X0^2+R0^2,Y0*Y2-Y0^2+X0*X2-X0^2+COS0*L2*R0,X0*Y2-X2*Y0+L2*R0*SIN0,SIN1^2+COS1^2-1,-Y1^2+2*Y0*Y1-Y0^2-X1^2+2*X0*X1-X0^2+L0^2,-Y1^2-X1^2+2*X1+R1^2-1,-Y1^2+Y0*Y1-X1^2+X0*X1+X1-X0+COS1*L0*R1,-X0*Y1+Y1+X1*Y0-Y0+L0*R1*SIN1,SIN2^2+COS2^2-1,-Y2^2+2*Y1*Y2-Y1^2-X2^2+2*X1*X2-X1^2+L1^2,-Y2^2+2*V2*Y2-X2^2+2*U2*X2-V2^2-U2^2+R2^2,-Y2^2+Y1*Y2+V2*Y2-V2*Y1-X2^2+X1*X2+U2*X2-U2*X1+COS2*L1*R2,-X1*Y2+U2*Y2+X2*Y1-U2*Y1-V2*X2+V2*X1+L1*R2*SIN2]"
+'(COS0 SIN0 COS1 SIN1 COS2 SIN2 X0 Y0 X1 Y1 x2 y2 L0 L1 l2) ;variables
+'(r0 r1 r2 u2 v2) ;parameters
+:main-order #'lex>
+:parameter-order #'lex>
+:cover '(("[]" "[]"))
+)
Index: /trunk/examples/billiard1.macsyma
===================================================================
--- /trunk/examples/billiard1.macsyma	(revision 8)
+++ /trunk/examples/billiard1.macsyma	(revision 8)
@@ -0,0 +1,45 @@
+if get('geometry2, 'version)=false then load("geometry2");
+n:3;
+/* Define points Ai=[xi,yi] */
+for i:0 thru n-1 do
+	A[i]:[concat(x,i),concat(y,i)];
+
+/* Define circle centers Oi=[ui,vi] */
+for i:0 thru n-1 do
+	O[i]:[concat(u,i),concat(v,i)];
+
+/* Define radii and angles */
+for i:0 thru n-1 do (
+	R[i]:concat(R,i),
+	COS_P[i]:concat(Cos,i),
+	SIN_P[i]:concat(Sin,i),
+	l[i]:concat(l,i)
+);
+
+/* Ai is on the circle with center Oi and radius Ri */
+eqns1:makelist(distance(O[i],A[i],R[i]),i,0,n-1);
+
+/* Distance between Ai and A[i+1] is l[i] */
+shift(k):=if k=n-1 then 0 else k+1;
+lshift(k):=if k=0 then n-1 else k-1;
+eqns2:makelist(distance(A[i],A[shift(i)],l[i]),i,0,n-1);
+
+/* Pi is the angle between [Ai,Oi] and [A[i],A[i+1]] */
+eqns3:apply(append,makelist(angle(cos_p[i],sin_p[i],O[i],A[i],A[shift(i)],
+	r[i],l[i]),i,0,n-1));
+
+/* Pi is the angle between [A[i-1],A[i]] and [Ai,Oi] */
+eqns4:apply(append,makelist(angle(cos_p[i],sin_p[i],A[lshift(i)],A[i],O[i],
+	l[lshift(i)],r[i]),i,0,n-1));
+
+/* Combine all equations */
+eqns:expand(append(eqns1,eqns2,eqns3,eqns4));
+
+/* Introduce simplifications */
+u0:0;
+v0:0;
+u1:1;
+v1:0;
+
+eqns:''eqns;
+stringout("billiard1.out",eqns,listofvars(eqns));
Index: /trunk/examples/billiard1.out
===================================================================
--- /trunk/examples/billiard1.out	(revision 8)
+++ /trunk/examples/billiard1.out	(revision 8)
@@ -0,0 +1,3 @@
+
+[-Y0^2-X0^2+R0^2,-Y1^2-X1^2+2*X1+R1^2-1,-Y2^2+2*V2*Y2-X2^2+2*U2*X2-V2^2-U2^2+R2^2,-Y1^2+2*Y0*Y1-Y0^2-X1^2+2*X0*X1-X0^2+L0^2,-Y2^2+2*Y1*Y2-Y1^2-X2^2+2*X1*X2-X1^2+L1^2,-Y2^2+2*Y0*Y2-Y0^2-X2^2+2*X0*X2-X0^2+L2^2,SIN0^2+COS0^2-1,-Y0^2-X0^2+R0^2,-Y1^2+2*Y0*Y1-Y0^2-X1^2+2*X0*X1-X0^2+L0^2,Y0*Y1-Y0^2+X0*X1-X0^2+COS0*L0*R0,-X0*Y1+X1*Y0+L0*R0*SIN0,SIN1^2+COS1^2-1,-Y1^2-X1^2+2*X1+R1^2-1,-Y2^2+2*Y1*Y2-Y1^2-X2^2+2*X1*X2-X1^2+L1^2,Y1*Y2-Y1^2+X1*X2-X2-X1^2+X1+COS1*L1*R1,-X1*Y2+Y2+X2*Y1-Y1+L1*R1*SIN1,SIN2^2+COS2^2-1,-Y2^2+2*V2*Y2-X2^2+2*U2*X2-V2^2-U2^2+R2^2,-Y2^2+2*Y0*Y2-Y0^2-X2^2+2*X0*X2-X0^2+L2^2,-Y2^2+Y0*Y2+V2*Y2-V2*Y0-X2^2+X0*X2+U2*X2-U2*X0+COS2*L2*R2,X0*Y2-U2*Y2-X2*Y0+U2*Y0+V2*X2-V2*X0+L2*R2*SIN2,SIN0^2+COS0^2-1,-Y2^2+2*Y0*Y2-Y0^2-X2^2+2*X0*X2-X0^2+L2^2,-Y0^2-X0^2+R0^2,Y0*Y2-Y0^2+X0*X2-X0^2+COS0*L2*R0,X0*Y2-X2*Y0+L2*R0*SIN0,SIN1^2+COS1^2-1,-Y1^2+2*Y0*Y1-Y0^2-X1^2+2*X0*X1-X0^2+L0^2,-Y1^2-X1^2+2*X1+R1^2-1,-Y1^2+Y0*Y1-X1^2+X0*X1+X1-X0+COS1*L0*R1,-X0*Y1+Y1+X1*Y0-Y0+L0*R1*SIN1,SIN2^2+COS2^2-1,-Y2^2+2*Y1*Y2-Y1^2-X2^2+2*X1*X2-X1^2+L1^2,-Y2^2+2*V2*Y2-X2^2+2*U2*X2-V2^2-U2^2+R2^2,-Y2^2+Y1*Y2+V2*Y2-V2*Y1-X2^2+X1*X2+U2*X2-U2*X1+COS2*L1*R2,-X1*Y2+U2*Y2+X2*Y1-U2*Y1-V2*X2+V2*X1+L1*R2*SIN2];
+[R0,X0,Y0,R1,X1,Y1,R2,U2,V2,X2,Y2,L0,L1,L2,COS0,SIN0,COS1,SIN1,COS2,SIN2];
Index: /trunk/examples/billiard2.lisp
===================================================================
--- /trunk/examples/billiard2.lisp	(revision 8)
+++ /trunk/examples/billiard2.lisp	(revision 8)
@@ -0,0 +1,11 @@
+(setf *colored-poly-debug* t)
+(setf *grobner-debug* nil)
+(string-grobner-system
+"[1-2*L0*Q0,1-2*L1*Q1,-2*Q1*X1-2*Q0*X1+2*Q1*X0+2*Q0*X0+2*P0*X0,2*Q1*X1+2*Q0*X1+2*P1*X1-2*Q1*X0-2*Q0*X0-2*P1,-2*Q1*Y1-2*Q0*Y1+2*Q1*Y0+2*Q0*Y0+2*P0*Y0,2*Q1*Y1+2*Q0*Y1+2*P1*Y1-2*Q1*Y0-2*Q0*Y0,Y0^2+X0^2-R0^2,Y1^2+X1^2-2*X1-R1^2+1,Y1^2-2*Y0*Y1+Y0^2+X1^2-2*X0*X1+X0^2-L0^2,Y1^2-2*Y0*Y1+Y0^2+X1^2-2*X0*X1+X0^2-L1^2]"
+'(X0 Y0 X1 Y1 L0 L1 P0 P1 Q1 Q0)
+'(R0 R1)
+:cover '(("[r0-1,r1-1]" "[]"))
+:main-order #'grevlex>
+:parameter-order #'grevlex>
+)
+
Index: /trunk/examples/billiard2.macsyma
===================================================================
--- /trunk/examples/billiard2.macsyma	(revision 8)
+++ /trunk/examples/billiard2.macsyma	(revision 8)
@@ -0,0 +1,56 @@
+if get('geometry2, 'version)=false then load("geometry2");
+n:2;
+/* Introduce simplifications */
+u0:0;
+v0:0;
+u1:1;
+v1:0;
+
+/* Define points Ai=[xi,yi] */
+for i:0 thru n-1 do
+	A[i]:[concat(x,i),concat(y,i)];
+
+/* Define circle centers Oi=[ui,vi] */
+for i:0 thru n-1 do
+	O[i]:[concat(u,i),concat(v,i)];
+
+/* Define radii and lengths */
+for i:0 thru n-1 do (
+	R[i]:concat(R,i),
+	l[i]:concat(l,i),
+	p[i]:concat(p,i),
+	q[i]:concat(q,i)
+);
+
+/* Ai is on the circle with center Oi and radius Ri */
+eqns1:makelist(distance(O[i],A[i],R[i]),i,0,n-1);
+
+
+shift(k):=if k=n-1 then 0 else k+1;
+lshift(k):=if k=0 then n-1 else k-1;
+
+
+/* Lagrange expression */
+f: sum(l[i],i,0,n-1)-sum(p[i]*distance(O[i],A[i],r[i]),i,0,n-1)
+	-sum(q[i]*distance(A[i],A[shift(i)],l[i]),i,0,n-1);
+
+/* Lagrange equations */
+eqns0:makelist(diff(f,l[i]),i,0,n-1);
+eqns1:makelist(diff(f,concat(x,i)),i,0,n-1);
+eqns2:makelist(diff(f,concat(y,i)),i,0,n-1);
+eqns3:makelist(diff(f,p[i]),i,0,n-1);
+eqns4:makelist(diff(f,q[i]),i,0,n-1);
+
+/* The rationale is that the entire circles would have to be orbits
+and thus we are seeking for such parameters for which the circle equations
+imply satisfaction of critical point equations */
+
+eqns:expand(append(eqns0,eqns1,eqns2));
+
+
+vars:listofvars(makelist([p[i],q[i],l[i]],i,0,n-1));
+params:listofvars(makelist([A[i],O[i],r[i]],i,0,n-1));
+cover:expand([append(''eqns3,''eqns4),[]]);
+
+eqns:''eqns;
+stringout("billiard2.out",eqns,vars,params,cover);
Index: /trunk/examples/billiard2.out
===================================================================
--- /trunk/examples/billiard2.out	(revision 8)
+++ /trunk/examples/billiard2.out	(revision 8)
@@ -0,0 +1,5 @@
+
+[1-2*L0*Q0,1-2*L1*Q1,-2*Q1*X1-2*Q0*X1+2*Q1*X0+2*Q0*X0+2*P0*X0,2*Q1*X1+2*Q0*X1+2*P1*X1-2*Q1*X0-2*Q0*X0-2*P1,-2*Q1*Y1-2*Q0*Y1+2*Q1*Y0+2*Q0*Y0+2*P0*Y0,2*Q1*Y1+2*Q0*Y1+2*P1*Y1-2*Q1*Y0-2*Q0*Y0];
+[P0,Q0,L0,P1,Q1,L1];
+[X0,Y0,U0,V0,R0,X1,Y1,U1,V1,R1];
+[[Y0^2+X0^2-R0^2,Y1^2+X1^2-2*X1-R1^2+1,Y1^2-2*Y0*Y1+Y0^2+X1^2-2*X0*X1+X0^2-L0^2,Y1^2-2*Y0*Y1+Y0^2+X1^2-2*X0*X1+X0^2-L1^2],[]];
Index: /trunk/examples/billiard3.macsyma
===================================================================
--- /trunk/examples/billiard3.macsyma	(revision 8)
+++ /trunk/examples/billiard3.macsyma	(revision 8)
@@ -0,0 +1,52 @@
+if get('geometry2, 'version)=false then load("geometry2");
+if get('cone, 'version)=false then load("cone"); 
+n:2;
+/* Introduce simplifications */
+u0:0;
+v0:0;
+u1:1;
+v1:0;
+
+/* Define points Ai=[xi,yi] */
+for i:0 thru n-1 do
+	A[i]:[concat(x,i),concat(y,i)];
+
+/* Define circle centers Oi=[ui,vi] */
+for i:0 thru n-1 do
+	O[i]:[concat(u,i),concat(v,i)];
+
+/* Define radii and lengths and Lagrange multipliers */
+for i:0 thru n-1 do (
+	R[i]:concat(R,i),
+	l[i]:concat(l,i),
+	p[i]:concat(p,i),
+	q[i]:concat(q,i)
+);
+
+/* Ai is on the circle with center Oi and radius Ri */
+eqns1:makelist(distance(O[i],A[i],R[i]),i,0,n-1);
+
+
+shift(k):=if k=n-1 then 0 else k+1;
+lshift(k):=if k=0 then n-1 else k-1;
+
+
+/* Lagrange expression */
+f: sum(l[i],i,0,n-1)-sum(p[i]*distance(O[i],A[i],r[i]),i,0,n-1)
+	-sum(q[i]*distance(A[i],A[shift(i)],l[i]),i,0,n-1);
+
+/* Lagrange equations */
+eqns0:makelist(diff(f,l[i]),i,0,n-1);
+eqns1:makelist(diff(f,concat(x,i)),i,0,n-1);
+eqns2:makelist(diff(f,concat(y,i)),i,0,n-1);
+eqns3:makelist(diff(f,p[i]),i,0,n-1);
+eqns4:makelist(diff(f,q[i]),i,0,n-1);
+
+eqns:expand(append(eqns0,eqns1,eqns2,eqns3,eqns4));
+
+vars:listofvars(makelist([p[i],q[i],l[i]],i,0,n-1));
+params:listofvars(makelist([A[i],O[i],r[i]],i,0,n-1));
+cover:expand([[[],[]]]);
+
+eqns:''eqns;
+stringout("billiard3.out",eqns,vars,params,cover);
Index: /trunk/examples/billiard3.out
===================================================================
--- /trunk/examples/billiard3.out	(revision 8)
+++ /trunk/examples/billiard3.out	(revision 8)
@@ -0,0 +1,5 @@
+
+[1-2*L0*Q0,1-2*L1*Q1,-2*Q1*X1-2*Q0*X1+2*Q1*X0+2*Q0*X0+2*P0*X0,2*Q1*X1+2*Q0*X1+2*P1*X1-2*Q1*X0-2*Q0*X0-2*P1,-2*Q1*Y1-2*Q0*Y1+2*Q1*Y0+2*Q0*Y0+2*P0*Y0,2*Q1*Y1+2*Q0*Y1+2*P1*Y1-2*Q1*Y0-2*Q0*Y0,Y0^2+X0^2-R0^2,Y1^2+X1^2-2*X1-R1^2+1,Y1^2-2*Y0*Y1+Y0^2+X1^2-2*X0*X1+X0^2-L0^2,Y1^2-2*Y0*Y1+Y0^2+X1^2-2*X0*X1+X0^2-L1^2];
+[P0,Q0,L0,P1,Q1,L1];
+[X0,Y0,U0,V0,R0,X1,Y1,U1,V1,R1];
+[[[],[]]];
Index: /trunk/examples/billiard31.lisp
===================================================================
--- /trunk/examples/billiard31.lisp	(revision 8)
+++ /trunk/examples/billiard31.lisp	(revision 8)
@@ -0,0 +1,32 @@
+(string-grobner "[-2*PSI0*PSI1*PSI2+K0*L2*PSI1*PSI2+K0*L1*PSI1*PSI2+K0*L0*PSI1*PSI2
+			 +2*K1*L2*PSI0*PSI2+2*K1*L0*PSI0*PSI2
+			 -2*K0*K1*L1*L2*PSI2-2*K0*K1*L0*L1*PSI2
+			 +2*K2*L0*PSI0*PSI1-2*K0*K2*L0*L2*PSI1
+			 -2*K0*K2*L0*L1*PSI1-4*K1*K2*L0*L2*PSI0
+			 +4*K0*K1*K2*L0*L1*L2,
+	2*K0*PSI0*PSI1*PSI2-K0^2*L2*PSI1*PSI2-K0^2*L1*PSI1*PSI2
+			   -K0^2*L0*PSI1*PSI2+2*K1*PSI0^2*PSI2
+			   -2*K0*K1*L2*PSI0*PSI2-2*K0*K1*L1*PSI0*PSI2
+			   -2*K0*K1*L0*PSI0*PSI2+2*K0^2*K1*L1*L2*PSI2
+			   +2*K0^2*K1*L0*L1*PSI2+2*K2*PSI0^2*PSI1
+			   -2*K0*K2*L2*PSI0*PSI1-2*K0*K2*L1*PSI0*PSI1
+			   -2*K0*K2*L0*PSI0*PSI1+2*K0^2*K2*L0*L2*PSI1
+			   +2*K0^2*K2*L0*L1*PSI1-4*K1*K2*L2*PSI0^2
+			   +4*K0*K1*K2*L1*L2*PSI0+4*K0*K1*K2*L0*L2*PSI0
+			   -4*K0^2*K1*K2*L0*L1*L2,
+	-L2*PSI1*PSI2-L1*PSI1*PSI2-L0*PSI1*PSI2+2*K1*L1*L2*PSI2
+		     +2*K1*L0*L1*PSI2+2*K2*L0*L2*PSI1+2*K2*L0*L1*PSI1
+		     -4*K1*K2*L0*L1*L2,
+	-2*PSI0*PSI1*PSI2+K0*L2*PSI1*PSI2+K0*L1*PSI1*PSI2+K0*L0*PSI1*PSI2
+			 +2*K1*L1*PSI0*PSI2-2*K0*K1*L1*L2*PSI2
+			 -2*K0*K1*L0*L1*PSI2+2*K2*L2*PSI0*PSI1
+			 +2*K2*L1*PSI0*PSI1-2*K0*K2*L0*L2*PSI1
+			 -2*K0*K2*L0*L1*PSI1-4*K1*K2*L1*L2*PSI0
+			 +4*K0*K1*K2*L0*L1*L2,PSI0^2+PHI0^2-1,PSI1^2+PHI1^2-1,
+	PSI2^2+PHI2^2-1,PSI0^2-PHI0^2+CT1,
+	2*PHI1*PSI1*ST1+CT1*PSI1^2-CT1*PHI1^2+CT2,
+	2*PHI2*PSI2*ST2+CT2*PSI2^2-CT2*PHI2^2+1,ST1+PSI0^2-PHI0^2,
+	ST2-2*PHI1*PSI1*ST1+CT1*PSI1^2-CT1*PHI1^2,
+	-2*PHI2*PSI2*ST2+CT2*PSI2^2-CT2*PHI2^2,CT2*L2+CT1*L1+L0,L2*ST2+L1*ST1]"
+		"[K0,K1,K2,L0,L1,L2,PSI0,PSI1,PSI2,PHI0,PHI1,PHI2,CT1,CT2,ST1,ST2]"
+		:order #'grevlex>)
Index: /trunk/examples/billiard32.lisp
===================================================================
--- /trunk/examples/billiard32.lisp	(revision 8)
+++ /trunk/examples/billiard32.lisp	(revision 8)
@@ -0,0 +1,1143 @@
+(string-grobner "[-((2*PSI0-K0*L2-K0*L1-K0*L0)*PSI1+(-2*K1*L2-2*K1*L0)*PSI0+2*K0*K1*L1*L2
+				       +2*K0*K1*L0*L1)
+       *PSI2
+       -(-2*K2*L0*PSI0+2*K0*K2*L0*L2+2*K0*K2*L0*L1)*PSI1-4*K1*K2*L0*L2*PSI0
+       +4*K0*K1*K2*L0*L1*L2,
+      ((2*K0*PSI0-K0^2*L2-K0^2*L1-K0^2*L0)*PSI1
+       +2*K1*PSI0^2+(-2*K0*K1*L2-2*K0*K1*L1-2*K0*K1*L0)*PSI0+2*K0^2*K1*L1*L2
+       +2*K0^2*K1*L0*L1)
+       *PSI2
+       +(2*K2*PSI0^2+(-2*K0*K2*L2-2*K0*K2*L1-2*K0*K2*L0)*PSI0+2*K0^2*K2*L0*L2
+		    +2*K0^2*K2*L0*L1)
+	*PSI1-4*K1*K2*L2*PSI0^2+(4*K0*K1*K2*L1+4*K0*K1*K2*L0)*L2*PSI0
+       -4*K0^2*K1*K2*L0*L1*L2,
+      ((((K0*L2^2+(K0*L0-2*K0*L1)*L2)*PHI0+K1\_0*L1*L2^2
+					  +(K1\_0*L1^2+K1\_0*L0*L1)*L2)
+       *PSI0^2
+       +(4*K0^2*L1*L2^2+(4*K0^2*L1^2+4*K0^2*L0*L1)*L2)*PHI0*PSI0
+       +(-K0^3*L1*L2^3+(-2*K0^3*L1^2-2*K0^3*L0*L1)*L2^2
+		      +(-K0^3*L1^3-2*K0^3*L0*L1^2-K0^3*L0^2*L1)*L2)
+	*PHI0)
+       *PSI1^3
+       +(((-2*K0*L2^2+(-4*K0*L1-2*K0*L0)*L2-2*K0*L0*L1)*PHI1-4*K1*L1*L2*PHI0)
+	*PSI0^3
+	+((K0^2*L1*L2^2+(4*K0^2*L1^2+K0^2*L0*L1)*L2+2*K0^2*L0*L1^2)*PHI1
+	 +(10*K0*K1*L1*L2^2+(8*K0*K1*L1^2+10*K0*K1*L0*L1)*L2)*PHI0
+	 -2*K1*K1\_0*L1^2*L2^2-2*K1*K1\_0*L0*L1^2*L2)
+	 *PSI0^2
+	+(-4*K0^2*K1*L1*L2^3+(-16*K0^2*K1*L1^2-8*K0^2*K1*L0*L1)*L2^2
+			    +(-4*K0^2*K1*L1^3-16*K0^2*K1*L0*L1^2
+					     -4*K0^2*K1*L0^2*L1)
+			     *L2)
+	 *PHI0*PSI0
+	+(4*K0^3*K1*L1^2*L2^3+(4*K0^3*K1*L1^3+8*K0^3*K1*L0*L1^2)*L2^2
+			     +(4*K0^3*K1*L0*L1^3+4*K0^3*K1*L0^2*L1^2)*L2)
+	 *PHI0)
+	*PSI1^2
+       +(((-K1*L2^2+(-4*K1*L1-K1*L0)*L2-3*K1*L0*L1)*PHI1
+	-K1\_1*L1*L2^2-K1\_1*L0*L1*L2)
+	*PSI0^4
+	+((4*K0*K1*L1*L2^2+(8*K0*K1*L1^2+4*K0*K1*L0*L1)*L2+6*K0*K1*L0*L1^2)
+	 *PHI1
+	 +(8*K1^2*L1*L2^2+8*K1^2*L0*L1*L2)*PHI0+2*K0*K1\_1*L1^2*L2^2
+	 +2*K0*K1\_1*L0*L1^2*L2)
+	 *PSI0^3
+	+((-3*K0^2*K1*L1^2*L2^2+(-4*K0^2*K1*L1^3-3*K0^2*K1*L0*L1^2)*L2
+			       -3*K0^2*K1*L0*L1^3)
+	 *PHI1
+	 +(-4*K0*K1^2*L1*L2^3+(-16*K0*K1^2*L1^2-8*K0*K1^2*L0*L1)*L2^2
+			     +(-16*K0*K1^2*L0*L1^2-4*K0*K1^2*L0^2*L1)*L2)
+	  *PHI0-K0^2*K1\_1*L1^3*L2^2-K0^2*K1\_1*L0*L1^3*L2)
+	 *PSI0^2
+	+(8*K0^2*K1^2*L1^2*L2^3+(8*K0^2*K1^2*L1^3+16*K0^2*K1^2*L0*L1^2)*L2^2
+			       +(8*K0^2*K1^2*L0*L1^3+8*K0^2*K1^2*L0^2*L1^2)
+				*L2)
+	 *PHI0*PSI0
+	+(-4*K0^3*K1^2*L1^3*L2^3-8*K0^3*K1^2*L0*L1^3*L2^2
+				-4*K0^3*K1^2*L0^2*L1^3*L2)
+	 *PHI0)
+	*PSI1+(K1^2*L1*L2^2+K1^2*L0*L1*L2)*PHI1*PSI0^4
+       +(-2*K0*K1^2*L1^2*L2^2-2*K0*K1^2*L0*L1^2*L2)*PHI1*PSI0^3
+       +(K0^2*K1^2*L1^3*L2^2+K0^2*K1^2*L0*L1^3*L2)*PHI1*PSI0^2)
+       *PSI2^3
+       +((((4*K0*L1*L2+2*K0*L0*L1)*PHI2-4*K2*L1*L2*PHI0)*PSI0^3
+	+((-4*K0^2*L1*L2^2+(-4*K0^2*L1^2-K0^2*L0*L1)*L2-2*K0^2*L0*L1^2)*PHI2
+	 +((8*K0*K2*L1-2*K0*K2*L0)*L2^2+(8*K0*K2*L1^2+10*K0*K2*L0*L1)*L2)*PHI0
+	 -2*K1\_0*K2*L0*L1*L2^2-2*K1\_0*K2*L0*L1^2*L2)
+	 *PSI0^2
+	+(-4*K0^2*K2*L1*L2^3+(-8*K0^2*K2*L1^2-16*K0^2*K2*L0*L1)*L2^2
+			    +(-4*K0^2*K2*L1^3-16*K0^2*K2*L0*L1^2
+					     -4*K0^2*K2*L0^2*L1)
+			     *L2)
+	 *PHI0*PSI0
+	+(4*K0^3*K2*L0*L1*L2^3+(8*K0^3*K2*L0*L1^2+4*K0^3*K2*L0^2*L1)*L2^2
+			      +(4*K0^3*K2*L0*L1^3+4*K0^3*K2*L0^2*L1^2)*L2)
+	 *PHI0)
+	*PSI1^3
+	+((8*K1*L1*L2+4*K1*L0*L1)*PHI2*PSI0^4
+	 +((-16*K0*K1*L1*L2^2+(-16*K0*K1*L1^2-4*K0*K1*L0*L1)*L2
+			     -8*K0*K1*L0*L1^2)
+	  *PHI2
+	  +(4*K0*K2*L0*L2^2+8*K0*K2*L0*L1*L2)*PHI1
+	  +(16*K1*K2*L1*L2^2+16*K1*K2*L0*L1*L2)*PHI0)
+	  *PSI0^3
+	 +((16*K0^2*K1*L1^2*L2^2+(8*K0^2*K1*L1^3+4*K0^2*K1*L0*L1^2)*L2
+				+4*K0^2*K1*L0*L1^3)
+	  *PHI2
+	  +(-2*K0^2*K2*L0*L1*L2^2-8*K0^2*K2*L0*L1^2*L2)*PHI1
+	  +(-16*K0*K1*K2*L1*L2^3+(-32*K0*K1*K2*L1^2-44*K0*K1*K2*L0*L1)*L2^2
+				+(-32*K0*K1*K2*L0*L1^2-8*K0*K1*K2*L0^2*L1)*L2)
+	   *PHI0+4*K1*K1\_0*K2*L0*L1^2*L2^2)
+	  *PSI0^2
+	 +((16*K0^2*K1*K2*L1^2+16*K0^2*K1*K2*L0*L1)*L2^3
+	  +(16*K0^2*K1*K2*L1^3+64*K0^2*K1*K2*L0*L1^2+16*K0^2*K1*K2*L0^2*L1)
+	   *L2^2+(16*K0^2*K1*K2*L0*L1^3+16*K0^2*K1*K2*L0^2*L1^2)*L2)
+	  *PHI0*PSI0
+	 +(-16*K0^3*K1*K2*L0*L1^2*L2^3+(-16*K0^3*K1*K2*L0*L1^3
+				       -16*K0^3*K1*K2*L0^2*L1^2)
+				       *L2^2-8*K0^3*K1*K2*L0^2*L1^3*L2)
+	  *PHI0)
+	 *PSI1^2
+	+(((-16*K1^2*L1*L2^2-4*K1^2*L0*L1*L2)*PHI2
+	 +(2*K1*K2*L0*L2^2+8*K1*K2*L0*L1*L2)*PHI1+2*K1\_1*K2*L0*L1*L2^2)
+	 *PSI0^4
+	 +((32*K0*K1^2*L1^2*L2^2+8*K0*K1^2*L0*L1^2*L2)*PHI2
+	  +(-8*K0*K1*K2*L0*L1*L2^2-16*K0*K1*K2*L0*L1^2*L2)*PHI1
+	  +(-16*K1^2*K2*L1*L2^3-32*K1^2*K2*L0*L1*L2^2)*PHI0
+	  -4*K0*K1\_1*K2*L0*L1^2*L2^2)
+	  *PSI0^3
+	 +((-16*K0^2*K1^2*L1^3*L2^2-4*K0^2*K1^2*L0*L1^3*L2)*PHI2
+	  +(6*K0^2*K1*K2*L0*L1^2*L2^2+8*K0^2*K1*K2*L0*L1^3*L2)*PHI1
+	  +((32*K0*K1^2*K2*L1^2+16*K0*K1^2*K2*L0*L1)*L2^3
+	   +(64*K0*K1^2*K2*L0*L1^2+16*K0*K1^2*K2*L0^2*L1)*L2^2)
+	   *PHI0+2*K0^2*K1\_1*K2*L0*L1^3*L2^2)
+	  *PSI0^2
+	 +((-16*K0^2*K1^2*K2*L1^3-32*K0^2*K1^2*K2*L0*L1^2)*L2^3
+	  +(-32*K0^2*K1^2*K2*L0*L1^3-32*K0^2*K1^2*K2*L0^2*L1^2)*L2^2)
+	  *PHI0*PSI0
+	 +(16*K0^3*K1^2*K2*L0*L1^3*L2^3+16*K0^3*K1^2*K2*L0^2*L1^3*L2^2)*PHI0)
+	 *PSI1-2*K1^2*K2*L0*L1*L2^2*PHI1*PSI0^4
+	+4*K0*K1^2*K2*L0*L1^2*L2^2*PHI1*PSI0^3
+	-2*K0^2*K1^2*K2*L0*L1^3*L2^2*PHI1*PSI0^2)
+	*PSI2^2
+       +((((4*K2*L1*L2+K2*L0*L1)*PHI2+K1\_2*L0*L1*L2)*PSI0^4
+	+((-8*K0*K2*L1*L2^2+(-8*K0*K2*L1^2-4*K0*K2*L0*L1)*L2-2*K0*K2*L0*L1^2)
+	 *PHI2
+	 +8*K2^2*L0*L1*L2*PHI0-2*K0*K1\_2*L0*L1*L2^2-2*K0*K1\_2*L0*L1^2*L2)
+	 *PSI0^3
+	+((4*K0^2*K2*L1*L2^3+(8*K0^2*K2*L1^2+3*K0^2*K2*L0*L1)*L2^2
+			    +(4*K0^2*K2*L1^3+4*K0^2*K2*L0*L1^2)*L2
+			    +K0^2*K2*L0*L1^3)
+	 *PHI2
+	 +((-16*K0*K2^2*L0*L1^2-4*K0*K2^2*L0^2*L1)*L2-16*K0*K2^2*L0*L1*L2^2)
+	  *PHI0+K0^2*K1\_2*L0*L1*L2^3+2*K0^2*K1\_2*L0*L1^2*L2^2
+	 +K0^2*K1\_2*L0*L1^3*L2)
+	 *PSI0^2
+	+(8*K0^2*K2^2*L0*L1*L2^3+(16*K0^2*K2^2*L0*L1^2+8*K0^2*K2^2*L0^2*L1)
+				 *L2^2
+				+(8*K0^2*K2^2*L0*L1^3+8*K0^2*K2^2*L0^2*L1^2)
+				 *L2)
+	 *PHI0*PSI0
+	+(-4*K0^3*K2^2*L0^2*L1*L2^3-8*K0^3*K2^2*L0^2*L1^2*L2^2
+				   -4*K0^3*K2^2*L0^2*L1^3*L2)
+	 *PHI0)
+	*PSI1^3
+	+(((-16*K1*K2*L1*L2^2-8*K1*K2*L0*L1*L2)*PHI2-4*K1*K1\_2*L0*L1*L2^2)
+	 *PSI0^4
+	 +((16*K0*K1*K2*L1*L2^3+(32*K0*K1*K2*L1^2+12*K0*K1*K2*L0*L1)*L2^2
+			       +16*K0*K1*K2*L0*L1^2*L2)
+	  *PHI2
+	  -32*K1*K2^2*L0*L1*L2^2*PHI0+4*K0*K1*K1\_2*L0*L1*L2^3
+	  +8*K0*K1*K1\_2*L0*L1^2*L2^2)
+	  *PSI0^3
+	 +((-16*K0^2*K1*K2*L1^2*L2^3+(-16*K0^2*K1*K2*L1^3
+				     -12*K0^2*K1*K2*L0*L1^2)
+				     *L2^2-8*K0^2*K1*K2*L0*L1^3*L2)
+	  *PHI2
+	  +(32*K0*K1*K2^2*L0*L1*L2^3+(64*K0*K1*K2^2*L0*L1^2
+				     +16*K0*K1*K2^2*L0^2*L1)
+				     *L2^2)
+	   *PHI0-4*K0^2*K1*K1\_2*L0*L1^2*L2^3-4*K0^2*K1*K1\_2*L0*L1^3*L2^2)
+	  *PSI0^2
+	 +((-32*K0^2*K1*K2^2*L0*L1^2-16*K0^2*K1*K2^2*L0^2*L1)*L2^3
+	  +(-32*K0^2*K1*K2^2*L0*L1^3-32*K0^2*K1*K2^2*L0^2*L1^2)*L2^2)
+	  *PHI0*PSI0
+	 +(16*K0^3*K1*K2^2*L0^2*L1^2*L2^3+16*K0^3*K1*K2^2*L0^2*L1^3*L2^2)
+	  *PHI0)
+	 *PSI1^2
+	+(((16*K1^2*K2*L1*L2^3+12*K1^2*K2*L0*L1*L2^2)*PHI2
+	 +4*K1^2*K1\_2*L0*L1*L2^3)
+	 *PSI0^4
+	 +((-32*K0*K1^2*K2*L1^2*L2^3-24*K0*K1^2*K2*L0*L1^2*L2^2)*PHI2
+	  +32*K1^2*K2^2*L0*L1*L2^3*PHI0-8*K0*K1^2*K1\_2*L0*L1^2*L2^3)
+	  *PSI0^3
+	 +((16*K0^2*K1^2*K2*L1^3*L2^3+12*K0^2*K1^2*K2*L0*L1^3*L2^2)*PHI2
+	  +(-64*K0*K1^2*K2^2*L0*L1^2-16*K0*K1^2*K2^2*L0^2*L1)*L2^3*PHI0
+	  +4*K0^2*K1^2*K1\_2*L0*L1^3*L2^3)
+	  *PSI0^2
+	 +(32*K0^2*K1^2*K2^2*L0*L1^3+32*K0^2*K1^2*K2^2*L0^2*L1^2)
+	  *L2^3*PHI0*PSI0-16*K0^3*K1^2*K2^2*L0^2*L1^3*L2^3*PHI0)
+	 *PSI1)
+	*PSI2
+       +(-K2^2*L0*L1*L2*PHI2*PSI0^4+(2*K0*K2^2*L0*L1*L2^2
+				    +2*K0*K2^2*L0*L1^2*L2)
+				    *PHI2*PSI0^3
+				   +(-K0^2*K2^2*L0*L1*L2^3
+				    -2*K0^2*K2^2*L0*L1^2*L2^2
+				    -K0^2*K2^2*L0*L1^3*L2)
+				    *PHI2*PSI0^2)
+	*PSI1^3
+       +(4*K1*K2^2*L0*L1*L2^2*PHI2*PSI0^4
+	+(-4*K0*K1*K2^2*L0*L1*L2^3-8*K0*K1*K2^2*L0*L1^2*L2^2)*PHI2*PSI0^3
+	+(4*K0^2*K1*K2^2*L0*L1^2*L2^3+4*K0^2*K1*K2^2*L0*L1^3*L2^2)
+	 *PHI2*PSI0^2)
+	*PSI1^2
+       +(-4*K1^2*K2^2*L0*L1*L2^3*PHI2*PSI0^4
+	+8*K0*K1^2*K2^2*L0*L1^2*L2^3*PHI2*PSI0^3
+	-4*K0^2*K1^2*K2^2*L0*L1^3*L2^3*PHI2*PSI0^2)
+	*PSI1,
+      -((((3*K0*L1-K0*L0)*L2*PHI0-K1\_0*L0*L1*L2)*PSI0^3
+       +(((K0^2*L0-4*K0^2*L1)*L2^2+(-4*K0^2*L1^2-6*K0^2*L0*L1+K0^2*L0^2)*L2)
+	*PHI0
+	+K0*K1\_0*L0*L1*L2^2+(K0*K1\_0*L0*L1^2+K0*K1\_0*L0^2*L1)*L2)
+	*PSI0^2
+       +(K0^3*L1*L2^3+(2*K0^3*L1^2+6*K0^3*L0*L1)*L2^2
+		     +(K0^3*L1^3+6*K0^3*L0*L1^2+5*K0^3*L0^2*L1)*L2)
+	*PHI0*PSI0
+       +(-K0^4*L0*L1*L2^3+(-2*K0^4*L0*L1^2-2*K0^4*L0^2*L1)*L2^2
+			 +(-K0^4*L0*L1^3-2*K0^4*L0^2*L1^2-K0^4*L0^3*L1)*L2)
+	*PHI0)
+       *PSI1^3
+       +(((2*K0*L0*L2+2*K0*L0*L1)*PHI1+4*K1*L1*L2*PHI0)*PSI0^4
+	+((-2*K0^2*L0*L2^2+(-5*K0^2*L0*L1-2*K0^2*L0^2)*L2-2*K0^2*L0*L1^2
+			  -2*K0^2*L0^2*L1)
+	 *PHI1
+	 +((-8*K0*K1*L1^2-14*K0*K1*L0*L1)*L2-12*K0*K1*L1*L2^2)*PHI0
+	 +2*K1*K1\_0*L0*L1^2*L2)
+	 *PSI0^3
+	+((K0^3*L0*L1*L2^2+(4*K0^3*L0*L1^2+K0^3*L0^2*L1)*L2+2*K0^3*L0^2*L1^2)
+	 *PHI1
+	 +(4*K0^2*K1*L1*L2^3+(16*K0^2*K1*L1^2+18*K0^2*K1*L0*L1)*L2^2
+			    +(4*K0^2*K1*L1^3+24*K0^2*K1*L0*L1^2
+					    +14*K0^2*K1*L0^2*L1)
+			     *L2)
+	  *PHI0-2*K0*K1*K1\_0*L0*L1^2*L2^2-2*K0*K1*K1\_0*L0^2*L1^2*L2)
+	 *PSI0^2
+	+((-4*K0^3*K1*L1^2-4*K0^3*K1*L0*L1)*L2^3
+	 +(-4*K0^3*K1*L1^3-24*K0^3*K1*L0*L1^2-8*K0^3*K1*L0^2*L1)*L2^2
+	 +(-8*K0^3*K1*L0*L1^3-20*K0^3*K1*L0^2*L1^2-4*K0^3*K1*L0^3*L1)*L2)
+	 *PHI0*PSI0
+	+(4*K0^4*K1*L0*L1^2*L2^3+(4*K0^4*K1*L0*L1^3+8*K0^4*K1*L0^2*L1^2)*L2^2
+				+(4*K0^4*K1*L0^2*L1^3+4*K0^4*K1*L0^3*L1^2)*L2)
+	 *PHI0)
+	*PSI1^2
+       +(((K1*L0*L2+3*K1*L0*L1)*PHI1+K1\_1*L0*L1*L2)*PSI0^5
+	+((-K0*K1*L0*L2^2+(-8*K0*K1*L0*L1-K0*K1*L0^2)*L2-6*K0*K1*L0*L1^2
+			 -3*K0*K1*L0^2*L1)
+	 *PHI1
+	 +(-8*K1^2*L1*L2^2-8*K1^2*L0*L1*L2)*PHI0-K0*K1\_1*L0*L1*L2^2
+	 +(-2*K0*K1\_1*L0*L1^2-K0*K1\_1*L0^2*L1)*L2)
+	 *PSI0^4
+	+((4*K0^2*K1*L0*L1*L2^2+(11*K0^2*K1*L0*L1^2+4*K0^2*K1*L0^2*L1)*L2
+			       +3*K0^2*K1*L0*L1^3+6*K0^2*K1*L0^2*L1^2)
+	 *PHI1
+	 +(4*K0*K1^2*L1*L2^3+(16*K0*K1^2*L1^2+16*K0*K1^2*L0*L1)*L2^2
+			    +(16*K0*K1^2*L0*L1^2+12*K0*K1^2*L0^2*L1)*L2)
+	  *PHI0+2*K0^2*K1\_1*L0*L1^2*L2^2
+	 +(K0^2*K1\_1*L0*L1^3+2*K0^2*K1\_1*L0^2*L1^2)*L2)
+	 *PSI0^3
+	+((-3*K0^3*K1*L0*L1^2*L2^2+(-4*K0^3*K1*L0*L1^3-3*K0^3*K1*L0^2*L1^2)*L2
+				  -3*K0^3*K1*L0^2*L1^3)
+	 *PHI1
+	 +((-8*K0^2*K1^2*L1^2-4*K0^2*K1^2*L0*L1)*L2^3
+	  +(-8*K0^2*K1^2*L1^3-32*K0^2*K1^2*L0*L1^2-8*K0^2*K1^2*L0^2*L1)*L2^2
+	  +(-8*K0^2*K1^2*L0*L1^3-24*K0^2*K1^2*L0^2*L1^2-4*K0^2*K1^2*L0^3*L1)
+	   *L2)
+	  *PHI0-K0^3*K1\_1*L0*L1^3*L2^2-K0^3*K1\_1*L0^2*L1^3*L2)
+	 *PSI0^2
+	+((4*K0^3*K1^2*L1^3+8*K0^3*K1^2*L0*L1^2)*L2^3
+	 +(16*K0^3*K1^2*L0*L1^3+16*K0^3*K1^2*L0^2*L1^2)*L2^2
+	 +(12*K0^3*K1^2*L0^2*L1^3+8*K0^3*K1^2*L0^3*L1^2)*L2)
+	 *PHI0*PSI0
+	+(-4*K0^4*K1^2*L0*L1^3*L2^3-8*K0^4*K1^2*L0^2*L1^3*L2^2
+				   -4*K0^4*K1^2*L0^3*L1^3*L2)
+	 *PHI0)
+	*PSI1-K1^2*L0*L1*L2*PHI1*PSI0^5
+       +(K0*K1^2*L0*L1*L2^2+(2*K0*K1^2*L0*L1^2+K0*K1^2*L0^2*L1)*L2)
+	*PHI1*PSI0^4
+       +((-K0^2*K1^2*L0*L1^3-2*K0^2*K1^2*L0^2*L1^2)*L2
+	-2*K0^2*K1^2*L0*L1^2*L2^2)
+	*PHI1*PSI0^3
+       +(K0^3*K1^2*L0*L1^3*L2^2+K0^3*K1^2*L0^2*L1^3*L2)*PHI1*PSI0^2)
+       *PSI2^3
+       -((((-2*K0*L1*L2-2*K0*L0*L1)*PHI2+4*K2*L1*L2*PHI0)*PSI0^4
+	+((2*K0^2*L1*L2^2+(2*K0^2*L1^2+5*K0^2*L0*L1)*L2+2*K0^2*L0*L1^2
+			 +2*K0^2*L0^2*L1)
+	 *PHI2
+	 +((2*K0*K2*L0-8*K0*K2*L1)*L2^2+(-8*K0*K2*L1^2-14*K0*K2*L0*L1)*L2)
+	  *PHI0+2*K1\_0*K2*L0*L1*L2^2+2*K1\_0*K2*L0*L1^2*L2)
+	 *PSI0^3
+	+((-4*K0^3*L0*L1*L2^2+(-4*K0^3*L0*L1^2-K0^3*L0^2*L1)*L2
+			     -2*K0^3*L0^2*L1^2)
+	 *PHI2
+	 +(4*K0^2*K2*L1*L2^3+(8*K0^2*K2*L1^2+24*K0^2*K2*L0*L1-2*K0^2*K2*L0^2)
+			     *L2^2
+			    +(4*K0^2*K2*L1^3+24*K0^2*K2*L0*L1^2
+					    +14*K0^2*K2*L0^2*L1)
+			     *L2)
+	  *PHI0-2*K0*K1\_0*K2*L0^2*L1*L2^2-2*K0*K1\_0*K2*L0^2*L1^2*L2)
+	 *PSI0^2
+	+(-8*K0^3*K2*L0*L1*L2^3+(-16*K0^3*K2*L0*L1^2-20*K0^3*K2*L0^2*L1)*L2^2
+			       +(-8*K0^3*K2*L0*L1^3-20*K0^3*K2*L0^2*L1^2
+						   -4*K0^3*K2*L0^3*L1)
+				*L2)
+	 *PHI0*PSI0
+	+(4*K0^4*K2*L0^2*L1*L2^3+(8*K0^4*K2*L0^2*L1^2+4*K0^4*K2*L0^3*L1)*L2^2
+				+(4*K0^4*K2*L0^2*L1^3+4*K0^4*K2*L0^3*L1^2)*L2)
+	 *PHI0)
+	*PSI1^3
+	+((-4*K1*L1*L2-4*K1*L0*L1)*PHI2*PSI0^5
+	 +((8*K0*K1*L1*L2^2+(8*K0*K1*L1^2+12*K0*K1*L0*L1)*L2+8*K0*K1*L0*L1^2
+			   +4*K0*K1*L0^2*L1)
+	  *PHI2
+	  +(-4*K0*K2*L0*L2^2-8*K0*K2*L0*L1*L2)*PHI1
+	  +(-16*K1*K2*L1*L2^2-16*K1*K2*L0*L1*L2)*PHI0)
+	  *PSI0^4
+	 +(((-8*K0^2*K1*L1^2-16*K0^2*K1*L0*L1)*L2^2
+	  +(-4*K0^2*K1*L1^3-20*K0^2*K1*L0*L1^2-4*K0^2*K1*L0^2*L1)*L2
+	  -4*K0^2*K1*L0*L1^3-8*K0^2*K1*L0^2*L1^2)
+	  *PHI2
+	  +((2*K0^2*K2*L0*L1+4*K0^2*K2*L0^2)*L2^2
+	   +(8*K0^2*K2*L0*L1^2+8*K0^2*K2*L0^2*L1)*L2)
+	   *PHI1
+	  +(16*K0*K1*K2*L1*L2^3+(32*K0*K1*K2*L1^2+60*K0*K1*K2*L0*L1)*L2^2
+			       +(32*K0*K1*K2*L0*L1^2+24*K0*K1*K2*L0^2*L1)*L2)
+	   *PHI0-4*K1*K1\_0*K2*L0*L1^2*L2^2)
+	  *PSI0^3
+	 +((16*K0^3*K1*L0*L1^2*L2^2+(8*K0^3*K1*L0*L1^3+4*K0^3*K1*L0^2*L1^2)*L2
+				   +4*K0^3*K1*L0^2*L1^3)
+	  *PHI2
+	  +(-2*K0^3*K2*L0^2*L1*L2^2-8*K0^3*K2*L0^2*L1^2*L2)*PHI1
+	  +((-16*K0^2*K1*K2*L1^2-32*K0^2*K1*K2*L0*L1)*L2^3
+	   +(-16*K0^2*K1*K2*L1^3-96*K0^2*K1*K2*L0*L1^2-60*K0^2*K1*K2*L0^2*L1)
+	    *L2^2
+	   +(-16*K0^2*K1*K2*L0*L1^3-48*K0^2*K1*K2*L0^2*L1^2
+				   -8*K0^2*K1*K2*L0^3*L1)
+	    *L2)
+	   *PHI0+4*K0*K1*K1\_0*K2*L0^2*L1^2*L2^2)
+	  *PSI0^2
+	 +((32*K0^3*K1*K2*L0*L1^2+16*K0^3*K1*K2*L0^2*L1)*L2^3
+	  +(32*K0^3*K1*K2*L0*L1^3+80*K0^3*K1*K2*L0^2*L1^2
+				 +16*K0^3*K1*K2*L0^3*L1)
+	   *L2^2+(24*K0^3*K1*K2*L0^2*L1^3+16*K0^3*K1*K2*L0^3*L1^2)*L2)
+	  *PHI0*PSI0
+	 +(-16*K0^4*K1*K2*L0^2*L1^2*L2^3
+	  +(-16*K0^4*K1*K2*L0^2*L1^3-16*K0^4*K1*K2*L0^3*L1^2)*L2^2
+	  -8*K0^4*K1*K2*L0^3*L1^3*L2)
+	  *PHI0)
+	 *PSI1^2
+	+(((8*K1^2*L1*L2^2+4*K1^2*L0*L1*L2)*PHI2
+	 +(-2*K1*K2*L0*L2^2-8*K1*K2*L0*L1*L2)*PHI1-2*K1\_1*K2*L0*L1*L2^2)
+	 *PSI0^5
+	 +(((-16*K0*K1^2*L1^2-16*K0*K1^2*L0*L1)*L2^2
+	  +(-8*K0*K1^2*L0*L1^2-4*K0*K1^2*L0^2*L1)*L2)
+	  *PHI2
+	  +((8*K0*K1*K2*L0*L1+2*K0*K1*K2*L0^2)*L2^2
+	   +(16*K0*K1*K2*L0*L1^2+8*K0*K1*K2*L0^2*L1)*L2)
+	   *PHI1+(16*K1^2*K2*L1*L2^3+32*K1^2*K2*L0*L1*L2^2)*PHI0
+	  +(4*K0*K1\_1*K2*L0*L1^2+2*K0*K1\_1*K2*L0^2*L1)*L2^2)
+	  *PSI0^4
+	 +(((8*K0^2*K1^2*L1^3+32*K0^2*K1^2*L0*L1^2)*L2^2
+	  +(4*K0^2*K1^2*L0*L1^3+8*K0^2*K1^2*L0^2*L1^2)*L2)
+	  *PHI2
+	  +((-6*K0^2*K1*K2*L0*L1^2-8*K0^2*K1*K2*L0^2*L1)*L2^2
+	   +(-8*K0^2*K1*K2*L0*L1^3-16*K0^2*K1*K2*L0^2*L1^2)*L2)
+	   *PHI1
+	  +((-32*K0*K1^2*K2*L1^2-32*K0*K1^2*K2*L0*L1)*L2^3
+	   +(-64*K0*K1^2*K2*L0*L1^2-48*K0*K1^2*K2*L0^2*L1)*L2^2)
+	   *PHI0+(-2*K0^2*K1\_1*K2*L0*L1^3-4*K0^2*K1\_1*K2*L0^2*L1^2)*L2^2)
+	  *PSI0^3
+	 +((-16*K0^3*K1^2*L0*L1^3*L2^2-4*K0^3*K1^2*L0^2*L1^3*L2)*PHI2
+	  +(6*K0^3*K1*K2*L0^2*L1^2*L2^2+8*K0^3*K1*K2*L0^2*L1^3*L2)*PHI1
+	  +((16*K0^2*K1^2*K2*L1^3+64*K0^2*K1^2*K2*L0*L1^2
+				 +16*K0^2*K1^2*K2*L0^2*L1)
+	   *L2^3
+	   +(32*K0^2*K1^2*K2*L0*L1^3+96*K0^2*K1^2*K2*L0^2*L1^2
+				    +16*K0^2*K1^2*K2*L0^3*L1)
+	    *L2^2)
+	   *PHI0+2*K0^3*K1\_1*K2*L0^2*L1^3*L2^2)
+	  *PSI0^2
+	 +((-32*K0^3*K1^2*K2*L0*L1^3-32*K0^3*K1^2*K2*L0^2*L1^2)*L2^3
+	  +(-48*K0^3*K1^2*K2*L0^2*L1^3-32*K0^3*K1^2*K2*L0^3*L1^2)*L2^2)
+	  *PHI0*PSI0
+	 +(16*K0^4*K1^2*K2*L0^2*L1^3*L2^3+16*K0^4*K1^2*K2*L0^3*L1^3*L2^2)
+	  *PHI0)
+	 *PSI1+2*K1^2*K2*L0*L1*L2^2*PHI1*PSI0^5
+	+(-4*K0*K1^2*K2*L0*L1^2-2*K0*K1^2*K2*L0^2*L1)*L2^2*PHI1*PSI0^4
+	+(2*K0^2*K1^2*K2*L0*L1^3+4*K0^2*K1^2*K2*L0^2*L1^2)*L2^2*PHI1*PSI0^3
+	-2*K0^3*K1^2*K2*L0^2*L1^3*L2^2*PHI1*PSI0^2)
+	*PSI2^2
+       -((((-3*K2*L1*L2-K2*L0*L1)*PHI2-K1\_2*L0*L1*L2)*PSI0^5
+	+((6*K0*K2*L1*L2^2+(6*K0*K2*L1^2+8*K0*K2*L0*L1)*L2+2*K0*K2*L0*L1^2
+			  +K0*K2*L0^2*L1)
+	 *PHI2
+	 -8*K2^2*L0*L1*L2*PHI0+2*K0*K1\_2*L0*L1*L2^2
+	 +(2*K0*K1\_2*L0*L1^2+K0*K1\_2*L0^2*L1)*L2)
+	 *PSI0^4
+	+((-3*K0^2*K2*L1*L2^3+(-6*K0^2*K2*L1^2-11*K0^2*K2*L0*L1)*L2^2
+			     +(-3*K0^2*K2*L1^3-12*K0^2*K2*L0*L1^2
+					      -4*K0^2*K2*L0^2*L1)
+			      *L2-K0^2*K2*L0*L1^3-2*K0^2*K2*L0^2*L1^2)
+	 *PHI2
+	 +(16*K0*K2^2*L0*L1*L2^2+(16*K0*K2^2*L0*L1^2+12*K0*K2^2*L0^2*L1)*L2)
+	  *PHI0-K0^2*K1\_2*L0*L1*L2^3
+	 +(-2*K0^2*K1\_2*L0*L1^2-2*K0^2*K1\_2*L0^2*L1)*L2^2
+	 +(-K0^2*K1\_2*L0*L1^3-2*K0^2*K1\_2*L0^2*L1^2)*L2)
+	 *PSI0^3
+	+((4*K0^3*K2*L0*L1*L2^3+(8*K0^3*K2*L0*L1^2+3*K0^3*K2*L0^2*L1)*L2^2
+			       +(4*K0^3*K2*L0*L1^3+4*K0^3*K2*L0^2*L1^2)*L2
+			       +K0^3*K2*L0^2*L1^3)
+	 *PHI2
+	 +(-8*K0^2*K2^2*L0*L1*L2^3+(-16*K0^2*K2^2*L0*L1^2
+				   -24*K0^2*K2^2*L0^2*L1)
+				   *L2^2
+				  +(-8*K0^2*K2^2*L0*L1^3
+				   -24*K0^2*K2^2*L0^2*L1^2
+				   -4*K0^2*K2^2*L0^3*L1)
+				   *L2)
+	  *PHI0+K0^3*K1\_2*L0^2*L1*L2^3+2*K0^3*K1\_2*L0^2*L1^2*L2^2
+	 +K0^3*K1\_2*L0^2*L1^3*L2)
+	 *PSI0^2
+	+(12*K0^3*K2^2*L0^2*L1*L2^3+(24*K0^3*K2^2*L0^2*L1^2
+				    +8*K0^3*K2^2*L0^3*L1)
+				    *L2^2
+				   +(12*K0^3*K2^2*L0^2*L1^3
+				    +8*K0^3*K2^2*L0^3*L1^2)
+				    *L2)
+	 *PHI0*PSI0
+	+(-4*K0^4*K2^2*L0^3*L1*L2^3-8*K0^4*K2^2*L0^3*L1^2*L2^2
+				   -4*K0^4*K2^2*L0^3*L1^3*L2)
+	 *PHI0)
+	*PSI1^3
+	+(((12*K1*K2*L1*L2^2+8*K1*K2*L0*L1*L2)*PHI2+4*K1*K1\_2*L0*L1*L2^2)
+	 *PSI0^5
+	 +((-12*K0*K1*K2*L1*L2^3+(-24*K0*K1*K2*L1^2-28*K0*K1*K2*L0*L1)*L2^2
+				+(-16*K0*K1*K2*L0*L1^2-8*K0*K1*K2*L0^2*L1)*L2)
+	  *PHI2
+	  +32*K1*K2^2*L0*L1*L2^2*PHI0-4*K0*K1*K1\_2*L0*L1*L2^3
+	  +(-8*K0*K1*K1\_2*L0*L1^2-4*K0*K1*K1\_2*L0^2*L1)*L2^2)
+	  *PSI0^4
+	 +(((12*K0^2*K1*K2*L1^2+16*K0^2*K1*K2*L0*L1)*L2^3
+	  +(12*K0^2*K1*K2*L1^3+44*K0^2*K1*K2*L0*L1^2+12*K0^2*K1*K2*L0^2*L1)
+	   *L2^2+(8*K0^2*K1*K2*L0*L1^3+16*K0^2*K1*K2*L0^2*L1^2)*L2)
+	  *PHI2
+	  +((-64*K0*K1*K2^2*L0*L1^2-48*K0*K1*K2^2*L0^2*L1)*L2^2
+	   -32*K0*K1*K2^2*L0*L1*L2^3)
+	   *PHI0+(4*K0^2*K1*K1\_2*L0*L1^2+4*K0^2*K1*K1\_2*L0^2*L1)*L2^3
+	  +(4*K0^2*K1*K1\_2*L0*L1^3+8*K0^2*K1*K1\_2*L0^2*L1^2)*L2^2)
+	  *PSI0^3
+	 +((-16*K0^3*K1*K2*L0*L1^2*L2^3+(-16*K0^3*K1*K2*L0*L1^3
+					-12*K0^3*K1*K2*L0^2*L1^2)
+					*L2^2-8*K0^3*K1*K2*L0^2*L1^3*L2)
+	  *PHI2
+	  +((32*K0^2*K1*K2^2*L0*L1^2+48*K0^2*K1*K2^2*L0^2*L1)*L2^3
+	   +(32*K0^2*K1*K2^2*L0*L1^3+96*K0^2*K1*K2^2*L0^2*L1^2
+				    +16*K0^2*K1*K2^2*L0^3*L1)
+	    *L2^2)
+	   *PHI0-4*K0^3*K1*K1\_2*L0^2*L1^2*L2^3
+	  -4*K0^3*K1*K1\_2*L0^2*L1^3*L2^2)
+	  *PSI0^2
+	 +((-48*K0^3*K1*K2^2*L0^2*L1^2-16*K0^3*K1*K2^2*L0^3*L1)*L2^3
+	  +(-48*K0^3*K1*K2^2*L0^2*L1^3-32*K0^3*K1*K2^2*L0^3*L1^2)*L2^2)
+	  *PHI0*PSI0
+	 +(16*K0^4*K1*K2^2*L0^3*L1^2*L2^3+16*K0^4*K1*K2^2*L0^3*L1^3*L2^2)
+	  *PHI0)
+	 *PSI1^2
+	+(((-12*K1^2*K2*L1*L2^3-12*K1^2*K2*L0*L1*L2^2)*PHI2
+	 -4*K1^2*K1\_2*L0*L1*L2^3)
+	 *PSI0^5
+	 +(((24*K0*K1^2*K2*L1^2+16*K0*K1^2*K2*L0*L1)*L2^3
+	  +(24*K0*K1^2*K2*L0*L1^2+12*K0*K1^2*K2*L0^2*L1)*L2^2)
+	  *PHI2
+	  -32*K1^2*K2^2*L0*L1*L2^3*PHI0
+	  +(8*K0*K1^2*K1\_2*L0*L1^2+4*K0*K1^2*K1\_2*L0^2*L1)*L2^3)
+	  *PSI0^4
+	 +(((-12*K0^2*K1^2*K2*L1^3-32*K0^2*K1^2*K2*L0*L1^2)*L2^3
+	  +(-12*K0^2*K1^2*K2*L0*L1^3-24*K0^2*K1^2*K2*L0^2*L1^2)*L2^2)
+	  *PHI2
+	  +(64*K0*K1^2*K2^2*L0*L1^2+48*K0*K1^2*K2^2*L0^2*L1)*L2^3*PHI0
+	  +(-4*K0^2*K1^2*K1\_2*L0*L1^3-8*K0^2*K1^2*K1\_2*L0^2*L1^2)*L2^3)
+	  *PSI0^3
+	 +((16*K0^3*K1^2*K2*L0*L1^3*L2^3+12*K0^3*K1^2*K2*L0^2*L1^3*L2^2)*PHI2
+	  +(-32*K0^2*K1^2*K2^2*L0*L1^3-96*K0^2*K1^2*K2^2*L0^2*L1^2
+				      -16*K0^2*K1^2*K2^2*L0^3*L1)
+	   *L2^3*PHI0+4*K0^3*K1^2*K1\_2*L0^2*L1^3*L2^3)
+	  *PSI0^2
+	 +(48*K0^3*K1^2*K2^2*L0^2*L1^3+32*K0^3*K1^2*K2^2*L0^3*L1^2)
+	  *L2^3*PHI0*PSI0-16*K0^4*K1^2*K2^2*L0^3*L1^3*L2^3*PHI0)
+	 *PSI1)
+	*PSI2
+       -(K2^2*L0*L1*L2*PHI2*PSI0^5+((-2*K0*K2^2*L0*L1^2-K0*K2^2*L0^2*L1)*L2
+				   -2*K0*K2^2*L0*L1*L2^2)
+				   *PHI2*PSI0^4
+				  +(K0^2*K2^2*L0*L1*L2^3
+				   +(2*K0^2*K2^2*L0*L1^2+2*K0^2*K2^2*L0^2*L1)
+				    *L2^2
+				   +(K0^2*K2^2*L0*L1^3+2*K0^2*K2^2*L0^2*L1^2)
+				    *L2)
+				   *PHI2*PSI0^3
+				  +(-K0^3*K2^2*L0^2*L1*L2^3
+				   -2*K0^3*K2^2*L0^2*L1^2*L2^2
+				   -K0^3*K2^2*L0^2*L1^3*L2)
+				   *PHI2*PSI0^2)
+	*PSI1^3
+       -(-4*K1*K2^2*L0*L1*L2^2*PHI2*PSI0^5
+	+(4*K0*K1*K2^2*L0*L1*L2^3+(8*K0*K1*K2^2*L0*L1^2+4*K0*K1*K2^2*L0^2*L1)
+				  *L2^2)
+	 *PHI2*PSI0^4
+	+((-4*K0^2*K1*K2^2*L0*L1^2-4*K0^2*K1*K2^2*L0^2*L1)*L2^3
+	 +(-4*K0^2*K1*K2^2*L0*L1^3-8*K0^2*K1*K2^2*L0^2*L1^2)*L2^2)
+	 *PHI2*PSI0^3
+	+(4*K0^3*K1*K2^2*L0^2*L1^2*L2^3+4*K0^3*K1*K2^2*L0^2*L1^3*L2^2)
+	 *PHI2*PSI0^2)
+	*PSI1^2
+       -(4*K1^2*K2^2*L0*L1*L2^3*PHI2*PSI0^5
+	+(-8*K0*K1^2*K2^2*L0*L1^2-4*K0*K1^2*K2^2*L0^2*L1)*L2^3*PHI2*PSI0^4
+	+(4*K0^2*K1^2*K2^2*L0*L1^3+8*K0^2*K1^2*K2^2*L0^2*L1^2)
+	 *L2^3*PHI2*PSI0^3-4*K0^3*K1^2*K2^2*L0^2*L1^3*L2^3*PHI2*PSI0^2)
+	*PSI1,
+      -((L2+L1+L0)*PSI1-2*K1*L1*L2-2*K1*L0*L1)*PSI2
+       -(-2*K2*L0*L2-2*K2*L0*L1)*PSI1-4*K1*K2*L0*L1*L2,
+      -((2*PSI0-K0*L2-K0*L1-K0*L0)*PSI1-2*K1*L1*PSI0+2*K0*K1*L1*L2
+				       +2*K0*K1*L0*L1)
+       *PSI2
+       -((-2*K2*L2-2*K2*L1)*PSI0+2*K0*K2*L0*L2+2*K0*K2*L0*L1)*PSI1
+       -4*K1*K2*L1*L2*PSI0+4*K0*K1*K2*L0*L1*L2,
+      -(((L2^2+L0*L2)*PHI0*PSI0^2+(3*K0*L1*L2^2+(3*K0*L1^2+3*K0*L0*L1)*L2)
+				  *PHI0*PSI0
+				 +(-K0^2*L1*L2^3
+				  +(-2*K0^2*L1^2-2*K0^2*L0*L1)*L2^2
+				  +(-K0^2*L1^3-2*K0^2*L0*L1^2-K0^2*L0^2*L1)
+				   *L2)
+				  *PHI0)
+       *PSI1^3
+       +((-L2^2+(-2*L1-L0)*L2-L0*L1)*PHI1*PSI0^3
+	+((K0*L1*L2^2+(4*K0*L1^2+K0*L0*L1)*L2+2*K0*L0*L1^2)*PHI1
+	 +(2*K1*L1*L2^2+(4*K1*L1^2+2*K1*L0*L1)*L2)*PHI0)
+	 *PSI0^2
+	+(-2*K0*K1*L1*L2^3+(-12*K0*K1*L1^2-4*K0*K1*L0*L1)*L2^2
+			  +(-4*K0*K1*L1^3-12*K0*K1*L0*L1^2-2*K0*K1*L0^2*L1)
+			   *L2)
+	 *PHI0*PSI0
+	+(4*K0^2*K1*L1^2*L2^3+(4*K0^2*K1*L1^3+8*K0^2*K1*L0*L1^2)*L2^2
+			     +(4*K0^2*K1*L0*L1^3+4*K0^2*K1*L0^2*L1^2)*L2)
+	 *PHI0)
+	*PSI1^2
+       +(((2*K1*L1*L2^2+(4*K1*L1^2+2*K1*L0*L1)*L2+3*K1*L0*L1^2)*PHI1
+	+K1\_1*L1^2*L2^2+K1\_1*L0*L1^2*L2)
+	*PSI0^3
+	+((-3*K0*K1*L1^2*L2^2+(-4*K0*K1*L1^3-3*K0*K1*L0*L1^2)*L2
+			     -3*K0*K1*L0*L1^3)
+	 *PHI1
+	 +(-8*K1^2*L1^2*L2^2-8*K1^2*L0*L1^2*L2)*PHI0-K0*K1\_1*L1^3*L2^2
+	 -K0*K1\_1*L0*L1^3*L2)
+	 *PSI0^2
+	+(4*K0*K1^2*L1^2*L2^3+(8*K0*K1^2*L1^3+8*K0*K1^2*L0*L1^2)*L2^2
+			     +(8*K0*K1^2*L0*L1^3+4*K0*K1^2*L0^2*L1^2)*L2)
+	 *PHI0*PSI0
+	+(-4*K0^2*K1^2*L1^3*L2^3-8*K0^2*K1^2*L0*L1^3*L2^2
+				-4*K0^2*K1^2*L0^2*L1^3*L2)
+	 *PHI0)
+	*PSI1+(-K1^2*L1^2*L2^2-K1^2*L0*L1^2*L2)*PHI1*PSI0^3
+       +(K0*K1^2*L1^3*L2^2+K0*K1^2*L0*L1^3*L2)*PHI1*PSI0^2)
+       *PSI2^3
+       -(((2*L1*L2+L0*L1)*PHI2*PSI0^3+((-4*K0*L1*L2^2+(-4*K0*L1^2-K0*L0*L1)*L2
+						     -2*K0*L0*L1^2)
+				      *PHI2
+				      +((4*K2*L1-2*K2*L0)*L2^2
+				       +(4*K2*L1^2+2*K2*L0*L1)*L2)
+				       *PHI0)
+				      *PSI0^2
+				     +(-4*K0*K2*L1*L2^3
+				      +(-8*K0*K2*L1^2-12*K0*K2*L0*L1)*L2^2
+				      +(-4*K0*K2*L1^3-12*K0*K2*L0*L1^2
+						     -2*K0*K2*L0^2*L1)
+				       *L2)
+				      *PHI0*PSI0
+				     +(4*K0^2*K2*L0*L1*L2^3
+				      +(8*K0^2*K2*L0*L1^2+4*K0^2*K2*L0^2*L1)
+				       *L2^2
+				      +(4*K0^2*K2*L0*L1^3+4*K0^2*K2*L0^2*L1^2)
+				       *L2)
+				      *PHI0)
+	*PSI1^3
+	+(((-8*K1*L1*L2^2+(-8*K1*L1^2-2*K1*L0*L1)*L2-4*K1*L0*L1^2)*PHI2
+	 +(2*K2*L0*L2^2+4*K2*L0*L1*L2)*PHI1)
+	 *PSI0^3
+	 +((16*K0*K1*L1^2*L2^2+(8*K0*K1*L1^3+4*K0*K1*L0*L1^2)*L2
+			      +4*K0*K1*L0*L1^3)
+	  *PHI2
+	  +(-2*K0*K2*L0*L1*L2^2-8*K0*K2*L0*L1^2*L2)*PHI1
+	  +(-8*K1*K2*L1*L2^3+(-16*K1*K2*L1^2-12*K1*K2*L0*L1)*L2^2
+			    -16*K1*K2*L0*L1^2*L2)
+	   *PHI0)
+	  *PSI0^2
+	 +((16*K0*K1*K2*L1^2+8*K0*K1*K2*L0*L1)*L2^3
+	  +(16*K0*K1*K2*L1^3+48*K0*K1*K2*L0*L1^2+8*K0*K1*K2*L0^2*L1)*L2^2
+	  +(16*K0*K1*K2*L0*L1^3+8*K0*K1*K2*L0^2*L1^2)*L2)
+	  *PHI0*PSI0
+	 +(-16*K0^2*K1*K2*L0*L1^2*L2^3+(-16*K0^2*K1*K2*L0*L1^3
+				       -16*K0^2*K1*K2*L0^2*L1^2)
+				       *L2^2-8*K0^2*K1*K2*L0^2*L1^3*L2)
+	  *PHI0)
+	 *PSI1^2
+	+(((16*K1^2*L1^2*L2^2+4*K1^2*L0*L1^2*L2)*PHI2
+	 +(-4*K1*K2*L0*L1*L2^2-8*K1*K2*L0*L1^2*L2)*PHI1
+	 -2*K1\_1*K2*L0*L1^2*L2^2)
+	 *PSI0^3
+	 +((-16*K0*K1^2*L1^3*L2^2-4*K0*K1^2*L0*L1^3*L2)*PHI2
+	  +(6*K0*K1*K2*L0*L1^2*L2^2+8*K0*K1*K2*L0*L1^3*L2)*PHI1
+	  +(16*K1^2*K2*L1^2*L2^3+32*K1^2*K2*L0*L1^2*L2^2)*PHI0
+	  +2*K0*K1\_1*K2*L0*L1^3*L2^2)
+	  *PSI0^2
+	 +((-16*K0*K1^2*K2*L1^3-16*K0*K1^2*K2*L0*L1^2)*L2^3
+	  +(-32*K0*K1^2*K2*L0*L1^3-16*K0*K1^2*K2*L0^2*L1^2)*L2^2)
+	  *PHI0*PSI0
+	 +(16*K0^2*K1^2*K2*L0*L1^3*L2^3+16*K0^2*K1^2*K2*L0^2*L1^3*L2^2)*PHI0)
+	 *PSI1+2*K1^2*K2*L0*L1^2*L2^2*PHI1*PSI0^3
+	-2*K0*K1^2*K2*L0*L1^3*L2^2*PHI1*PSI0^2)
+	*PSI2^2
+       -((((-4*K2*L1*L2^2+(-4*K2*L1^2-2*K2*L0*L1)*L2-K2*L0*L1^2)*PHI2
+	-K1\_2*L0*L1*L2^2-K1\_2*L0*L1^2*L2)
+	*PSI0^3
+	+((4*K0*K2*L1*L2^3+(8*K0*K2*L1^2+3*K0*K2*L0*L1)*L2^2
+			  +(4*K0*K2*L1^3+4*K0*K2*L0*L1^2)*L2+K0*K2*L0*L1^3)
+	 *PHI2
+	 +(-8*K2^2*L0*L1*L2^2-8*K2^2*L0*L1^2*L2)*PHI0+K0*K1\_2*L0*L1*L2^3
+	 +2*K0*K1\_2*L0*L1^2*L2^2+K0*K1\_2*L0*L1^3*L2)
+	 *PSI0^2
+	+(8*K0*K2^2*L0*L1*L2^3+(16*K0*K2^2*L0*L1^2+4*K0*K2^2*L0^2*L1)*L2^2
+			      +(8*K0*K2^2*L0*L1^3+4*K0*K2^2*L0^2*L1^2)*L2)
+	 *PHI0*PSI0
+	+(-4*K0^2*K2^2*L0^2*L1*L2^3-8*K0^2*K2^2*L0^2*L1^2*L2^2
+				   -4*K0^2*K2^2*L0^2*L1^3*L2)
+	 *PHI0)
+	*PSI1^3
+	+(((8*K1*K2*L1*L2^3+(16*K1*K2*L1^2+6*K1*K2*L0*L1)*L2^2
+			   +8*K1*K2*L0*L1^2*L2)
+	 *PHI2
+	 +2*K1*K1\_2*L0*L1*L2^3+4*K1*K1\_2*L0*L1^2*L2^2)
+	 *PSI0^3
+	 +((-16*K0*K1*K2*L1^2*L2^3+(-16*K0*K1*K2*L1^3-12*K0*K1*K2*L0*L1^2)
+				   *L2^2-8*K0*K1*K2*L0*L1^3*L2)
+	  *PHI2
+	  +(16*K1*K2^2*L0*L1*L2^3+32*K1*K2^2*L0*L1^2*L2^2)*PHI0
+	  -4*K0*K1*K1\_2*L0*L1^2*L2^3-4*K0*K1*K1\_2*L0*L1^3*L2^2)
+	  *PSI0^2
+	 +((-32*K0*K1*K2^2*L0*L1^2-8*K0*K1*K2^2*L0^2*L1)*L2^3
+	  +(-32*K0*K1*K2^2*L0*L1^3-16*K0*K1*K2^2*L0^2*L1^2)*L2^2)
+	  *PHI0*PSI0
+	 +(16*K0^2*K1*K2^2*L0^2*L1^2*L2^3+16*K0^2*K1*K2^2*L0^2*L1^3*L2^2)
+	  *PHI0)
+	 *PSI1^2
+	+(((-16*K1^2*K2*L1^2*L2^3-12*K1^2*K2*L0*L1^2*L2^2)*PHI2
+	 -4*K1^2*K1\_2*L0*L1^2*L2^3)
+	 *PSI0^3
+	 +((16*K0*K1^2*K2*L1^3*L2^3+12*K0*K1^2*K2*L0*L1^3*L2^2)*PHI2
+	  -32*K1^2*K2^2*L0*L1^2*L2^3*PHI0+4*K0*K1^2*K1\_2*L0*L1^3*L2^3)
+	  *PSI0^2
+	 +(32*K0*K1^2*K2^2*L0*L1^3+16*K0*K1^2*K2^2*L0^2*L1^2)*L2^3*PHI0*PSI0
+	 -16*K0^2*K1^2*K2^2*L0^2*L1^3*L2^3*PHI0)
+	 *PSI1)
+	*PSI2
+       -((K2^2*L0*L1*L2^2+K2^2*L0*L1^2*L2)*PHI2*PSI0^3
+	+(-K0*K2^2*L0*L1*L2^3-2*K0*K2^2*L0*L1^2*L2^2-K0*K2^2*L0*L1^3*L2)
+	 *PHI2*PSI0^2)
+	*PSI1^3
+       -((-2*K1*K2^2*L0*L1*L2^3-4*K1*K2^2*L0*L1^2*L2^2)*PHI2*PSI0^3
+	+(4*K0*K1*K2^2*L0*L1^2*L2^3+4*K0*K1*K2^2*L0*L1^3*L2^2)*PHI2*PSI0^2)
+	*PSI1^2
+       -(4*K1^2*K2^2*L0*L1^2*L2^3*PHI2*PSI0^3
+	-4*K0*K1^2*K2^2*L0*L1^3*L2^3*PHI2*PSI0^2)
+	*PSI1,
+      (((L1-L0)*L2*PHI0*PSI0^3+((K0*L0-3*K0*L1)*L2^2
+			       +(-3*K0*L1^2-3*K0*L0*L1+K0*L0^2)*L2)
+			       *PHI0*PSI0^2
+			      +(K0^2*L1*L2^3+(2*K0^2*L1^2+5*K0^2*L0*L1)*L2^2
+					    +(K0^2*L1^3+5*K0^2*L0*L1^2
+						       +4*K0^2*L0^2*L1)
+					     *L2)
+			       *PHI0*PSI0
+			      +(-K0^3*L0*L1*L2^3
+			       +(-2*K0^3*L0*L1^2-2*K0^3*L0^2*L1)*L2^2
+			       +(-K0^3*L0*L1^3-2*K0^3*L0^2*L1^2-K0^3*L0^3*L1)
+				*L2)
+			       *PHI0)
+       *PSI1^3
+       +((L0*L2+L0*L1)*PHI1*PSI0^4+((-K0*L0*L2^2+(-3*K0*L0*L1-K0*L0^2)*L2
+						-2*K0*L0*L1^2-K0*L0^2*L1)
+				   *PHI1
+				   +((-4*K1*L1^2-2*K1*L0*L1)*L2-4*K1*L1*L2^2)
+				    *PHI0)
+				   *PSI0^3
+				  +((K0^2*L0*L1*L2^2
+				   +(4*K0^2*L0*L1^2+K0^2*L0^2*L1)*L2
+				   +2*K0^2*L0^2*L1^2)
+				   *PHI1
+				   +(2*K0*K1*L1*L2^3
+				    +(12*K0*K1*L1^2+6*K0*K1*L0*L1)*L2^2
+				    +(4*K0*K1*L1^3+16*K0*K1*L0*L1^2
+						  +4*K0*K1*L0^2*L1)
+				     *L2)
+				    *PHI0)
+				   *PSI0^2
+				  +((-4*K0^2*K1*L1^2-2*K0^2*K1*L0*L1)*L2^3
+				   +(-4*K0^2*K1*L1^3-20*K0^2*K1*L0*L1^2
+						    -4*K0^2*K1*L0^2*L1)
+				    *L2^2
+				   +(-8*K0^2*K1*L0*L1^3-16*K0^2*K1*L0^2*L1^2
+						       -2*K0^2*K1*L0^3*L1)
+				    *L2)
+				   *PHI0*PSI0
+				  +(4*K0^3*K1*L0*L1^2*L2^3
+				   +(4*K0^3*K1*L0*L1^3+8*K0^3*K1*L0^2*L1^2)
+				    *L2^2
+				   +(4*K0^3*K1*L0^2*L1^3+4*K0^3*K1*L0^3*L1^2)
+				    *L2)
+				   *PHI0)
+	*PSI1^2
+       +(((-2*K1*L0*L1*L2-3*K1*L0*L1^2)*PHI1-K1\_1*L0*L1^2*L2)*PSI0^4
+	+((2*K0*K1*L0*L1*L2^2+(7*K0*K1*L0*L1^2+2*K0*K1*L0^2*L1)*L2
+			     +3*K0*K1*L0*L1^3+3*K0*K1*L0^2*L1^2)
+	 *PHI1
+	 +(8*K1^2*L1^2*L2^2+8*K1^2*L0*L1^2*L2)*PHI0+K0*K1\_1*L0*L1^2*L2^2
+	 +(K0*K1\_1*L0*L1^3+K0*K1\_1*L0^2*L1^2)*L2)
+	 *PSI0^3
+	+((-3*K0^2*K1*L0*L1^2*L2^2+(-4*K0^2*K1*L0*L1^3-3*K0^2*K1*L0^2*L1^2)*L2
+				  -3*K0^2*K1*L0^2*L1^3)
+	 *PHI1
+	 +(-4*K0*K1^2*L1^2*L2^3+(-8*K0*K1^2*L1^3-16*K0*K1^2*L0*L1^2)*L2^2
+			       +(-8*K0*K1^2*L0*L1^3-12*K0*K1^2*L0^2*L1^2)*L2)
+	  *PHI0-K0^2*K1\_1*L0*L1^3*L2^2-K0^2*K1\_1*L0^2*L1^3*L2)
+	 *PSI0^2
+	+((4*K0^2*K1^2*L1^3+4*K0^2*K1^2*L0*L1^2)*L2^3
+	 +(16*K0^2*K1^2*L0*L1^3+8*K0^2*K1^2*L0^2*L1^2)*L2^2
+	 +(12*K0^2*K1^2*L0^2*L1^3+4*K0^2*K1^2*L0^3*L1^2)*L2)
+	 *PHI0*PSI0
+	+(-4*K0^3*K1^2*L0*L1^3*L2^3-8*K0^3*K1^2*L0^2*L1^3*L2^2
+				   -4*K0^3*K1^2*L0^3*L1^3*L2)
+	 *PHI0)
+	*PSI1+K1^2*L0*L1^2*L2*PHI1*PSI0^4
+       +((-K0*K1^2*L0*L1^3-K0*K1^2*L0^2*L1^2)*L2-K0*K1^2*L0*L1^2*L2^2)
+	*PHI1*PSI0^3
+       +(K0^2*K1^2*L0*L1^3*L2^2+K0^2*K1^2*L0^2*L1^3*L2)*PHI1*PSI0^2)
+       *PSI2^3
+       +(((-L1*L2-L0*L1)*PHI2*PSI0^4+((2*K0*L1*L2^2+(2*K0*L1^2+3*K0*L0*L1)*L2
+						   +2*K0*L0*L1^2+K0*L0^2*L1)
+				     *PHI2
+				     +((2*K2*L0-4*K2*L1)*L2^2
+				      +(-4*K2*L1^2-2*K2*L0*L1)*L2)
+				      *PHI0)
+				     *PSI0^3
+				    +((-4*K0^2*L0*L1*L2^2
+				     +(-4*K0^2*L0*L1^2-K0^2*L0^2*L1)*L2
+				     -2*K0^2*L0^2*L1^2)
+				     *PHI2
+				     +(4*K0*K2*L1*L2^3
+				      +(8*K0*K2*L1^2+16*K0*K2*L0*L1
+						    -2*K0*K2*L0^2)
+				       *L2^2
+				      +(4*K0*K2*L1^3+16*K0*K2*L0*L1^2
+						    +4*K0*K2*L0^2*L1)
+				       *L2)
+				      *PHI0)
+				     *PSI0^2
+				    +(-8*K0^2*K2*L0*L1*L2^3
+				     +(-16*K0^2*K2*L0*L1^2-16*K0^2*K2*L0^2*L1)
+				      *L2^2
+				     +(-8*K0^2*K2*L0*L1^3-16*K0^2*K2*L0^2*L1^2
+							 -2*K0^2*K2*L0^3*L1)
+				      *L2)
+				     *PHI0*PSI0
+				    +(4*K0^3*K2*L0^2*L1*L2^3
+				     +(8*K0^3*K2*L0^2*L1^2+4*K0^3*K2*L0^3*L1)
+				      *L2^2
+				     +(4*K0^3*K2*L0^2*L1^3
+				      +4*K0^3*K2*L0^3*L1^2)
+				      *L2)
+				     *PHI0)
+	*PSI1^3
+	+(((4*K1*L1*L2^2+(4*K1*L1^2+2*K1*L0*L1)*L2+4*K1*L0*L1^2)*PHI2
+	 +(-2*K2*L0*L2^2-4*K2*L0*L1*L2)*PHI1)
+	 *PSI0^4
+	 +(((-8*K0*K1*L1^2-8*K0*K1*L0*L1)*L2^2
+	  +(-4*K0*K1*L1^3-12*K0*K1*L0*L1^2-2*K0*K1*L0^2*L1)*L2-4*K0*K1*L0*L1^3
+	  -4*K0*K1*L0^2*L1^2)
+	  *PHI2
+	  +((2*K0*K2*L0*L1+2*K0*K2*L0^2)*L2^2
+	   +(8*K0*K2*L0*L1^2+4*K0*K2*L0^2*L1)*L2)
+	   *PHI1
+	  +(8*K1*K2*L1*L2^3+(16*K1*K2*L1^2+12*K1*K2*L0*L1)*L2^2
+			   +16*K1*K2*L0*L1^2*L2)
+	   *PHI0)
+	  *PSI0^3
+	 +((16*K0^2*K1*L0*L1^2*L2^2+(8*K0^2*K1*L0*L1^3+4*K0^2*K1*L0^2*L1^2)*L2
+				   +4*K0^2*K1*L0^2*L1^3)
+	  *PHI2
+	  +(-2*K0^2*K2*L0^2*L1*L2^2-8*K0^2*K2*L0^2*L1^2*L2)*PHI1
+	  +((-16*K0*K1*K2*L1^2-16*K0*K1*K2*L0*L1)*L2^3
+	   +(-16*K0*K1*K2*L1^3-64*K0*K1*K2*L0*L1^2-20*K0*K1*K2*L0^2*L1)*L2^2
+	   +(-16*K0*K1*K2*L0*L1^3-24*K0*K1*K2*L0^2*L1^2)*L2)
+	   *PHI0)
+	  *PSI0^2
+	 +((32*K0^2*K1*K2*L0*L1^2+8*K0^2*K1*K2*L0^2*L1)*L2^3
+	  +(32*K0^2*K1*K2*L0*L1^3+64*K0^2*K1*K2*L0^2*L1^2
+				 +8*K0^2*K1*K2*L0^3*L1)
+	   *L2^2+(24*K0^2*K1*K2*L0^2*L1^3+8*K0^2*K1*K2*L0^3*L1^2)*L2)
+	  *PHI0*PSI0
+	 +(-16*K0^3*K1*K2*L0^2*L1^2*L2^3
+	  +(-16*K0^3*K1*K2*L0^2*L1^3-16*K0^3*K1*K2*L0^3*L1^2)*L2^2
+	  -8*K0^3*K1*K2*L0^3*L1^3*L2)
+	  *PHI0)
+	 *PSI1^2
+	+(((-8*K1^2*L1^2*L2^2-4*K1^2*L0*L1^2*L2)*PHI2
+	 +(4*K1*K2*L0*L1*L2^2+8*K1*K2*L0*L1^2*L2)*PHI1
+	 +2*K1\_1*K2*L0*L1^2*L2^2)
+	 *PSI0^4
+	 +(((8*K0*K1^2*L1^3+16*K0*K1^2*L0*L1^2)*L2^2
+	  +(4*K0*K1^2*L0*L1^3+4*K0*K1^2*L0^2*L1^2)*L2)
+	  *PHI2
+	  +((-6*K0*K1*K2*L0*L1^2-4*K0*K1*K2*L0^2*L1)*L2^2
+	   +(-8*K0*K1*K2*L0*L1^3-8*K0*K1*K2*L0^2*L1^2)*L2)
+	   *PHI1+(-16*K1^2*K2*L1^2*L2^3-32*K1^2*K2*L0*L1^2*L2^2)*PHI0
+	  +(-2*K0*K1\_1*K2*L0*L1^3-2*K0*K1\_1*K2*L0^2*L1^2)*L2^2)
+	  *PSI0^3
+	 +((-16*K0^2*K1^2*L0*L1^3*L2^2-4*K0^2*K1^2*L0^2*L1^3*L2)*PHI2
+	  +(6*K0^2*K1*K2*L0^2*L1^2*L2^2+8*K0^2*K1*K2*L0^2*L1^3*L2)*PHI1
+	  +((16*K0*K1^2*K2*L1^3+32*K0*K1^2*K2*L0*L1^2)*L2^3
+	   +(32*K0*K1^2*K2*L0*L1^3+48*K0*K1^2*K2*L0^2*L1^2)*L2^2)
+	   *PHI0+2*K0^2*K1\_1*K2*L0^2*L1^3*L2^2)
+	  *PSI0^2
+	 +((-32*K0^2*K1^2*K2*L0*L1^3-16*K0^2*K1^2*K2*L0^2*L1^2)*L2^3
+	  +(-48*K0^2*K1^2*K2*L0^2*L1^3-16*K0^2*K1^2*K2*L0^3*L1^2)*L2^2)
+	  *PHI0*PSI0
+	 +(16*K0^3*K1^2*K2*L0^2*L1^3*L2^3+16*K0^3*K1^2*K2*L0^3*L1^3*L2^2)
+	  *PHI0)
+	 *PSI1-2*K1^2*K2*L0*L1^2*L2^2*PHI1*PSI0^4
+	+(2*K0*K1^2*K2*L0*L1^3+2*K0*K1^2*K2*L0^2*L1^2)*L2^2*PHI1*PSI0^3
+	-2*K0^2*K1^2*K2*L0^2*L1^3*L2^2*PHI1*PSI0^2)
+	*PSI2^2
+       +((((3*K2*L1*L2^2+(3*K2*L1^2+2*K2*L0*L1)*L2+K2*L0*L1^2)*PHI2
+	+K1\_2*L0*L1*L2^2+K1\_2*L0*L1^2*L2)
+	*PSI0^4
+	+((-3*K0*K2*L1*L2^3+(-6*K0*K2*L1^2-7*K0*K2*L0*L1)*L2^2
+			   +(-3*K0*K2*L1^3-8*K0*K2*L0*L1^2-2*K0*K2*L0^2*L1)*L2
+			   -K0*K2*L0*L1^3-K0*K2*L0^2*L1^2)
+	 *PHI2
+	 +(8*K2^2*L0*L1*L2^2+8*K2^2*L0*L1^2*L2)*PHI0-K0*K1\_2*L0*L1*L2^3
+	 +(-2*K0*K1\_2*L0*L1^2-K0*K1\_2*L0^2*L1)*L2^2
+	 +(-K0*K1\_2*L0*L1^3-K0*K1\_2*L0^2*L1^2)*L2)
+	 *PSI0^3
+	+((4*K0^2*K2*L0*L1*L2^3+(8*K0^2*K2*L0*L1^2+3*K0^2*K2*L0^2*L1)*L2^2
+			       +(4*K0^2*K2*L0*L1^3+4*K0^2*K2*L0^2*L1^2)*L2
+			       +K0^2*K2*L0^2*L1^3)
+	 *PHI2
+	 +(-8*K0*K2^2*L0*L1*L2^3+(-16*K0*K2^2*L0*L1^2-12*K0*K2^2*L0^2*L1)*L2^2
+				+(-8*K0*K2^2*L0*L1^3-12*K0*K2^2*L0^2*L1^2)*L2)
+	  *PHI0+K0^2*K1\_2*L0^2*L1*L2^3+2*K0^2*K1\_2*L0^2*L1^2*L2^2
+	 +K0^2*K1\_2*L0^2*L1^3*L2)
+	 *PSI0^2
+	+(12*K0^2*K2^2*L0^2*L1*L2^3+(24*K0^2*K2^2*L0^2*L1^2
+				    +4*K0^2*K2^2*L0^3*L1)
+				    *L2^2
+				   +(12*K0^2*K2^2*L0^2*L1^3
+				    +4*K0^2*K2^2*L0^3*L1^2)
+				    *L2)
+	 *PHI0*PSI0
+	+(-4*K0^3*K2^2*L0^3*L1*L2^3-8*K0^3*K2^2*L0^3*L1^2*L2^2
+				   -4*K0^3*K2^2*L0^3*L1^3*L2)
+	 *PHI0)
+	*PSI1^3
+	+(((-6*K1*K2*L1*L2^3+(-12*K1*K2*L1^2-6*K1*K2*L0*L1)*L2^2
+			    -8*K1*K2*L0*L1^2*L2)
+	 *PHI2
+	 -2*K1*K1\_2*L0*L1*L2^3-4*K1*K1\_2*L0*L1^2*L2^2)
+	 *PSI0^4
+	 +(((12*K0*K1*K2*L1^2+8*K0*K1*K2*L0*L1)*L2^3
+	  +(12*K0*K1*K2*L1^3+28*K0*K1*K2*L0*L1^2+6*K0*K1*K2*L0^2*L1)*L2^2
+	  +(8*K0*K1*K2*L0*L1^3+8*K0*K1*K2*L0^2*L1^2)*L2)
+	  *PHI2
+	  +(-16*K1*K2^2*L0*L1*L2^3-32*K1*K2^2*L0*L1^2*L2^2)*PHI0
+	  +(4*K0*K1*K1\_2*L0*L1^2+2*K0*K1*K1\_2*L0^2*L1)*L2^3
+	  +(4*K0*K1*K1\_2*L0*L1^3+4*K0*K1*K1\_2*L0^2*L1^2)*L2^2)
+	  *PSI0^3
+	 +((-16*K0^2*K1*K2*L0*L1^2*L2^3+(-16*K0^2*K1*K2*L0*L1^3
+					-12*K0^2*K1*K2*L0^2*L1^2)
+					*L2^2-8*K0^2*K1*K2*L0^2*L1^3*L2)
+	  *PHI2
+	  +((32*K0*K1*K2^2*L0*L1^2+24*K0*K1*K2^2*L0^2*L1)*L2^3
+	   +(32*K0*K1*K2^2*L0*L1^3+48*K0*K1*K2^2*L0^2*L1^2)*L2^2)
+	   *PHI0-4*K0^2*K1*K1\_2*L0^2*L1^2*L2^3
+	  -4*K0^2*K1*K1\_2*L0^2*L1^3*L2^2)
+	  *PSI0^2
+	 +((-48*K0^2*K1*K2^2*L0^2*L1^2-8*K0^2*K1*K2^2*L0^3*L1)*L2^3
+	  +(-48*K0^2*K1*K2^2*L0^2*L1^3-16*K0^2*K1*K2^2*L0^3*L1^2)*L2^2)
+	  *PHI0*PSI0
+	 +(16*K0^3*K1*K2^2*L0^3*L1^2*L2^3+16*K0^3*K1*K2^2*L0^3*L1^3*L2^2)
+	  *PHI0)
+	 *PSI1^2
+	+(((12*K1^2*K2*L1^2*L2^3+12*K1^2*K2*L0*L1^2*L2^2)*PHI2
+	 +4*K1^2*K1\_2*L0*L1^2*L2^3)
+	 *PSI0^4
+	 +(((-12*K0*K1^2*K2*L1^3-16*K0*K1^2*K2*L0*L1^2)*L2^3
+	  +(-12*K0*K1^2*K2*L0*L1^3-12*K0*K1^2*K2*L0^2*L1^2)*L2^2)
+	  *PHI2
+	  +32*K1^2*K2^2*L0*L1^2*L2^3*PHI0
+	  +(-4*K0*K1^2*K1\_2*L0*L1^3-4*K0*K1^2*K1\_2*L0^2*L1^2)*L2^3)
+	  *PSI0^3
+	 +((16*K0^2*K1^2*K2*L0*L1^3*L2^3+12*K0^2*K1^2*K2*L0^2*L1^3*L2^2)*PHI2
+	  +(-32*K0*K1^2*K2^2*L0*L1^3-48*K0*K1^2*K2^2*L0^2*L1^2)*L2^3*PHI0
+	  +4*K0^2*K1^2*K1\_2*L0^2*L1^3*L2^3)
+	  *PSI0^2
+	 +(48*K0^2*K1^2*K2^2*L0^2*L1^3+16*K0^2*K1^2*K2^2*L0^3*L1^2)
+	  *L2^3*PHI0*PSI0-16*K0^3*K1^2*K2^2*L0^3*L1^3*L2^3*PHI0)
+	 *PSI1)
+	*PSI2
+       +((-K2^2*L0*L1*L2^2-K2^2*L0*L1^2*L2)*PHI2*PSI0^4
+	+(K0*K2^2*L0*L1*L2^3+(2*K0*K2^2*L0*L1^2+K0*K2^2*L0^2*L1)*L2^2
+			    +(K0*K2^2*L0*L1^3+K0*K2^2*L0^2*L1^2)*L2)
+	 *PHI2*PSI0^3
+	+(-K0^2*K2^2*L0^2*L1*L2^3-2*K0^2*K2^2*L0^2*L1^2*L2^2
+				 -K0^2*K2^2*L0^2*L1^3*L2)
+	 *PHI2*PSI0^2)
+	*PSI1^3
+       +((2*K1*K2^2*L0*L1*L2^3+4*K1*K2^2*L0*L1^2*L2^2)*PHI2*PSI0^4
+	+((-4*K0*K1*K2^2*L0*L1^2-2*K0*K1*K2^2*L0^2*L1)*L2^3
+	 +(-4*K0*K1*K2^2*L0*L1^3-4*K0*K1*K2^2*L0^2*L1^2)*L2^2)
+	 *PHI2*PSI0^3
+	+(4*K0^2*K1*K2^2*L0^2*L1^2*L2^3+4*K0^2*K1*K2^2*L0^2*L1^3*L2^2)
+	 *PHI2*PSI0^2)
+	*PSI1^2
+       +(-4*K1^2*K2^2*L0*L1^2*L2^3*PHI2*PSI0^4
+	+(4*K0*K1^2*K2^2*L0*L1^3+4*K0*K1^2*K2^2*L0^2*L1^2)*L2^3*PHI2*PSI0^3
+	-4*K0^2*K1^2*K2^2*L0^2*L1^3*L2^3*PHI2*PSI0^2)
+	*PSI1,
+      (((3*L2^2+(3*L1+3*L0)*L2)*PHI0*PSI0
+       +(-K0*L2^3+(-2*K0*L1-2*K0*L0)*L2^2+(-K0*L1^2-2*K0*L0*L1-K0*L0^2)*L2)
+	*PHI0)
+       *PSI1^3
+       +((L2^2+(4*L1+L0)*L2+2*L0*L1)*PHI1*PSI0^2
+	+((-4*K1*L1^2-10*K1*L0*L1)*L2-10*K1*L1*L2^2)*PHI0*PSI0
+	+(4*K0*K1*L1*L2^3+(4*K0*K1*L1^2+8*K0*K1*L0*L1)*L2^2
+			 +(4*K0*K1*L0*L1^2+4*K0*K1*L0^2*L1)*L2)
+	 *PHI0)
+	*PSI1^2
+       +(((-3*K1*L1*L2^2+(-4*K1*L1^2-3*K1*L0*L1)*L2-3*K1*L0*L1^2)*PHI1
+	-K1\_1*L1^2*L2^2-K1\_1*L0*L1^2*L2)
+	*PSI0^2
+	+(8*K1^2*L1^2*L2^2+8*K1^2*L0*L1^2*L2)*PHI0*PSI0
+	+(-4*K0*K1^2*L1^2*L2^3-8*K0*K1^2*L0*L1^2*L2^2-4*K0*K1^2*L0^2*L1^2*L2)
+	 *PHI0)
+	*PSI1+(K1^2*L1^2*L2^2+K1^2*L0*L1^2*L2)*PHI1*PSI0^2)
+       *PSI2^3
+       +(((-4*L2^2+(-4*L1-L0)*L2-2*L0*L1)*PHI2*PSI0^2
+	+(-4*K2*L2^3+(-8*K2*L1-10*K2*L0)*L2^2+(-4*K2*L1^2-10*K2*L0*L1)*L2)
+	 *PHI0*PSI0
+	+(4*K0*K2*L0*L2^3+(8*K0*K2*L0*L1+4*K0*K2*L0^2)*L2^2
+			 +(4*K0*K2*L0*L1^2+4*K0*K2*L0^2*L1)*L2)
+	 *PHI0)
+	*PSI1^3
+	+(((16*K1*L1*L2^2+(8*K1*L1^2+4*K1*L0*L1)*L2+4*K1*L0*L1^2)*PHI2
+	 +(-2*K2*L0*L2^2-8*K2*L0*L1*L2)*PHI1)
+	 *PSI0^2
+	 +(16*K1*K2*L1*L2^3+(16*K1*K2*L1^2+36*K1*K2*L0*L1)*L2^2
+			   +16*K1*K2*L0*L1^2*L2)
+	  *PHI0*PSI0
+	 +(-16*K0*K1*K2*L0*L1*L2^3+(-16*K0*K1*K2*L0*L1^2-16*K0*K1*K2*L0^2*L1)
+				   *L2^2-8*K0*K1*K2*L0^2*L1^2*L2)
+	  *PHI0)
+	 *PSI1^2
+	+(((-16*K1^2*L1^2*L2^2-4*K1^2*L0*L1^2*L2)*PHI2
+	 +(6*K1*K2*L0*L1*L2^2+8*K1*K2*L0*L1^2*L2)*PHI1
+	 +2*K1\_1*K2*L0*L1^2*L2^2)
+	 *PSI0^2
+	 +(-16*K1^2*K2*L1^2*L2^3-32*K1^2*K2*L0*L1^2*L2^2)*PHI0*PSI0
+	 +(16*K0*K1^2*K2*L0*L1^2*L2^3+16*K0*K1^2*K2*L0^2*L1^2*L2^2)*PHI0)
+	 *PSI1-2*K1^2*K2*L0*L1^2*L2^2*PHI1*PSI0^2)
+	*PSI2^2
+       +((((4*K2*L2^3+(8*K2*L1+3*K2*L0)*L2^2+(4*K2*L1^2+4*K2*L0*L1)*L2
+		     +K2*L0*L1^2)
+	*PHI2
+	+K1\_2*L0*L2^3+2*K1\_2*L0*L1*L2^2+K1\_2*L0*L1^2*L2)
+	*PSI0^2
+	+(8*K2^2*L0*L2^3+16*K2^2*L0*L1*L2^2+8*K2^2*L0*L1^2*L2)*PHI0*PSI0
+	+(-4*K0*K2^2*L0^2*L2^3-8*K0*K2^2*L0^2*L1*L2^2-4*K0*K2^2*L0^2*L1^2*L2)
+	 *PHI0)
+	*PSI1^3
+	+(((-16*K1*K2*L1*L2^3+(-16*K1*K2*L1^2-12*K1*K2*L0*L1)*L2^2
+			     -8*K1*K2*L0*L1^2*L2)
+	 *PHI2
+	 -4*K1*K1\_2*L0*L1*L2^3-4*K1*K1\_2*L0*L1^2*L2^2)
+	 *PSI0^2
+	 +(-32*K1*K2^2*L0*L1*L2^3-32*K1*K2^2*L0*L1^2*L2^2)*PHI0*PSI0
+	 +(16*K0*K1*K2^2*L0^2*L1*L2^3+16*K0*K1*K2^2*L0^2*L1^2*L2^2)*PHI0)
+	 *PSI1^2
+	+(((16*K1^2*K2*L1^2*L2^3+12*K1^2*K2*L0*L1^2*L2^2)*PHI2
+	 +4*K1^2*K1\_2*L0*L1^2*L2^3)
+	 *PSI0^2
+	 +32*K1^2*K2^2*L0*L1^2*L2^3*PHI0*PSI0
+	 -16*K0*K1^2*K2^2*L0^2*L1^2*L2^3*PHI0)
+	 *PSI1)
+	*PSI2
+       +(-K2^2*L0*L2^3-2*K2^2*L0*L1*L2^2-K2^2*L0*L1^2*L2)*PHI2*PSI0^2*PSI1^3
+       +(4*K1*K2^2*L0*L1*L2^3+4*K1*K2^2*L0*L1^2*L2^2)*PHI2*PSI0^2*PSI1^2
+       -4*K1^2*K2^2*L0*L1^2*L2^3*PHI2*PSI0^2*PSI1,
+      (((2*L2^2+(2*L1+3*L0)*L2)*PHI0*PSI0^2
+       +(-K0*L2^3+(-2*K0*L1-5*K0*L0)*L2^2+(-K0*L1^2-5*K0*L0*L1-4*K0*L0^2)*L2)
+	*PHI0*PSI0
+       +(K0^2*L0*L2^3+(2*K0^2*L0*L1+2*K0^2*L0^2)*L2^2
+		     +(K0^2*L0*L1^2+2*K0^2*L0^2*L1+K0^2*L0^3)*L2)
+	*PHI0)
+       *PSI1^3
+       +((L0*L2+2*L0*L1)*PHI1*PSI0^3+((-K0*L0*L2^2+(-4*K0*L0*L1-K0*L0^2)*L2
+						  -2*K0*L0^2*L1)
+				     *PHI1
+				     +((-4*K1*L1^2-10*K1*L0*L1)*L2
+				      -8*K1*L1*L2^2)
+				      *PHI0)
+				     *PSI0^2
+				    +(4*K0*K1*L1*L2^3
+				     +(4*K0*K1*L1^2+18*K0*K1*L0*L1)*L2^2
+				     +(8*K0*K1*L0*L1^2+14*K0*K1*L0^2*L1)*L2)
+				     *PHI0*PSI0
+				    +(-4*K0^2*K1*L0*L1*L2^3
+				     +(-4*K0^2*K1*L0*L1^2-8*K0^2*K1*L0^2*L1)
+				      *L2^2
+				     +(-4*K0^2*K1*L0^2*L1^2-4*K0^2*K1*L0^3*L1)
+				      *L2)
+				     *PHI0)
+	*PSI1^2
+       +(((-3*K1*L0*L1*L2-3*K1*L0*L1^2)*PHI1-K1\_1*L0*L1^2*L2)*PSI0^3
+	+((3*K0*K1*L0*L1*L2^2+(4*K0*K1*L0*L1^2+3*K0*K1*L0^2*L1)*L2
+			     +3*K0*K1*L0^2*L1^2)
+	 *PHI1
+	 +(8*K1^2*L1^2*L2^2+8*K1^2*L0*L1^2*L2)*PHI0+K0*K1\_1*L0*L1^2*L2^2
+	 +K0*K1\_1*L0^2*L1^2*L2)
+	 *PSI0^2
+	+(-4*K0*K1^2*L1^2*L2^3-16*K0*K1^2*L0*L1^2*L2^2
+			      -12*K0*K1^2*L0^2*L1^2*L2)
+	 *PHI0*PSI0
+	+(4*K0^2*K1^2*L0*L1^2*L2^3+8*K0^2*K1^2*L0^2*L1^2*L2^2
+				  +4*K0^2*K1^2*L0^3*L1^2*L2)
+	 *PHI0)
+	*PSI1+K1^2*L0*L1^2*L2*PHI1*PSI0^3
+       +(-K0*K1^2*L0*L1^2*L2^2-K0*K1^2*L0^2*L1^2*L2)*PHI1*PSI0^2)
+       *PSI2^3
+       +(((-2*L2^2+(-2*L1-L0)*L2-2*L0*L1)*PHI2*PSI0^3
+	+((4*K0*L0*L2^2+(4*K0*L0*L1+K0*L0^2)*L2+2*K0*L0^2*L1)*PHI2
+	 +(-4*K2*L2^3+(-8*K2*L1-10*K2*L0)*L2^2+(-4*K2*L1^2-10*K2*L0*L1)*L2)
+	  *PHI0)
+	 *PSI0^2
+	+(8*K0*K2*L0*L2^3+(16*K0*K2*L0*L1+14*K0*K2*L0^2)*L2^2
+			 +(8*K0*K2*L0*L1^2+14*K0*K2*L0^2*L1)*L2)
+	 *PHI0*PSI0
+	+(-4*K0^2*K2*L0^2*L2^3+(-8*K0^2*K2*L0^2*L1-4*K0^2*K2*L0^3)*L2^2
+			      +(-4*K0^2*K2*L0^2*L1^2-4*K0^2*K2*L0^3*L1)*L2)
+	 *PHI0)
+	*PSI1^3
+	+(((8*K1*L1*L2^2+(4*K1*L1^2+4*K1*L0*L1)*L2+4*K1*L0*L1^2)*PHI2
+	 +(-2*K2*L0*L2^2-8*K2*L0*L1*L2)*PHI1)
+	 *PSI0^3
+	 +((-16*K0*K1*L0*L1*L2^2+(-8*K0*K1*L0*L1^2-4*K0*K1*L0^2*L1)*L2
+				-4*K0*K1*L0^2*L1^2)
+	  *PHI2
+	  +(2*K0*K2*L0^2*L2^2+8*K0*K2*L0^2*L1*L2)*PHI1
+	  +(16*K1*K2*L1*L2^3+(16*K1*K2*L1^2+36*K1*K2*L0*L1)*L2^2
+			    +16*K1*K2*L0*L1^2*L2)
+	   *PHI0)
+	  *PSI0^2
+	 +(-32*K0*K1*K2*L0*L1*L2^3+(-32*K0*K1*K2*L0*L1^2-52*K0*K1*K2*L0^2*L1)
+				   *L2^2-24*K0*K1*K2*L0^2*L1^2*L2)
+	  *PHI0*PSI0
+	 +(16*K0^2*K1*K2*L0^2*L1*L2^3+(16*K0^2*K1*K2*L0^2*L1^2
+				      +16*K0^2*K1*K2*L0^3*L1)
+				      *L2^2+8*K0^2*K1*K2*L0^3*L1^2*L2)
+	  *PHI0)
+	 *PSI1^2
+	+(((-8*K1^2*L1^2*L2^2-4*K1^2*L0*L1^2*L2)*PHI2
+	 +(6*K1*K2*L0*L1*L2^2+8*K1*K2*L0*L1^2*L2)*PHI1
+	 +2*K1\_1*K2*L0*L1^2*L2^2)
+	 *PSI0^3
+	 +((16*K0*K1^2*L0*L1^2*L2^2+4*K0*K1^2*L0^2*L1^2*L2)*PHI2
+	  +(-6*K0*K1*K2*L0^2*L1*L2^2-8*K0*K1*K2*L0^2*L1^2*L2)*PHI1
+	  +(-16*K1^2*K2*L1^2*L2^3-32*K1^2*K2*L0*L1^2*L2^2)*PHI0
+	  -2*K0*K1\_1*K2*L0^2*L1^2*L2^2)
+	  *PSI0^2
+	 +(32*K0*K1^2*K2*L0*L1^2*L2^3+48*K0*K1^2*K2*L0^2*L1^2*L2^2)*PHI0*PSI0
+	 +(-16*K0^2*K1^2*K2*L0^2*L1^2*L2^3-16*K0^2*K1^2*K2*L0^3*L1^2*L2^2)
+	  *PHI0)
+	 *PSI1-2*K1^2*K2*L0*L1^2*L2^2*PHI1*PSI0^3
+	+2*K0*K1^2*K2*L0^2*L1^2*L2^2*PHI1*PSI0^2)
+	*PSI2^2
+       +((((3*K2*L2^3+(6*K2*L1+3*K2*L0)*L2^2+(3*K2*L1^2+4*K2*L0*L1)*L2
+		     +K2*L0*L1^2)
+	*PHI2
+	+K1\_2*L0*L2^3+2*K1\_2*L0*L1*L2^2+K1\_2*L0*L1^2*L2)
+	*PSI0^3
+	+((-4*K0*K2*L0*L2^3+(-8*K0*K2*L0*L1-3*K0*K2*L0^2)*L2^2
+			   +(-4*K0*K2*L0*L1^2-4*K0*K2*L0^2*L1)*L2
+			   -K0*K2*L0^2*L1^2)
+	 *PHI2
+	 +(8*K2^2*L0*L2^3+16*K2^2*L0*L1*L2^2+8*K2^2*L0*L1^2*L2)*PHI0
+	 -K0*K1\_2*L0^2*L2^3-2*K0*K1\_2*L0^2*L1*L2^2-K0*K1\_2*L0^2*L1^2*L2)
+	 *PSI0^2
+	+(-12*K0*K2^2*L0^2*L2^3-24*K0*K2^2*L0^2*L1*L2^2
+			       -12*K0*K2^2*L0^2*L1^2*L2)
+	 *PHI0*PSI0
+	+(4*K0^2*K2^2*L0^3*L2^3+8*K0^2*K2^2*L0^3*L1*L2^2
+			       +4*K0^2*K2^2*L0^3*L1^2*L2)
+	 *PHI0)
+	*PSI1^3
+	+(((-12*K1*K2*L1*L2^3+(-12*K1*K2*L1^2-12*K1*K2*L0*L1)*L2^2
+			     -8*K1*K2*L0*L1^2*L2)
+	 *PHI2
+	 -4*K1*K1\_2*L0*L1*L2^3-4*K1*K1\_2*L0*L1^2*L2^2)
+	 *PSI0^3
+	 +((16*K0*K1*K2*L0*L1*L2^3+(16*K0*K1*K2*L0*L1^2+12*K0*K1*K2*L0^2*L1)
+				   *L2^2+8*K0*K1*K2*L0^2*L1^2*L2)
+	  *PHI2
+	  +(-32*K1*K2^2*L0*L1*L2^3-32*K1*K2^2*L0*L1^2*L2^2)*PHI0
+	  +4*K0*K1*K1\_2*L0^2*L1*L2^3+4*K0*K1*K1\_2*L0^2*L1^2*L2^2)
+	  *PSI0^2
+	 +(48*K0*K1*K2^2*L0^2*L1*L2^3+48*K0*K1*K2^2*L0^2*L1^2*L2^2)*PHI0*PSI0
+	 +(-16*K0^2*K1*K2^2*L0^3*L1*L2^3-16*K0^2*K1*K2^2*L0^3*L1^2*L2^2)*PHI0)
+	 *PSI1^2
+	+(((12*K1^2*K2*L1^2*L2^3+12*K1^2*K2*L0*L1^2*L2^2)*PHI2
+	 +4*K1^2*K1\_2*L0*L1^2*L2^3)
+	 *PSI0^3
+	 +((-16*K0*K1^2*K2*L0*L1^2*L2^3-12*K0*K1^2*K2*L0^2*L1^2*L2^2)*PHI2
+	  +32*K1^2*K2^2*L0*L1^2*L2^3*PHI0-4*K0*K1^2*K1\_2*L0^2*L1^2*L2^3)
+	  *PSI0^2-48*K0*K1^2*K2^2*L0^2*L1^2*L2^3*PHI0*PSI0
+	 +16*K0^2*K1^2*K2^2*L0^3*L1^2*L2^3*PHI0)
+	 *PSI1)
+	*PSI2
+       +((-K2^2*L0*L2^3-2*K2^2*L0*L1*L2^2-K2^2*L0*L1^2*L2)*PHI2*PSI0^3
+	+(K0*K2^2*L0^2*L2^3+2*K0*K2^2*L0^2*L1*L2^2+K0*K2^2*L0^2*L1^2*L2)
+	 *PHI2*PSI0^2)
+	*PSI1^3
+       +((4*K1*K2^2*L0*L1*L2^3+4*K1*K2^2*L0*L1^2*L2^2)*PHI2*PSI0^3
+	+(-4*K0*K1*K2^2*L0^2*L1*L2^3-4*K0*K1*K2^2*L0^2*L1^2*L2^2)*PHI2*PSI0^2)
+	*PSI1^2
+       +(4*K0*K1^2*K2^2*L0^2*L1^2*L2^3*PHI2*PSI0^2
+	-4*K1^2*K2^2*L0*L1^2*L2^3*PHI2*PSI0^3)
+	*PSI1,PSI0^2+PHI0^2-1,PSI1^2+PHI1^2-1,PSI2^2+PHI2^2-1,
+      2*PHI0*PSI0*ST0+CT0*PSI0^2-CT0*PHI0^2+CT1,
+      2*PHI1*PSI1*ST1+CT1*PSI1^2-CT1*PHI1^2+CT2,
+      2*PHI2*PSI2*ST2+CT2*PSI2^2-CT2*PHI2^2+CT0,
+      ST1-2*PHI0*PSI0*ST0+CT0*PSI0^2-CT0*PHI0^2,
+      ST2-2*PHI1*PSI1*ST1+CT1*PSI1^2-CT1*PHI1^2,
+      -2*PHI2*PSI2*ST2+ST0+CT2*PSI2^2-CT2*PHI2^2,CT2*L2+CT1*L1+CT0*L0,
+      L2*ST2+L1*ST1+L0*ST0]"
+		;;"[K0,K1,K2,L0,L1,L2,PSI0,PSI1,PSI2,PHI2,PHI0,K1\_2,PHI1,K1\_1,K1\_0,CT1, CT0,ST0,CT2,ST1,ST2]"
+		"[CT0,ST0,K0,L0,PHI0,PSI0,K1\_0,CT1,ST1,K1,L1,PHI1,PSI1,K1\_1,CT2,ST2,K2,L2,PHI2,PSI2,K1\_2]"
+		:order #'lex>)
Index: /trunk/examples/chemistry.lisp
===================================================================
--- /trunk/examples/chemistry.lisp	(revision 8)
+++ /trunk/examples/chemistry.lisp	(revision 8)
@@ -0,0 +1,9 @@
+#|
+This is the xample from Weispfenning paper on p. 26
+|#
+(string-grobner-system
+ "[x4-a4+a2,x1+x2+x3+x4+a1+a3+a4,x1*x3+x1*x4+x2*x3+x3*x4-a1*a4-a1*a3-a3*a4,x1*x3*x4-a1*a3*a4]" '(x1 x2 x3 x4) '(a1 a2 a3 a4)
+:parameter-order #'lex>
+:green-reduce t
+:mark-coefficients nil
+)
Index: /trunk/examples/chemistry.output
===================================================================
--- /trunk/examples/chemistry.output	(revision 8)
+++ /trunk/examples/chemistry.output	(revision 8)
@@ -0,0 +1,25 @@
+Starts dribbling to chemistry.output (1996/6/4, 14:58:11).
+NIL
+
+>
+(load "chemistry")Loading chemistry.lisp
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ A2 - A4 ]
+ Basis: [ (1) * X4 + (A2 - A4), (A2 - A4) * X1 + (1) * X3^2 + (A1 + A3 + A4) * X3 + (A1 * A3 + A1 * A4 + A3 * A4), (A2 - A4) * X2 + ( - 1) * X3^2 + ( - A1 + A2 - A3 - 2 * A4) * X3 + (A1 * A2 - A1 * A3 - 2 * A1 * A4 - A2^2 + A2 * A3 + 3 * A2 * A4 - 2 * A3 * A4 - 2 * A4^2), (1) * X3^3 + (A1 + A3 + A4) * X3^2 + (A1 * A3 + A1 * A4 + A3 * A4) * X3 + ( - A1 * A3 * A4) ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [ A2 - A4 ]
+  Red list: [ A1 * A2^2 - A1 * A2 * A3 - 3 * A1 * A2 * A4 + 2 * A1 * A4^2 - A2^3 + A2^2 * A3 + 4 * A2^2 * A4 - 3 * A2 * A3 * A4 - 5 * A2 * A4^2 + 2 * A3 * A4^2 + 2 * A4^3 ]
+ Basis: [ ( - A1 * A3 * A4) ]
+------------------- CASE 3 -------------------
+Condition:
+  Green list: [ A2 - A4, A1 * A3 * A4 ]
+  Red list: [  ]
+ Basis: [ (1) * X4, (1) * X1 + (1) * X2 + (1) * X3 + (A1 + A3 + A4), ( - 1) * X3^2 + ( - A1 - A3 - A4) * X3 + ( - A1 * A3 - A1 * A4 - A3 * A4) ]
+Finished loading chemistry.lisp
+T
+
+>
+(dribble)
Index: /trunk/examples/colored-poly-tests.output
===================================================================
--- /trunk/examples/colored-poly-tests.output	(revision 8)
+++ /trunk/examples/colored-poly-tests.output	(revision 8)
@@ -0,0 +1,403 @@
+Starts dribbling to colored-poly-tests.output (1995/4/30, 18:32:27).
+real time : 0.083 secs
+run time  : 0.000 secs
+VALUES--> (NIL)
+
+EVAL> (WARN "Test 1")
+Warning: Test 1
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (NIL)
+
+EVAL> (STRING-GROBNER-SYSTEM "[4*x^2-3*x*y,4*x+5*y]" '(X Y) 'NIL)
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [  ]
+ Basis: [ (4) * X + (5) * Y, ( - 10) * Y^2 ]
+real time : 0.117 secs
+run time  : 0.033 secs
+VALUES--> NIL
+
+EVAL> (WARN "Test 2 - Enneper")
+Warning: Test 2 - Enneper
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (NIL)
+
+EVAL> (SETF VAL1
+            (STRING-GROBNER-SYSTEM
+                "[x-3*u-3*u*v^2+u^3,y-3*v-3*u^2*v+v^3,z-3*u^2+3*v^2]"
+                '(U V X Y Z) 'NIL :SUPPRESS-VALUE T))
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [  ]
+ Basis: [ ( - 3) * U^2 + (3) * V^2 + (1) * Z, (2) * V^3 + (1) * V * Z + (3) * V + ( - 1) * Y, ( - 6) * U * V^2 + (1) * U * Z + ( - 9) * U + (3) * X, (4) * U * V * Z + ( - 3) * U * Y + (3) * V * X, (9) * U * V * Y + ( - 2) * U * Z^2 + (18) * U * Z + ( - 9) * V^2 * X + ( - 6) * X * Z, ( - 27) * U * Y^2 + (8) * U * Z^3 + ( - 72) * U * Z^2 + (36) * V^2 * X * Z + (27) * V * X * Y + (24) * X * Z^2, (34992) * V^2 * X^2 + ( - 34992) * V^2 * Y^2 + ( - 186624) * V^2 * Z + ( - 15552) * V * Y * Z^2 + (46656) * V * Y * Z + (15552) * X^2 * Z + (93312) * X^2 + (19440) * Y^2 * Z + ( - 93312) * Y^2 + ( - 576) * Z^4 + (6912) * Z^3 + (15552) * Z^2 + ( - 279936) * Z, (139968) * U * X + (93312) * V^2 * Z + ( - 139968) * V * Y + (15552) * Z^2 + ( - 139968) * Z, (105815808) * V^2 * Y * Z + (52907904) * V * X^2 + ( - 52907904) * V * Y^2 + (15676416) * V * Z^3 + (141087744) * V * Z^2 + ( - 17635968) * Y * Z^2 + ( - 52907904) * Y * Z, (31104) * V^2 * Z^2 + (93312) * V^2 * Z + ( - 93312) * V * Y * Z + ( - 46656) * X^2 + (46656) * Y^2 + (1728) * Z^3 + ( - 31104) * Z^2 + (139968) * Z, (8817984) * V * X^2 * Z + (26453952) * V * X^2 + (44089920) * V * Y^2 * Z + ( - 26453952) * V * Y^2 + (2612736) * V * Z^4 + (31352832) * V * Z^3 + (70543872) * V * Z^2 + (26453952) * X^2 * Y + ( - 26453952) * Y^3 + ( - 3919104) * Y * Z^3 + ( - 105815808) * Y * Z, ( - 158723712) * V * X^2 * Y + ( - 317447424) * V * Y^3 * Z + (158723712) * V * Y^3 + ( - 23514624) * V * Y * Z^4 + ( - 188116992) * V * Y * Z^3 + ( - 634894848) * V * Y * Z^2 + (26453952) * X^4 + ( - 211631616) * X^2 * Y^2 + (6858432) * X^2 * Z^3 + (88179840) * X^2 * Z^2 + ( - 79361856) * X^2 * Z + (185177664) * Y^4 + (34292160) * Y^2 * Z^3 + ( - 35271936) * Y^2 * Z^2 + (714256704) * Y^2 * Z + ( - 290304) * Z^6 + (2612736) * Z^5 + (23514624) * Z^4 + ( - 211631616) * Z^3, ( - 317447424) * V * Y^3 * Z^2 + ( - 23514624) * V * Y * Z^5 + ( - 211631616) * V * Y * Z^4 + ( - 634894848) * V * Y * Z^3 + ( - 634894848) * V * Y * Z^2 + (26453952) * X^4 * Z + (79361856) * X^4 + ( - 211631616) * X^2 * Y^2 * Z + ( - 158723712) * X^2 * Y^2 + (6858432) * X^2 * Z^4 + (108755136) * X^2 * Z^3 + (185177664) * X^2 * Z^2 + ( - 238085568) * X^2 * Z + (185177664) * Y^4 * Z + (79361856) * Y^4 + (34292160) * Y^2 * Z^4 + ( - 2939328) * Y^2 * Z^3 + (608440896) * Y^2 * Z^2 + (238085568) * Y^2 * Z + ( - 290304) * Z^7 + (1741824) * Z^6 + (31352832) * Z^5 + ( - 141087744) * Z^4 + ( - 634894848) * Z^3, (79361856) * V * X^4 + (2539579392) * V * X^2 + (317447424) * V * Y^4 * Z + ( - 79361856) * V * Y^4 + (23514624) * V * Y^2 * Z^4 + (117573120) * V * Y^2 * Z^3 + ( - 423263232) * V * Y^2 * Z^2 + (5079158784) * V * Y^2 * Z + ( - 2539579392) * V * Y^2 + ( - 6967296) * V * Z^6 + ( - 125411328) * V * Z^5 + ( - 564350976) * V * Z^4 + (752467968) * V * Z^3 + (6772211712) * V * Z^2 + ( - 26453952) * X^4 * Y + (211631616) * X^2 * Y^3 + ( - 6858432) * X^2 * Y * Z^3 + ( - 255721536) * X^2 * Y * Z^2 + ( - 846526464) * X^2 * Y * Z + (2539579392) * X^2 * Y + ( - 185177664) * Y^5 + ( - 34292160) * Y^3 * Z^3 + (44089920) * Y^3 * Z^2 + (211631616) * Y^3 * Z + ( - 2539579392) * Y^3 + (290304) * Y * Z^6 + (10450944) * Y * Z^5 + (7838208) * Y * Z^4 + (188116992) * Y * Z^3 + (3386105856) * Y * Z^2 + ( - 10158317568) * Y * Z, ( - 714256704) * X^6 + (2142770112) * X^4 * Y^2 + ( - 396809280) * X^4 * Z^3 + ( - 4285540224) * X^4 * Z^2 + (2142770112) * X^4 * Z + ( - 2142770112) * X^2 * Y^4 + ( - 2063408256) * X^2 * Y^2 * Z^3 + ( - 4285540224) * X^2 * Y^2 * Z + ( - 47029248) * X^2 * Z^6 + ( - 1269789696) * X^2 * Z^5 + ( - 6348948480) * X^2 * Z^4 + (11428107264) * X^2 * Z^3 + (714256704) * Y^6 + ( - 396809280) * Y^4 * Z^3 + (4285540224) * Y^4 * Z^2 + (2142770112) * Y^4 * Z + (47029248) * Y^2 * Z^6 + ( - 1269789696) * Y^2 * Z^5 + (6348948480) * Y^2 * Z^4 + (11428107264) * Y^2 * Z^3 + (2322432) * Z^9 + ( - 376233984) * Z^7 + (15237476352) * Z^5 ]
+real time : 14.133 secs
+run time  : 11.600 secs
+VALUES--> (NIL)
+
+EVAL> (SETF VAL1
+            (GROBNER (MAPCAR #'COLORED-POLY-TO-POLY (CADAR VAL1))))
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (NIL)
+
+EVAL> (SETF VAL2
+            (STRING-GROBNER
+                "[x-3*u-3*u*v^2+u^3,y-3*v-3*u^2*v+v^3,z-3*u^2+3*v^2]"
+                '(U V X Y Z) :SUPPRESS-VALUE T))
+Args:[ U^3 - 3 * U * V^2 - 3 * U + X,  - 3 * U^2 * V + V^3 - 3 * V + Y,  - 3 * U^2 + 3 * V^2 + Z ]
+[ 54 * V^2 * Y * Z + 27 * V * X^2 - 27 * V * Y^2 + 8 * V * Z^3 + 72 * V * Z^2 - 9 * Y * Z^2 - 27 * Y * Z, 9 * U * X + 6 * V^2 * Z - 9 * V * Y + Z^2 - 9 * Z, 243 * V^2 * X^2 - 243 * V^2 * Y^2 - 1296 * V^2 * Z - 108 * V * Y * Z^2 + 324 * V * Y * Z + 108 * X^2 * Z + 648 * X^2 + 135 * Y^2 * Z - 648 * Y^2 - 4 * Z^4 + 48 * Z^3 + 108 * Z^2 - 1944 * Z, 2 * V^3 + V * Z + 3 * V - Y, 6 * U * V^2 - U * Z + 9 * U - 3 * X, 3 * U^2 - 3 * V^2 - Z, 4 * U * V * Z - 3 * U * Y + 3 * V * X, 9 * U * V * Y - 2 * U * Z^2 + 18 * U * Z - 9 * V^2 * X - 6 * X * Z, 27 * U * Y^2 - 8 * U * Z^3 + 72 * U * Z^2 - 36 * V^2 * X * Z - 27 * V * X * Y - 24 * X * Z^2, 18 * V^2 * Z^2 + 54 * V^2 * Z - 54 * V * Y * Z - 27 * X^2 + 27 * Y^2 + Z^3 - 18 * Z^2 + 81 * Z, 27 * V * X^2 * Z + 81 * V * X^2 + 135 * V * Y^2 * Z - 81 * V * Y^2 + 8 * V * Z^4 + 96 * V * Z^3 + 216 * V * Z^2 + 81 * X^2 * Y - 81 * Y^3 - 12 * Y * Z^3 - 324 * Y * Z, 4374 * V * X^2 * Y + 8748 * V * Y^3 * Z - 4374 * V * Y^3 + 648 * V * Y * Z^4 + 5184 * V * Y * Z^3 + 17496 * V * Y * Z^2 - 729 * X^4 + 5832 * X^2 * Y^2 - 189 * X^2 * Z^3 - 2430 * X^2 * Z^2 + 2187 * X^2 * Z - 5103 * Y^4 - 945 * Y^2 * Z^3 + 972 * Y^2 * Z^2 - 19683 * Y^2 * Z + 8 * Z^6 - 72 * Z^5 - 648 * Z^4 + 5832 * Z^3, 8748 * V * Y^3 * Z^2 + 648 * V * Y * Z^5 + 5832 * V * Y * Z^4 + 17496 * V * Y * Z^3 + 17496 * V * Y * Z^2 - 729 * X^4 * Z - 2187 * X^4 + 5832 * X^2 * Y^2 * Z + 4374 * X^2 * Y^2 - 189 * X^2 * Z^4 - 2997 * X^2 * Z^3 - 5103 * X^2 * Z^2 + 6561 * X^2 * Z - 5103 * Y^4 * Z - 2187 * Y^4 - 945 * Y^2 * Z^4 + 81 * Y^2 * Z^3 - 16767 * Y^2 * Z^2 - 6561 * Y^2 * Z + 8 * Z^7 - 48 * Z^6 - 864 * Z^5 + 3888 * Z^4 + 17496 * Z^3, 2187 * V * X^4 + 69984 * V * X^2 + 8748 * V * Y^4 * Z - 2187 * V * Y^4 + 648 * V * Y^2 * Z^4 + 3240 * V * Y^2 * Z^3 - 11664 * V * Y^2 * Z^2 + 139968 * V * Y^2 * Z - 69984 * V * Y^2 - 192 * V * Z^6 - 3456 * V * Z^5 - 15552 * V * Z^4 + 20736 * V * Z^3 + 186624 * V * Z^2 - 729 * X^4 * Y + 5832 * X^2 * Y^3 - 189 * X^2 * Y * Z^3 - 7047 * X^2 * Y * Z^2 - 23328 * X^2 * Y * Z + 69984 * X^2 * Y - 5103 * Y^5 - 945 * Y^3 * Z^3 + 1215 * Y^3 * Z^2 + 5832 * Y^3 * Z - 69984 * Y^3 + 8 * Y * Z^6 + 288 * Y * Z^5 + 216 * Y * Z^4 + 5184 * Y * Z^3 + 93312 * Y * Z^2 - 279936 * Y * Z, 19683 * X^6 - 59049 * X^4 * Y^2 + 10935 * X^4 * Z^3 + 118098 * X^4 * Z^2 - 59049 * X^4 * Z + 59049 * X^2 * Y^4 + 56862 * X^2 * Y^2 * Z^3 + 118098 * X^2 * Y^2 * Z + 1296 * X^2 * Z^6 + 34992 * X^2 * Z^5 + 174960 * X^2 * Z^4 - 314928 * X^2 * Z^3 - 19683 * Y^6 + 10935 * Y^4 * Z^3 - 118098 * Y^4 * Z^2 - 59049 * Y^4 * Z - 1296 * Y^2 * Z^6 + 34992 * Y^2 * Z^5 - 174960 * Y^2 * Z^4 - 314928 * Y^2 * Z^3 - 64 * Z^9 + 10368 * Z^7 - 419904 * Z^5 ]
+real time : 7.733 secs
+run time  : 6.900 secs
+VALUES--> (NIL)
+
+EVAL> (GROBNER-EQUAL VAL1 VAL2)
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (T)
+
+EVAL> (WARN " Test 3 - staple")
+Warning:  Test 3 - staple
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (NIL)
+
+EVAL> (STRING-GROBNER-SYSTEM "[x+y,x+u*y]" '(X Y) '(U))
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ U - 1 ]
+ Basis: [ (U - 1) * X, ( - U + 1) * Y ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [ U - 1 ]
+  Red list: [  ]
+ Basis: [ (1) * X + (1) * Y ]
+real time : 0.200 secs
+run time  : 0.150 secs
+VALUES--> NIL
+
+EVAL> (WARN " Test 4 - staple")
+Warning:  Test 4 - staple
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (NIL)
+
+EVAL> (STRING-GROBNER-SYSTEM "[x+y,u*x+y]" '(X Y) '(U))
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [ U ]
+  Red list: [  ]
+ Basis: [ (1) * X, (1) * Y ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ U, U - 1 ]
+ Basis: [ (U^2 - U) * X, (U - 1) * Y ]
+------------------- CASE 3 -------------------
+Condition:
+  Green list: [ U - 1 ]
+  Red list: [ U ]
+ Basis: [ (1) * X + (1) * Y ]
+real time : 0.150 secs
+run time  : 0.100 secs
+VALUES--> NIL
+
+EVAL> (WARN "Test 5 - a small robot example")
+Warning: Test 5 - a small robot example
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (NIL)
+
+EVAL> (STRING-GROBNER-SYSTEM
+          "[a-l3*c1*c2+l3*s1*s2-l2*c1, b-l3*c1*s2-l3*c2*s1-l2*s1, c1^2+s1^2-1, c2^2+s2^2-1]"
+          '(C2 S2 C1 S1) '(A B L2 L3) :COVER '(("[]" "[l2,l3]")))
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ L3, A^2 + B^2, L2, A ]
+ Basis: [ ( - 2 * A * L2 * L3) * S2 + ( - 2 * A^2 * L2 - 2 * B^2 * L2) * S1 + (A^2 * B + B^3 + B * L2^2 - B * L3^2), ( - 2 * L2 * L3) * C2 + (A^2 + B^2 - L2^2 - L3^2), ( - 2 * A * L2) * C1 + ( - 2 * B * L2) * S1 + (A^2 + B^2 + L2^2 - L3^2), (4 * A^2 * L2^2 + 4 * B^2 * L2^2) * S1^2 + ( - 4 * A^2 * B * L2 - 4 * B^3 * L2 - 4 * B * L2^3 + 4 * B * L2 * L3^2) * S1 + (A^4 + 2 * A^2 * B^2 - 2 * A^2 * L2^2 - 2 * A^2 * L3^2 + B^4 + 2 * B^2 * L2^2 - 2 * B^2 * L3^2 + L2^4 - 2 * L2^2 * L3^2 + L3^4) ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [ A^2 + B^2 ]
+  Red list: [ L3, A^2 * B + B^3 + B * L2^2 - B * L3^2, L2, A ]
+ Basis: [ (4 * A * B * L2^3 * L3 - 4 * A * B * L2 * L3^3) * S2 + ( - 2 * B^2 * L2^4 + 4 * B^2 * L2^2 * L3^2 - 2 * B^2 * L3^4), ( - 2 * L2 * L3) * C2 + ( - L2^2 - L3^2), (4 * A * L2^3 - 4 * A * L2 * L3^2) * C1 + (4 * B^2 * L2^2 - L2^4 + 2 * L2^2 * L3^2 - L3^4), ( - 4 * B * L2^3 + 4 * B * L2 * L3^2) * S1 + (4 * B^2 * L2^2 + L2^4 - 2 * L2^2 * L3^2 + L3^4) ]
+------------------- CASE 3 -------------------
+Condition:
+  Green list: [ A^2 + B^2, L2^2 - L3^2 ]
+  Red list: [ L3, A, L2, A^4 + 2 * A^2 * B^2 - 2 * A^2 * L2^2 - 2 * A^2 * L3^2 + B^4 + 2 * B^2 * L2^2 - 2 * B^2 * L3^2 + L2^4 - 2 * L2^2 * L3^2 + L3^4 ]
+ Basis: [ (4 * B^2 * L3^2) ]
+------------------- CASE 4 -------------------
+Condition:
+  Green list: [ A ]
+  Red list: [ L3, B, L2 ]
+ Basis: [ (4 * B^2 * L2^2) * C1^2 + (B^4 - 2 * B^2 * L2^2 - 2 * B^2 * L3^2 + L2^4 - 2 * L2^2 * L3^2 + L3^4), (2 * B * L2 * L3) * S2 + ( - 2 * B^2 * L2) * C1, ( - 2 * L2 * L3) * C2 + (B^2 - L2^2 - L3^2), ( - 2 * B * L2) * S1 + (B^2 + L2^2 - L3^2) ]
+------------------- CASE 5 -------------------
+Condition:
+  Green list: [ A, B ]
+  Red list: [ L3, L2, A^2 + B^2 + L2^2 - L3^2 ]
+ Basis: [ (L2^2 - L3^2) ]
+------------------- CASE 6 -------------------
+Condition:
+  Green list: [ A, B, L2^2 - L3^2 ]
+  Red list: [ L3, L2 ]
+ Basis: [ (1) * C1^2 + (1) * S1^2 + ( - 1), (L3) * S2, (L3) * C2 + (L2) ]
+real time : 6.750 secs
+run time  : 5.900 secs
+VALUES--> NIL
+
+EVAL> (WARN "Test 6 - Circle of Apollonius")
+Warning: Test 6 - Circle of Apollonius
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (NIL)
+
+EVAL> (STRING-GROBNER-SYSTEM
+          "[2*x1-u1,2*x2-u2,2*x3-u1,2*x4-u2,x5*u1-x6*u2,x5*u2+x6*u1-u1*u2,x1^2-2*x1*x7+x7^2+x8^2-x7^2-x8^2+2*x8*x2-x2^2,x1^2-2*x1*x7+x7^2+x6^2-2*x6*x8+x8^2-x3^2+2*x3*x7-x7^2-x4^2+2*x4*x8-x8^2,1-s*x5^2+2*s*x5*x7-s*x7^2-s*x6^2+2*s*x6*x8-s*x8^2+s*x1^2-2*s*x1*x7+s*x7^2+s*x8^2]"
+          '(S X1 X2 X3 X4 X5 X6 X7 X8) '(U1 U2))
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [ U2, U1 ]
+  Red list: [  ]
+ Basis: [ (2) * X1, (2) * X2, (2) * X3, (2) * X4, ( - 4) * X6^2 + (8) * X6 * X8, (4) * S * X5^2 + ( - 8) * S * X5 * X7 + ( - 4) ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [ U2 ]
+  Red list: [ U1 ]
+ Basis: [ ( - 4 * U1^3) ]
+------------------- CASE 3 -------------------
+Condition:
+  Green list: [ U1 ]
+  Red list: [ U2 ]
+ Basis: [ (4 * U2^2) ]
+------------------- CASE 4 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ U1, U2, U1^2 - U2^2, U1^2 + U2^2 ]
+ Basis: [ (2) * X1 + ( - U1), (2) * X2 + ( - U2), (2) * X3 + ( - U1), (2) * X4 + ( - U2), (U1^2 * U2 + U2^3) * X5 + ( - U1 * U2^3), ( - U1^2 - U2^2) * X6 + (U1^2 * U2), ( - 4 * U1^5 + 4 * U1 * U2^4) * X7 + (U1^6 + 2 * U1^4 * U2^2 - 3 * U1^2 * U2^4), ( - 4 * U1^4 * U2 + 4 * U2^5) * X8 + (3 * U1^4 * U2^2 - 2 * U1^2 * U2^4 - U2^6), (2 * U1^6 * U2^2 - 2 * U1^4 * U2^4) * S + (4 * U1^6 - 4 * U1^2 * U2^4) ]
+------------------- CASE 5 -------------------
+Condition:
+  Green list: [ U1^2 - U2^2 ]
+  Red list: [ U1, U1^2 + U2^2, U2 ]
+ Basis: [ (2) * X1 + ( - U1), (2) * X2 + ( - U2), (2) * X3 + ( - U1), (2) * X4 + ( - U2), (2 * U2^3) * X5 + ( - U1 * U2^3), ( - 2 * U2^2) * X6 + (U2^3), (4 * U1) * X7 + ( - 4 * U2) * X8, ( - 8 * U2^5) * S * X8 + (2 * U2^6) * S + ( - 8 * U2^4) ]
+------------------- CASE 6 -------------------
+Condition:
+  Green list: [ U1^2 + U2^2 ]
+  Red list: [ U1, U2 ]
+ Basis: [ ( - U2^3) ]
+real time : 5.400 secs
+run time  : 4.633 secs
+VALUES--> NIL
+
+EVAL> (WARN "Test 7")
+Warning: Test 7
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (NIL)
+
+EVAL> (SETF FL
+            (PARSE-STRING-TO-SORTED-ALIST
+                "[a^2*x^2*y+b*x^2*y+a^3*b*x*y+a^3*c*x*y,c^2*a*x^2+c^2*b*x^2+b*y+4]"
+                '(X Y A B C)))
+real time : 0.100 secs
+run time  : 0.050 secs
+VALUES--> (((((2 1 2 0 0) . 1) ((2 1 0 1 0) . 1) ((1 1 3 1 0) . 1)
+             ((1 1 3 0 1) . 1))
+            (((2 0 1 0 2) . 1) ((2 0 0 1 2) . 1) ((0 1 0 1 0) . 1)
+             ((0 0 0 0 0) . 4))))
+
+EVAL> (SETF CFL (MAKE-COLORED-POLY-LIST FL 2))
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (((((2 1) (((2 0 0) . 1) ((0 1 0) . 1)) . :WHITE)
+             ((1 1) (((3 1 0) . 1) ((3 0 1) . 1)) . :WHITE))
+            (((2 0) (((1 0 2) . 1) ((0 1 2) . 1)) . :WHITE)
+             ((0 1) (((0 1 0) . 1)) . :WHITE)
+             ((0 0) (((0 0 0) . 4)) . :WHITE))))
+
+EVAL> (COND-SYSTEM-PRINT (DETERMINE CFL) '(X Y) '(A B C))
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ A * C^2 + B * C^2, A^2 + B ]
+ Basis: [ (A^2 + B) * X^2 * Y + (A^3 * B + A^3 * C) * X * Y, (A * C^2 + B * C^2) * X^2 + (B) * Y + (4) ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [ A^2 + B ]
+  Red list: [ A * C^2 + B * C^2, A^3 * B + A^3 * C ]
+ Basis: [ (A^3 * B + A^3 * C) * X * Y, (A * C^2 + B * C^2) * X^2 + (B) * Y + (4) ]
+------------------- CASE 3 -------------------
+Condition:
+  Green list: [ A^2 - C, B + C ]
+  Red list: [ A * C^2 + B * C^2 ]
+ Basis: [ (A * C^2 + B * C^2) * X^2 + (B) * Y + (4) ]
+------------------- CASE 4 -------------------
+Condition:
+  Green list: [ A * C^2 + B * C^2 ]
+  Red list: [ B, A^2 + B ]
+ Basis: [ (A^2 + B) * X^2 * Y + (A^3 * B + A^3 * C) * X * Y, (B) * Y + (4) ]
+------------------- CASE 5 -------------------
+Condition:
+  Green list: [ A * C^2 - C^2, A^2 + B, B * C^2 + C^2 ]
+  Red list: [ B, A^3 * B + A^3 * C ]
+ Basis: [ (A^3 * B + A^3 * C) * X * Y, (B) * Y + (4) ]
+------------------- CASE 6 -------------------
+Condition:
+  Green list: [ B + 1, C - 1, A - 1 ]
+  Red list: [ B ]
+ Basis: [ (B) * Y + (4) ]
+------------------- CASE 7 -------------------
+Condition:
+  Green list: [ B, C^2 ]
+  Red list: [ 4, A^2 + B ]
+ Basis: [ (A^2 + B) * X^2 * Y + (A^3 * B + A^3 * C) * X * Y, (4) ]
+------------------- CASE 8 -------------------
+Condition:
+  Green list: [ A^2, A * C^2, B ]
+  Red list: [ 4 ]
+ Basis: [ (4) ]
+real time : 1.033 secs
+run time  : 0.733 secs
+VALUES--> NIL
+
+EVAL> (WARN "Test 8")
+Warning: Test 8
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (NIL)
+
+EVAL> (SETF FL (PARSE-STRING-TO-SORTED-ALIST "[a^2*x+5*a]" '(X A)))
+real time : 0.017 secs
+run time  : 0.033 secs
+VALUES--> (((((1 2) . 1) ((0 1) . 5))))
+
+EVAL> (SETF CFL (MAKE-COLORED-POLY-LIST FL 1))
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (((((1) (((2) . 1)) . :WHITE) ((0) (((1) . 5)) . :WHITE))))
+
+EVAL> (COND-SYSTEM-PRINT (DETERMINE CFL) '(X) '(A))
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ A^2 ]
+ Basis: [ (A^2) * X + (5 * A) ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [ A^2 ]
+  Red list: [  ]
+ Basis: [ ]
+real time : 0.033 secs
+run time  : 0.017 secs
+VALUES--> NIL
+
+EVAL> (WARN "Test 9 - the discriminant of a quadratic polynomial")
+Warning: Test 9 - the discriminant of a quadratic polynomial
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (NIL)
+
+EVAL> (STRING-GROBNER-SYSTEM "[a*x^2+b*x+c,2*a*x+b]" '(X) '(A B C)
+          :COVER (LIST (LIST "[]" "[a]")))
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ A, 4 * A * C - B^2 ]
+ Basis: [ (4 * A * C - B^2) ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [ 4 * A * C - B^2 ]
+  Red list: [ A ]
+ Basis: [ (2 * A) * X + (B) ]
+real time : 0.183 secs
+run time  : 0.133 secs
+VALUES--> NIL
+
+EVAL> (WARN "Test 10 - the discriminant of a cubic polynomial")
+Warning: Test 10 - the discriminant of a cubic polynomial
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (NIL)
+
+EVAL> (STRING-GROBNER-SYSTEM "[x^3+p*x+q,3*x^2+p]" '(X) '(P Q) :COVER
+          (LIST (LIST "[]" "[]")))
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ P, 4 * P^3 + 27 * Q^2 ]
+ Basis: [ ( - 4 * P^3 - 27 * Q^2) ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [ 4 * P^3 + 27 * Q^2 ]
+  Red list: [ P ]
+ Basis: [ (2 * P) * X + (3 * Q) ]
+------------------- CASE 3 -------------------
+Condition:
+  Green list: [ P ]
+  Red list: [ Q ]
+ Basis: [ (3 * Q) ]
+------------------- CASE 4 -------------------
+Condition:
+  Green list: [ P, Q ]
+  Red list: [  ]
+ Basis: [ (3) * X^2 ]
+real time : 0.317 secs
+run time  : 0.250 secs
+VALUES--> NIL
+
+EVAL> (WARN "Test 11 - the discriminant of a quartic polynomial")
+Warning: Test 11 - the discriminant of a quartic polynomial
+real time : 0.000 secs
+run time  : 0.000 secs
+VALUES--> (NIL)
+
+EVAL> (STRING-GROBNER-SYSTEM "[x^4+p*x^2+q*x+r,4*x^3+2*p*x+q]" '(X)
+          '(P Q R) :COVER (LIST (LIST "[]" "[]")))
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ 16 * P^4 * R - 4 * P^3 * Q^2 - 128 * P^2 * R^2 + 144 * P * Q^2 * R - 27 * Q^4 + 256 * R^3, P, 2 * P^3 - 8 * P * R + 9 * Q^2 ]
+ Basis: [ (16 * P^6 * R - 4 * P^5 * Q^2 - 128 * P^4 * R^2 + 144 * P^3 * Q^2 * R - 27 * P^2 * Q^4 + 256 * P^2 * R^3) ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [ 16 * P^4 * R - 4 * P^3 * Q^2 - 128 * P^2 * R^2 + 144 * P * Q^2 * R - 27 * Q^4 + 256 * R^3 ]
+  Red list: [ P, 2 * P^3 - 8 * P * R + 9 * Q^2 ]
+ Basis: [ ( - 2 * P^3 + 8 * P * R - 9 * Q^2) * X + ( - P^2 * Q - 12 * Q * R) ]
+------------------- CASE 3 -------------------
+Condition:
+  Green list: [ 2 * P^3 - 8 * P * R + 9 * Q^2 ]
+  Red list: [ P, P^2 * Q + 12 * Q * R ]
+ Basis: [ ( - P^2 * Q - 12 * Q * R) ]
+------------------- CASE 4 -------------------
+Condition:
+  Green list: [ 2 * P^3 - 8 * P * R + 9 * Q^2, P^2 * Q + 12 * Q * R, 32 * P * Q * R - 9 * Q^3, 3 * P * Q^3 + 128 * Q * R^2, 27 * Q^5 + 4096 * Q * R^3, 8 * P^2 * R - 3 * P * Q^2 - 32 * R^2 ]
+  Red list: [ P ]
+ Basis: [ (2 * P) * X^2 + (3 * Q) * X + (4 * R) ]
+------------------- CASE 5 -------------------
+Condition:
+  Green list: [ P ]
+  Red list: [ Q, 72 * P * Q^2 * R - 27 * Q^4 + 256 * R^3 ]
+ Basis: [ (27 * Q^4 - 256 * R^3) ]
+------------------- CASE 6 -------------------
+Condition:
+  Green list: [ P, 27 * Q^4 - 256 * R^3 ]
+  Red list: [ Q ]
+ Basis: [ (3 * Q) * X + (4 * R) ]
+------------------- CASE 7 -------------------
+Condition:
+  Green list: [ P, Q ]
+  Red list: [ R ]
+ Basis: [ (4 * R) ]
+------------------- CASE 8 -------------------
+Condition:
+  Green list: [ P, Q, R ]
+  Red list: [  ]
+ Basis: [ (4) * X^3 ]
+real time : 2.600 secs
+run time  : 2.133 secs
+VALUES--> NIL
+
+EVAL> (DRIBBLE)
Index: /trunk/examples/euler.lisp
===================================================================
--- /trunk/examples/euler.lisp	(revision 8)
+++ /trunk/examples/euler.lisp	(revision 8)
@@ -0,0 +1,8 @@
+(string-grobner-system
+"[2*X7-U1-1,2*X8-U2,2*X9-U1,2*X10-U2,2*X11-1,2*X12,U1*X2-X2-U2*X1+U2,U1*X4-U2*X3,X6,U2*X18+U1*X17-X17,U2*X18+U1*X17-U1,X17-U1,U2*X8+U1*X7-X7-U2*X16-U1*X15+X15,U1*X9-U2*X16-U1*X15+U2*X10,X11-X15,X13*X8-X14*X7,-X14*X9+X14+X10*X13-X10,-V*X15*X18+V*X13*X18+V*X16*X17-V*X14*X17-V*X13*X16+V*X14*X15+1]"
+'(X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 V)
+'(U1 U2)
+:cover '(("[]" "[u2]"))
+:main-order #'grevlex>
+:parameter-order #'grevlex>
+)
Index: /trunk/examples/euler.macsyma
===================================================================
--- /trunk/examples/euler.macsyma	(revision 8)
+++ /trunk/examples/euler.macsyma	(revision 8)
@@ -0,0 +1,44 @@
+/* Unfinished !! */
+if get('geometry2, 'version)=false then load(geometry2);
+A:[u1,u2]; B:[u3,u4]; C:[u5,u6]; /* Vertices */
+H1:[x1,x2]; H2: [x3,x4]; H3: [x5,x6]; /* Feet of altitudes */
+M1:[x7,x8]; M2: [x9,x10]; M3: [x11,x12]; /* Midpoints */
+O1:[x13,x14]; /* Centroid */
+O2:[x15,x16]; /* Orthocenter */
+O3:[x17,x18]; /* Intersection point of altitudes */
+
+vars:listofvars([H1,H2,H3,M1,M2,M3,O1,O2,O3,v]);
+params:listofvars([A,B,C]);
+
+eqns:append(
+	midpoint(M1,B,C),
+	midpoint(M2,A,C),
+	midpoint(M3,A,B),
+	[
+		/* Hi are on the sides */
+		collinear(B,C,H1),
+		collinear(A,C,H2),
+		collinear(A,B,H3),
+		/* O3 is intersection of altitudes */
+		perpendicular(A,O3,B,C),
+		perpendicular(B,O3,A,C),
+		perpendicular(C,O3,A,B),
+		/* O2 is orthocenter */
+		perpendicular(O2,M1,B,C),
+		perpendicular(O2,M2,A,C),
+		perpendicular(O2,M3,A,B),
+		/* O1 is the centroid */
+		collinear(O1,M1,A),
+		collinear(O1,M2,B),
+		/* collinear(O1,M3,C),	*/
+		/* Conclusion */
+		1-v*collinear(O1,O2,O3)
+	]
+);
+
+cover:[[[],[]]];
+
+eqns:expand(eqns);
+cover:expand(cover);
+stringout("euler.out",eqns,vars,params,cover);
+
Index: /trunk/examples/euler.out
===================================================================
--- /trunk/examples/euler.out	(revision 8)
+++ /trunk/examples/euler.out	(revision 8)
@@ -0,0 +1,5 @@
+
+[2*X7-U5-U3,2*X8-U6-U4,2*X9-U5-U1,2*X10-U6-U2,2*X11-U3-U1,2*X12-U4-U2,U5*X2-U3*X2-U6*X1+U4*X1+U3*U6-U4*U5,U5*X4-U1*X4-U6*X3+U2*X3+U1*U6-U2*U5,U3*X6-U1*X6-U4*X5+U2*X5+U1*U4-U2*U3,U6*X18-U4*X18+U5*X17-U3*X17-U2*U6-U1*U5+U2*U4+U1*U3,U6*X18-U2*X18+U5*X17-U1*X17-U4*U6-U3*U5+U2*U4+U1*U3,U4*X18-U2*X18+U3*X17-U1*X17-U4*U6+U2*U6-U3*U5+U1*U5,U6*X8-U4*X8+U5*X7-U3*X7-U6*X16+U4*X16-U5*X15+U3*X15,U5*X9-U1*X9-U6*X16+U2*X16-U5*X15+U1*X15+U6*X10-U2*X10,-U4*X16+U2*X16-U3*X15+U1*X15+U4*X12-U2*X12+U3*X11-U1*X11,X13*X8-U1*X8-X14*X7+U2*X7+U1*X14-U2*X13,-X14*X9+U4*X9+U3*X14+X10*X13-U4*X13-U3*X10,-V*X15*X18+V*X13*X18+V*X16*X17-V*X14*X17-V*X13*X16+V*X14*X15+1];
+[X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,X11,X12,X13,X14,X15,X16,X17,X18,V];
+[U1,U2,U3,U4,U5,U6];
+[[[],[]]];
Index: /trunk/examples/euler.result
===================================================================
--- /trunk/examples/euler.result	(revision 8)
+++ /trunk/examples/euler.result	(revision 8)
@@ -0,0 +1,17 @@
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [ U1 ]
+  Red list: [ U1 - 1, U2 ]
+ Basis: [ (6 * U2^3) ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [ U1 - 1 ]
+  Red list: [ U1, U2 ]
+ Basis: [ (6 * U2^3) ]
+------------------- CASE 3 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ U1 - 1, U2, U1 ]
+ Basis: [ (6 * U1 * U2^3 - 6 * U2^3) ]
+Finished loading euler.lisp
+T
Index: /trunk/examples/euler2.lisp
===================================================================
--- /trunk/examples/euler2.lisp	(revision 8)
+++ /trunk/examples/euler2.lisp	(revision 8)
@@ -0,0 +1,8 @@
+(string-grobner-system
+"[2*X7-U5-U3,2*X8-U6-U4,2*X9-U5-U1,2*X10-U6-U2,2*X11-U3-U1,2*X12-U4-U2,U5*X2-U3*X2-U6*X1+U4*X1+U3*U6-U4*U5,U5*X4-U1*X4-U6*X3+U2*X3+U1*U6-U2*U5,U3*X6-U1*X6-U4*X5+U2*X5+U1*U4-U2*U3,U6*X18-U4*X18+U5*X17-U3*X17-U2*U6-U1*U5+U2*U4+U1*U3,U6*X18-U2*X18+U5*X17-U1*X17-U4*U6-U3*U5+U2*U4+U1*U3,U4*X18-U2*X18+U3*X17-U1*X17-U4*U6+U2*U6-U3*U5+U1*U5,U6*X8-U4*X8+U5*X7-U3*X7-U6*X16+U4*X16-U5*X15+U3*X15,U5*X9-U1*X9-U6*X16+U2*X16-U5*X15+U1*X15+U6*X10-U2*X10,-U4*X16+U2*X16-U3*X15+U1*X15+U4*X12-U2*X12+U3*X11-U1*X11,X13*X8-U1*X8-X14*X7+U2*X7+U1*X14-U2*X13,-X14*X9+U4*X9+U3*X14+X10*X13-U4*X13-U3*X10,-V*X15*X18+V*X13*X18+V*X16*X17-V*X14*X17-V*X13*X16+V*X14*X15+1]"
+'(X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 V)
+'(U1 U2 U3 U4 U5 U6)
+:cover '(("[]" "[]"))
+:main-order #'grevlex>
+:parameter-order #'grevlex>
+)
Index: /trunk/examples/galois3.lisp
===================================================================
--- /trunk/examples/galois3.lisp	(revision 8)
+++ /trunk/examples/galois3.lisp	(revision 8)
@@ -0,0 +1,32 @@
+;; Galois group calculation
+(setf Vars '(u12 u13 u23 p q r x1 x2 x3))
+	     
+(setf 
+    f12 "1-u12*x1+u12*x2"
+    f13 "1-u13*x1+u13*x3"
+    f23 "1-u23*x2+u23*x3"
+    a "x1^3+p*x1^2+q*x1+r"
+    b "x2^3+p*x2^2+q*x2+r"
+    c "x3^3+p*x3^2+q*x3+r"
+    rel1 "p^2-q"
+    rel2 "0"
+    rel3 "0"
+    )
+
+(setf n 6)				;number of vars to eliminate
+(setf primary-order #'lex>)
+(setf secondary-order #'lex>)
+
+(setf order (elimination-order
+	     n
+	     :primary-order primary-order
+	     :secondary-order secondary-order))
+
+(setf F (remove nil (mapcar #'(lambda (s) (parse-string-to-sorted-alist s vars order))
+			    (list f12 f13 f23 a b c rel1 rel2 rel3))))
+
+(poly-print (cons '[ f) vars)
+(terpri)
+;Gb:=gbasis(F,Vars,plex);
+(setf gb (elimination-ideal F n :order order :top-reduction-only nil))
+(poly-print (cons '[ gb) vars)
Index: /trunk/examples/geometry.macsyma
===================================================================
--- /trunk/examples/geometry.macsyma	(revision 8)
+++ /trunk/examples/geometry.macsyma	(revision 8)
@@ -0,0 +1,66 @@
+/*----------------------------------------------------------------
+	Basic function for construction of equations 
+	in Geometric Theorem proving 
+----------------------------------------------------------------*/
+put('geometry,1,'version);
+
+define_variable(geqns,[],any);
+define_variable(hypotheses,[],any);
+define_variable(conclusions,[],any);
+define_variable(gvars,[],any);
+define_variable(gparams,[],any);
+define_variable(gindex,1,any);
+define_variable(gparindex,1,any);
+define_variable(gideal,FALSE,any);
+
+ginit():=(geqns:hypotheses:conclusions:gvars:gparams:[],
+	gindex:gparindex:1);
+ghypot():=(hypotheses:geqns,geqns:[]);
+
+gconcl():=(conclusions:geqns,geqns:[]);
+
+gideal():= (gideal:append(hypotheses,
+	makelist(1-genpar()*conclusions[i],i,1,length(conclusions))));
+
+showideal():=expand(gideal);
+
+gstringout(file):=block([val:ev(string(showideal()),grind=true)],
+stringout(file,concat("(string-grobner-system \"",
+val,"\" '",
+lispl(gvars),
+" '",lispl(gparams),")")));
+
+lispl(l):=apply(concat,append(["("],makelist(concat(" ",e," "),e,l),[")"]));
+
+gpoints([L]):=map(lambda([P],
+	P::genpoint(),gvars:append(gvars,eval(P))),L);
+
+garbitrary([L]):=map(lambda([P],gparams:append(gparams,eval(P))),L);
+
+/* X, Y, Z on the plane are colinear */
+collinear(X,Y,Z):=
+	(geqns:endcons(det(matrix(cons(1,X),cons(1,Y),cons(1,Z))),geqns));
+
+/* Vector AB and CD are perpendicular */
+perp(A,B,C,D):= (geqns:endcons((B-A).(D-C),geqns));
+
+/* AB and CD have equal length */
+eqlen(A,B,C,D):=(geqns:endcons((B-A).(B-A)-(D-C).(D-C),geqns));
+
+/* AB and CD are parallel */
+parallel(A,B,C,D):=(geqns:endcons(geqns,det(matrix(B-A,D-C))));
+
+/* M is the midpoint of AB; 2 equations */
+midpoint(M,A,B):=(geqns:append(geqns,2*M-(A+B)));
+
+/* Points A and B are identical */
+identical(A,B):=(geqns:append(geqns,A-B));
+
+/* Generate a point with coords [xi,yi] */
+genpoint():=block([i:gindex],gindex:gindex+1,[concat('x,i),concat('y,i)]);
+
+/* Generate a parameter ui */
+genpar():=block([i:gparindex,sym:concat('u,i)],
+	gvars:endcons(sym,gvars),gparindex:gparindex+1,sym);
+
+
Index: /trunk/examples/geometry.macsyma.unfinished
===================================================================
--- /trunk/examples/geometry.macsyma.unfinished	(revision 8)
+++ /trunk/examples/geometry.macsyma.unfinished	(revision 8)
@@ -0,0 +1,77 @@
+/*----------------------------------------------------------------
+	Basic function for construction of equations 
+	in Geometric Theorem proving 
+----------------------------------------------------------------*/
+put('geometry,1,'version);
+
+define_variable(geqns,[],any);
+define_variable(hypotheses,[],any);
+define_variable(conclusions,[],any);
+define_variable(gvars,[],any);
+define_variable(gparams,[],any);
+define_variable(gindex,1,any);
+define_variable(gparindex,1,any);
+define_variable(gideal,FALSE,any);
+
+geometry_initialize():=(geqns:hypotheses:conclusions:gvars:gparams:[],
+	gindex:gparindex:1);
+end_of_hypotheses():=(hypotheses:geqns,geqns:[]);
+
+end_of_conclusions():=(conclusions:geqns,geqns:[]);
+
+generate_ideal():= (gideal:append(hypotheses,
+	makelist(1-genpar()*conclusions[i],i,1,length(conclusions))));
+
+show_ideal():=expand(gideal);
+
+/* Generate a point with coords [xi,yi] */
+genpoint():=block([i:gindex],gindex:gindex+1,[concat('x,i),concat('y,i)]);
+genangle():=block([i:gindex],gindex:gindex+1,[concat('x,i),concat('y,i)]);
+
+/* Generate a parameter ui */
+genpar():=block([i:gparindex,sym:concat('u,i)],
+	gvars:endcons(sym,gvars),gparindex:gparindex+1,sym);
+
+/*------------------------------- Lisp Output --------------------------------*/ 
+
+gstringout(file):=block([val:ev(string(showideal()),grind=true)],
+stringout(file,concat("(string-grobner-system \"",
+val,"\" '",
+lispl(gvars),
+" '",lispl(gparams),")")));
+
+/* Output a list as Lisp */
+lispl(l):=apply(concat,append(["("],makelist(concat(" ",e," "),e,l),[")"]));
+
+consider_points([L]):=map(lambda([P],
+	P::genpoint(),gvars:append(gvars,eval(P))),L);
+
+consider_angles([L]):=map(lambda([A],
+	A::genangle(),gangles:append(gangles,eval(A),L);
+
+arbitrary_points([L]):=map(lambda([P],gparams:append(gparams,eval(P))),L);
+arbitrary_angles([L]):=map(lambda([P],gparams:endcons(gparams,eval(P))),L);
+/*--------------- Geometric Declarations -----------------------------------*/
+/* X, Y, Z on the plane are colinear */
+are_collinear(X,Y,Z):=
+	(geqns:endcons(det(matrix(cons(1,X),cons(1,Y),cons(1,Z))),geqns));
+
+/* Vector AB and CD are perpendicular */
+are_perpendicular(A,B,C,D):= (geqns:endcons((B-A).(D-C),geqns));
+
+/* AB and CD have equal length */
+have_equal_length(A,B,C,D):=(geqns:endcons((B-A).(B-A)-(D-C).(D-C),geqns));
+
+/* AB and CD are parallel */
+are_parallel(A,B,C,D):=(geqns:endcons(geqns,det(matrix(B-A,D-C))));
+
+/* M is the midpoint of AB; 2 equations */
+is_midpoint(M,A,B):=(geqns:append(geqns,2*M-(A+B)));
+
+/* Points A and B are identical */
+are_identical(A,B):=(geqns:append(geqns,A-B));
+
+/* Angles ABC and DEF are equal */
+/* equal_angles(A,B,C,D,E,F):=(geqns:endcons(geqns,*/
+	
+
Index: /trunk/examples/geometry2.macsyma
===================================================================
--- /trunk/examples/geometry2.macsyma	(revision 8)
+++ /trunk/examples/geometry2.macsyma	(revision 8)
@@ -0,0 +1,44 @@
+/*----------------------------------------------------------------
+	Basic function for construction of equations 
+	in Geometric Theorem proving 
+----------------------------------------------------------------*/
+put('geometry2,1,'version);
+
+generate_ideal(hypotheses,conclusions):=
+	append(hypotheses,
+		makelist(1-genpar()*conclusions[i],i,1,length(conclusions)));
+
+/* X, Y, Z on the plane are colinear */
+collinear(X,Y,Z):= det(matrix(cons(1,X),cons(1,Y),cons(1,Z)));
+
+/* Vector AB and CD are perpendicular */
+perpendicular(A,B,C,D):= (B-A).(D-C);
+
+/* AB and CD have equal length */
+equidistant(A,B,C,D):=(B-A).(B-A)-(D-C).(D-C);
+
+/* AB and CD are parallel */
+parallel(A,B,C,D):=det(matrix(B-A,D-C));
+
+/* M is the midpoint of AB; 2 equations */
+midpoint(M,A,B):=2*M-(A+B);
+
+/* Points A and B are identical */
+identical(A,B):=B-A;
+
+/* D is the distance between A and B */
+distance(A,B,D):=D^2-(B-A).(B-A);
+
+/* Angle P with cos COS_P and sin SIN_P is the angle ABC
+where segments AB and BC have lengths D_AB and D_BC */
+angle(COS_P,SIN_P,A,B,C,D_AB,D_BC):=
+	[
+		cos_p^2+sin_p^2-1,
+		distance(A,B,D_AB),
+		distance(B,C,D_BC),
+		COS_P*D_AB*D_BC-(C-B).(A-B),
+		SIN_P*D_AB*D_BC-det(matrix(C-B,A-B))
+	];
+
+/* Point X is on ellipse with center at O with semi-axes a and b */
+ellipse(X,O,a,b):= b^2*(X[1]-O[1])^2+a^2*(x[2]-o[2])^2-a^2*b^2;
Index: /trunk/examples/henon-bifurcation.lisp
===================================================================
--- /trunk/examples/henon-bifurcation.lisp	(revision 8)
+++ /trunk/examples/henon-bifurcation.lisp	(revision 8)
@@ -0,0 +1,45 @@
+;;
+;; A computation of the places at which flip bifurcation occurrs in the
+;; quadratic family
+;; Note: period 3 finished quite easily, period 4 runs forever
+;; Two methods: grobner and resultant
+;;
+
+
+(setf order (elimination-order
+	     2
+	     :primary-order #'grevlex>
+	     :secondary-order #'grevlex>
+	     ))
+
+(setf f (cdr (string-read-poly "[a-x^2+b*y,x,a,b]" '(x y a b) :order order)))
+(setf id (cdr (string-read-poly "[x,y,a,b]" '(x y a b) :order order)))
+(setf one (string-read-poly "1" '(x y a b) :order order))
+
+(defun f-composition (n) (poly-dynamic-power f n order))
+
+;; Flip bifurcations occur when derivative is -1 at some fixed point
+;; g
+(defun g (n) (subseq (mapcar #'(lambda (x y) (poly- x y order))
+			     (f-composition n) id) 0 2))
+(defun f-jacobian (n) (characteristic-polynomial (jacobi-matrix (f-composition n) 2 2)
+						 order))
+(defun flip-value (n) (poly-scalar-composition
+		       (f-jacobian n)
+		       (cdr (string-read-poly "[x,y,a,b,-1]" '(x y a b) :order order))
+		       order))
+
+
+(defun ideal (n) (cons (flip-value n) (g n)))
+
+(defun print-ideal (n) (poly-print (cons '[ (ideal n)) '(x y a b)) (terpri))
+
+(defun bifurcation (n)
+  (mapcar #'(lambda (x) (poly-contract x 2))
+	  (elimination-ideal (ideal n) 2
+			     :order order
+			     )))
+
+(defun print-bifurcation (n)
+  (poly-print (cons '[ (bifurcation n)) '(a b))
+  (terpri))
Index: /trunk/examples/klee.lisp
===================================================================
--- /trunk/examples/klee.lisp	(revision 8)
+++ /trunk/examples/klee.lisp	(revision 8)
@@ -0,0 +1,8 @@
+(string-grobner-system
+"[-Y1^2-X1^2-2*A*X1+R1^2-A^2,-Y1^2-X1^2+2*A*X1+R2^2-A^2,R2+R1-2,-Y2^2-X2^2-2*A*X2+S1^2-A^2,-Y2^2-X2^2+2*A*X2+S2^2-A^2,S2+S1-2,X1*Y2+A*Y2-X2*Y1-A*Y1,R1*S1*U*V-S1*V-R1*V+1]"
+'(X1 Y1 X2 Y2 R1 R2 S1 S2 V)
+'(U A)
+:cover '(("[-A^2*U+U-2]" "[A]"))
+:main-order #'grevlex>
+:parameter-order #'grevlex>
+)
Index: /trunk/examples/klee.macsyma
===================================================================
--- /trunk/examples/klee.macsyma	(revision 8)
+++ /trunk/examples/klee.macsyma	(revision 8)
@@ -0,0 +1,22 @@
+if get('geometry2, 'version)=false then load(geometry2);
+X:[x1,y1]; Y:[x2,y2]; O1:[a,0]; O2:[-a,0];
+vars:[x1,y1,x2,y2,r1,r2,s1,s2,v]; params:[a];
+cover:[[],[a]];
+u:2/(1-a^2);
+concl:r1+s1-u*r1*s1;
+
+
+eqns:[
+	distance(X,O1,r1),
+	distance(X,O2,r2),
+	r1+r2-2,
+	distance(Y,O1,s1),
+	distance(Y,O2,s2),
+	s1+s2-2,
+	collinear(X,Y,O1),
+	1-v*concl
+];
+
+eqns:expand(eqns);
+cover:expand(cover);
+stringout("klee.out",eqns,vars,params,cover);
Index: /trunk/examples/klee.out
===================================================================
--- /trunk/examples/klee.out	(revision 8)
+++ /trunk/examples/klee.out	(revision 8)
@@ -0,0 +1,5 @@
+
+[Y1^2-P^2*X1^2+X1^2+P^2-1,Y2^2-P^2*X2^2+X2^2+P^2-1,-Y1^2-X1^2-2*P*X1+R1^2-P^2,-Y2^2-X2^2-2*P*X2+S1^2-P^2,X1*Y2+P*Y2-X2*Y1-P*Y1,-P^2*U+U-2,-R1^4*S1^4*U^4*V+2*R1^2*S1^4*U^2*V+2*R1^4*S1^2*U^2*V-S1^4*V+2*R1^2*S1^2*V-R1^4*V+1];
+[X1,Y1,X2,Y2,R1,R2,S1,S2,U,V];
+[P];
+[[],[P,X2*Y2-X1*Y2-X2*Y1+X1*Y1]];
Index: /trunk/examples/klee.result
===================================================================
--- /trunk/examples/klee.result	(revision 8)
+++ /trunk/examples/klee.result	(revision 8)
@@ -0,0 +1,10 @@
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [ U * A^2 - U + 2 ]
+  Red list: [ U - 4, U, A ]
+ Basis: [ ( - 1) * X1^2 + ( - 1) * Y1^2 + (1) * R2^2 + ( - 2) * R2 + (1), (1) * R1 + (1) * R2 + ( - 1), ( - 1) * X2^2 + ( - 1) * Y2^2 + (1) * S2^2 + ( - 2) * S2 + (1), (1) * S1 + (1) * S2 + ( - 1), ( - 1) * Y1 * X2 + (1) * X1 * Y2, ( - 2) * Y2 * A + (1) * A^2 + ( - 2) * S2 + (1), ( - 2) * Y1 * A + (1) * A^2 + ( - 2) * R2 + (1), (U) * R2 * S2 * V + ( - U + 1) * R2 * V + ( - U + 1) * S2 * V + (U - 2) * V + (1), ( - 4) * Y2 * R2 + (2) * A * R2 + (4) * Y1 * S2 + ( - 2) * A * S2 + ( - 2) * Y1 + (2) * Y2, (1) * X1 * A^2 + ( - 1) * X2 * A^2 + (2) * X2 * R2 + ( - 2) * X1 * S2 + (1) * X1 + ( - 1) * X2, ( - 1) * X1 * X2 * Y2 + ( - 1) * Y1 * Y2^2 + (1) * Y1 * S2^2 + ( - 2) * Y1 * S2 + (1) * Y1, ( - 4 * U) * Y1 * S2^2 * V + (2 * U) * A * S2^2 * V + (6 * U - 4) * Y1 * S2 * V + (2 * U - 4) * Y2 * S2 * V + ( - 4 * U + 4) * A * S2 * V + ( - 2 * U + 2) * Y1 * V + ( - 2 * U + 6) * Y2 * V + (2 * U - 4) * A * V + ( - 4) * Y2 + (2) * A, (4) * A^2 * R2^2 + ( - 4) * A^2 * S2^2 + ( - 8) * A^2 * R2 + (16) * Y1^2 * S2 + ( - 16) * Y1 * Y2 * S2 + (8) * A^2 * S2 + ( - 16) * R2^2 * S2 + (16) * R2 * S2^2 + ( - 12) * Y1^2 + (8) * Y1 * Y2 + (4) * Y2^2 + (8) * R2^2 + (8) * R2 * S2 + ( - 16) * S2^2 + ( - 8) * R2 + (8) * S2, ( - 8) * X1 * X2 * R2 + ( - 2) * A^2 * R2 + (8) * Y1^2 * S2 + (8) * X1 * X2 * S2 + ( - 8) * Y1 * Y2 * S2 + (2) * A^2 * S2 + ( - 8) * R2^2 * S2 + (8) * R2 * S2^2 + ( - 8) * Y1^2 + (4) * Y1 * Y2 + (4) * Y2^2 + (8) * R2^2 + (4) * R2 * S2 + ( - 12) * S2^2 + ( - 10) * R2 + (10) * S2, ( - 32) * Y1^2 * Y2 * S2 + (32) * Y1 * Y2^2 * S2 + (8) * A * R2^2 * S2 + (32) * Y1 * R2 * S2^2 + ( - 16) * A * R2 * S2^2 + ( - 32) * Y1 * S2^3 + (8) * A * S2^3 + (24) * Y1^2 * Y2 + ( - 16) * Y1 * Y2^2 + ( - 8) * Y2^3 + ( - 4) * A * R2^2 + ( - 48) * Y1 * R2 * S2 + (32) * Y1 * S2^2 + (16) * Y2 * S2^2 + (4) * A * S2^2 + (20) * Y1 * R2 + (6) * A * R2 + ( - 20) * Y2 * S2 + ( - 6) * A * S2 + ( - 6) * Y1 + (6) * Y2, (16) * X1 * Y1 * Y2 * S2 + ( - 16) * X1 * Y2^2 * S2 + ( - 8) * X2 * R2^2 * S2 + ( - 8) * X1 * R2 * S2^2 + (8) * X2 * R2 * S2^2 + (8) * X1 * S2^3 + ( - 12) * X1 * Y1 * Y2 + (8) * X1 * Y2^2 + (4) * X2 * Y2^2 + (4) * X2 * R2^2 + (16) * X1 * R2 * S2 + (8) * X2 * R2 * S2 + ( - 16) * X1 * S2^2 + ( - 12) * X2 * S2^2 + ( - 8) * X1 * R2 + ( - 8) * X2 * R2 + (8) * X1 * S2 + (8) * X2 * S2, (8) * A * R2^3 + ( - 32) * Y1^3 * S2 + (32) * Y1 * Y2^2 * S2 + (32) * Y1 * R2^2 * S2 + ( - 8) * A * R2^2 * S2 + ( - 8) * A * R2 * S2^2 + ( - 32) * Y1 * S2^3 + (8) * A * S2^3 + (24) * Y1^3 + (8) * Y1^2 * Y2 + ( - 24) * Y1 * Y2^2 + ( - 8) * Y2^3 + ( - 16) * Y1 * R2^2 + ( - 16) * A * R2^2 + ( - 80) * Y1 * R2 * S2 + (24) * A * R2 * S2 + (80) * Y1 * S2^2 + (16) * Y2 * S2^2 + ( - 8) * A * S2^2 + (48) * Y1 * R2 + (8) * A * R2 + ( - 24) * Y1 * S2 + ( - 24) * Y2 * S2 + ( - 8) * A * S2 + ( - 8) * Y1 + (8) * Y2, ( - 8) * X2 * R2^3 + (16) * X1 * Y1^2 * S2 + ( - 16) * X1 * Y2^2 * S2 + ( - 8) * X1 * R2^2 * S2 + (8) * X2 * R2 * S2^2 + (8) * X1 * S2^3 + ( - 12) * X1 * Y1^2 + ( - 4) * X1 * Y1 * Y2 + (12) * X1 * Y2^2 + (4) * X2 * Y2^2 + (4) * X1 * R2^2 + (20) * X2 * R2^2 + (24) * X1 * R2 * S2 + ( - 8) * X2 * R2 * S2 + ( - 28) * X1 * S2^2 + ( - 12) * X2 * S2^2 + ( - 16) * X1 * R2 + ( - 16) * X2 * R2 + (16) * X1 * S2 + (16) * X2 * S2, (4) * X2 * A * R2^2 + (4) * X1 * A * R2 * S2 + ( - 4) * X2 * A * R2 * S2 + ( - 4) * X1 * A * S2^2 + ( - 2) * X1 * A * R2 + ( - 6) * X2 * A * R2 + (8) * X1 * Y1 * S2 + ( - 8) * X1 * Y2 * S2 + (2) * X1 * A * S2 + (6) * X2 * A * S2 + ( - 6) * X1 * Y1 + (4) * X1 * Y2 + (2) * X2 * Y2, (4 * U) * X1 * Y2 * S2^2 * V + ( - 2 * U) * X2 * A * S2^2 * V + ( - 6 * U + 4) * X1 * Y2 * S2 * V + ( - 2 * U + 4) * X2 * Y2 * S2 * V + (4 * U - 4) * X2 * A * S2 * V + (2 * U - 2) * X1 * Y2 * V + (2 * U - 6) * X2 * Y2 * V + ( - 2 * U + 4) * X2 * A * V + (4) * X2 * Y2 + ( - 2) * X2 * A, ( - 8 * U^3) * X1 * X2 * S2^2 * V + ( - 2 * U^3) * A^2 * S2^2 * V + (4 * U^3) * Y1^2 * S2 * V + (16 * U^3 - 16 * U^2) * X1 * X2 * S2 * V + ( - 4 * U^3 + 8 * U^2) * Y1 * Y2 * S2 * V + ( - 8 * U^2) * Y2^2 * S2 * V + (4 * U^3 - 4 * U^2) * A^2 * S2 * V + (8 * U^2) * S2^3 * V + ( - 4 * U^3 + 4 * U^2) * Y1^2 * V + ( - 8 * U^3 + 16 * U^2) * X1 * X2 * V + (4 * U^3 - 12 * U^2) * Y1 * Y2 * V + (8 * U^2) * Y2^2 * V + ( - 2 * U^3 + 4 * U^2) * A^2 * V + (2 * U^3 - 28 * U^2 + 8 * U) * S2^2 * V + ( - 8 * U^2) * X1 * X2 + (8 * U^2) * Y1 * Y2 + ( - 8 * U^2) * Y2^2 + ( - 2 * U^2) * A^2 + ( - 8 * U^2) * R2 * S2 + (8 * U^2) * S2^2 + ( - 4 * U - 8) * R2 * V + ( - 4 * U^3 + 36 * U^2 - 20 * U - 8) * S2 * V + (12 * U^2) * R2 + ( - 12 * U^2 + 8 * U) * S2 + (2 * U^3 - 16 * U^2 + 16 * U + 16) * V + (2 * U^2 - 12 * U - 8), (64) * Y1^4 * S2 + ( - 64) * Y1 * Y2^3 * S2 + ( - 64) * Y1^2 * R2^2 * S2 + (64) * Y1 * Y2 * S2^3 + ( - 48) * Y1^4 + ( - 16) * Y1^3 * Y2 + (48) * Y1 * Y2^3 + (16) * Y2^4 + (32) * Y1^2 * R2^2 + (16) * R2^4 + (192) * Y1^2 * R2 * S2 + (8) * A^2 * R2 * S2 + ( - 48) * R2^3 * S2 + ( - 64) * Y1^2 * S2^2 + ( - 128) * Y1 * Y2 * S2^2 + ( - 32) * Y2^2 * S2^2 + ( - 8) * A^2 * S2^2 + (64) * R2^2 * S2^2 + ( - 48) * R2 * S2^3 + (16) * S2^4 + ( - 120) * Y1^2 * R2 + ( - 10) * A^2 * R2 + ( - 24) * R2^3 + ( - 24) * Y1^2 * S2 + (104) * Y1 * Y2 * S2 + (40) * Y2^2 * S2 + (10) * A^2 * S2 + (40) * R2^2 * S2 + ( - 24) * R2 * S2^2 + (8) * S2^3 + (40) * Y1^2 + ( - 28) * Y1 * Y2 + ( - 12) * Y2^2 + (24) * R2^2 + ( - 20) * R2 * S2 + ( - 4) * S2^2 + ( - 10) * R2 + (10) * S2, ( - 32 * U^3) * A * S2^4 * V + ( - 32 * U^3 + 128 * U^2) * Y1 * Y2^2 * S2 * V + (32 * U^3 - 128 * U^2) * Y2^3 * S2 * V + ( - 64 * U^3 + 128 * U^2) * Y2 * S2^3 * V + (136 * U^3 - 96 * U^2) * A * S2^3 * V + ( - 8 * U^3 + 32 * U^2) * Y1^2 * Y2 * V + (48 * U^3 - 192 * U^2) * Y1 * Y2^2 * V + ( - 40 * U^3 + 160 * U^2) * Y2^3 * V + (4 * U^3 - 8 * U^2) * A * R2^2 * V + (208 * U^3 - 544 * U^2 + 128 * U) * Y2 * S2^2 * V + ( - 220 * U^3 + 320 * U^2 - 32 * U) * A * S2^2 * V + (128 * U^2) * Y1 * Y2^2 + ( - 128 * U^2) * Y2^3 + ( - 32 * U^2) * A * R2 * S2 + ( - 128 * U^2) * Y1 * S2^2 + (128 * U^2) * Y2 * S2^2 + (4 * U^3 - 16 * U^2 + 32 * U) * Y1 * R2 * V + ( - 10 * U^3 + 32 * U^2 - 24 * U - 32) * A * R2 * V + ( - 32 * U - 128) * Y1 * S2 * V + ( - 228 * U^3 + 752 * U^2 - 320 * U - 128) * Y2 * S2 * V + (162 * U^3 - 368 * U^2 + 104 * U + 96) * A * S2 * V + (40 * U^2) * A * R2 + (224 * U^2) * Y1 * S2 + ( - 288 * U^2 + 128 * U) * Y2 * S2 + (32 * U^2 - 32 * U) * A * S2 + ( - 6 * U^3 + 32 * U^2 - 32 * U + 64) * Y1 * V + (86 * U^3 - 352 * U^2 + 224 * U + 192) * Y2 * V + ( - 40 * U^3 + 120 * U^2 - 48 * U - 64) * A * V + ( - 96 * U^2 + 32 * U) * Y1 + (176 * U^2 - 192 * U - 128) * Y2 + ( - 40 * U^2 + 40 * U + 32) * A, (32 * U^3) * X1 * S2^4 * V + (16 * U^3 - 64 * U^2) * X1 * Y2^2 * S2 * V + ( - 16 * U^3 + 64 * U^2) * X2 * Y2^2 * S2 * V + ( - 120 * U^3 + 64 * U^2) * X1 * S2^3 * V + (16 * U^3 - 32 * U^2) * X2 * S2^3 * V + (4 * U^3 - 16 * U^2) * X1 * Y1 * Y2 * V + ( - 24 * U^3 + 96 * U^2) * X1 * Y2^2 * V + (20 * U^3 - 80 * U^2) * X2 * Y2^2 * V + ( - 4 * U^3 + 8 * U^2) * X2 * R2^2 * V + (168 * U^3 - 184 * U^2) * X1 * S2^2 * V + ( - 52 * U^3 + 136 * U^2 - 32 * U) * X2 * S2^2 * V + ( - 64 * U^2) * X1 * Y2^2 + (64 * U^2) * X2 * Y2^2 + (32 * U^2) * X2 * R2 * S2 + (32 * U^2) * X1 * S2^2 + ( - 32 * U^2) * X2 * S2^2 + ( - 8 * U) * X1 * R2 * V + (8 * U^3 - 24 * U^2 + 16 * U + 32) * X2 * R2 * V + ( - 104 * U^3 + 176 * U^2 - 8 * U) * X1 * S2 * V + (56 * U^3 - 184 * U^2 + 80 * U + 32) * X2 * S2 * V + ( - 40 * U^2) * X2 * R2 + ( - 56 * U^2) * X1 * S2 + (56 * U^2 - 32 * U) * X2 * S2 + (24 * U^3 - 56 * U^2 + 16 * U) * X1 * V + ( - 24 * U^3 + 96 * U^2 - 64 * U - 64) * X2 * V + (24 * U^2 - 8 * U) * X1 + ( - 24 * U^2 + 48 * U + 32) * X2, (16 * U^3) * Y1^3 * S2 * V + ( - 16 * U^3) * Y1 * Y2^2 * S2 * V + ( - 16 * U^3 + 16 * U^2) * Y1^3 * V + (8 * U^3 - 48 * U^2) * Y1^2 * Y2 * V + (48 * U^2) * Y1 * Y2^2 * V + (8 * U^3 - 16 * U^2) * Y2^3 * V + ( - 4 * U^3 + 16 * U^2) * A * R2^2 * V + ( - 8 * U^3) * Y2 * S2^2 * V + ( - 16 * U^2) * A * S2^2 * V + (64 * U^2) * Y1^2 * Y2 + ( - 64 * U^2) * Y1 * Y2^2 + ( - 16 * U^2) * A * R2^2 + ( - 64 * U^2) * Y1 * R2 * S2 + (32 * U^2) * A * R2 * S2 + (64 * U^2) * Y1 * S2^2 + ( - 16 * U^2) * A * S2^2 + ( - 4 * U^3 + 24 * U^2 - 64 * U) * Y1 * R2 * V + (10 * U^3 - 52 * U^2 + 32 * U) * A * R2 * V + (4 * U^3 - 8 * U^2) * Y1 * S2 * V + (16 * U^3 - 32 * U^2 + 64 * U) * Y2 * S2 * V + ( - 2 * U^3 + 44 * U^2 - 32 * U) * A * S2 * V + (64 * U^2) * Y1 * R2 + (16 * U^2) * A * R2 + ( - 32 * U^2) * Y1 * S2 + ( - 32 * U^2) * Y2 * S2 + ( - 16 * U^2) * A * S2 + (2 * U^3 - 32 * U^2 + 96 * U) * Y1 * V + ( - 10 * U^3 + 48 * U^2 - 96 * U) * Y2 * V + ( - 4 * U^3 + 8 * U^2) * A * V + ( - 8 * U^2 - 64 * U) * Y1 + (64 * U) * Y2 + ( - 4 * U^2) * A, ( - 8 * U^3) * X1 * Y1^2 * S2 * V + (8 * U^3) * X1 * Y2^2 * S2 * V + (8 * U^3 - 8 * U^2) * X1 * Y1^2 * V + ( - 4 * U^3 + 24 * U^2) * X1 * Y1 * Y2 * V + ( - 24 * U^2) * X1 * Y2^2 * V + ( - 4 * U^3 + 8 * U^2) * X2 * Y2^2 * V + (4 * U^3 - 16 * U^2) * X2 * R2^2 * V + (16 * U^2) * X1 * S2^2 * V + (4 * U^3) * X2 * S2^2 * V + ( - 32 * U^2) * X1 * Y1 * Y2 + (32 * U^2) * X1 * Y2^2 + (16 * U^2) * X2 * R2^2 + (16 * U^2) * X1 * R2 * S2 + ( - 16 * U^2) * X2 * R2 * S2 + ( - 16 * U^2) * X1 * S2^2 + (16 * U) * X1 * R2 * V + ( - 8 * U^3 + 40 * U^2 - 16 * U) * X2 * R2 * V + ( - 32 * U^2 + 16 * U) * X1 * S2 * V + ( - 8 * U^3 + 8 * U^2 - 16 * U) * X2 * S2 * V + ( - 24 * U^2) * X1 * R2 + ( - 24 * U^2) * X2 * R2 + (24 * U^2) * X1 * S2 + (24 * U^2) * X2 * S2 + (16 * U^2 - 32 * U) * X1 * V + (8 * U^3 - 32 * U^2 + 32 * U) * X2 * V + (16 * U) * X1 + (8 * U^2 - 16 * U) * X2, (4 * U^3) * A^2 * S2^3 * V + ( - 12 * U^3 + 4 * U^2) * A^2 * S2^2 * V + ( - 4 * U) * A^2 * R2 * V + (4 * U^3) * Y1^2 * S2 * V + ( - 8 * U^3 + 16 * U^2) * Y1 * Y2 * S2 * V + (4 * U^3 - 16 * U^2) * Y2^2 * S2 * V + (12 * U^3 - 8 * U^2 - 4 * U) * A^2 * S2 * V + ( - 8 * U^3 + 16 * U^2) * S2^3 * V + (4 * U^2) * A^2 * R2 + ( - 4 * U^3 + 4 * U^2) * Y1^2 * V + (8 * U^3 - 24 * U^2) * Y1 * Y2 * V + ( - 4 * U^3 + 20 * U^2) * Y2^2 * V + ( - 4 * U^3 + 4 * U^2 + 8 * U) * A^2 * V + (24 * U^3 - 64 * U^2 + 16 * U) * S2^2 * V + (16 * U^2) * Y1 * Y2 + ( - 16 * U^2) * Y2^2 + ( - 4 * U^2 - 4 * U) * A^2 + ( - 16 * U^2) * R2 * S2 + (16 * U^2) * S2^2 + ( - 16) * R2 * V + ( - 24 * U^3 + 80 * U^2 - 32 * U - 16) * S2 * V + (16 * U^2) * R2 + ( - 24 * U^2 + 16 * U) * S2 + (8 * U^3 - 32 * U^2 + 16 * U + 32) * V + (8 * U^2 - 16 * U - 16), (4 * U^2) * X1 * A * S2^3 * V + ( - 14 * U^2 + 8 * U) * X1 * A * S2^2 * V + (2 * U^2 - 4 * U) * X2 * A * S2^2 * V + ( - 4) * X2 * A * R2 * V + (2 * U^2) * X1 * Y1 * S2 * V + ( - 4 * U^2 + 8 * U) * X1 * Y2 * S2 * V + (2 * U^2 - 8 * U) * X2 * Y2 * S2 * V + (16 * U^2 - 20 * U) * X1 * A * S2 * V + ( - 4 * U^2 + 12 * U - 4) * X2 * A * S2 * V + (4 * U) * X2 * A * R2 + (4 * U) * X1 * A * S2 + ( - 4 * U) * X2 * A * S2 + ( - 2 * U^2 + 2 * U) * X1 * Y1 * V + (4 * U^2 - 12 * U) * X1 * Y2 * V + ( - 2 * U^2 + 10 * U) * X2 * Y2 * V + ( - 6 * U^2 + 12 * U) * X1 * A * V + (2 * U^2 - 8 * U + 8) * X2 * A * V + (8 * U) * X1 * Y2 + ( - 8 * U) * X2 * Y2 + ( - 6 * U) * X1 * A + (2 * U - 4) * X2 * A, ( - 8 * U^3 + 32 * U^2) * Y1^3 * Y2 * V + (24 * U^3 - 96 * U^2) * Y1^2 * Y2^2 * V + ( - 24 * U^3 + 96 * U^2) * Y1 * Y2^3 * V + (8 * U^3 - 32 * U^2) * Y2^4 * V + ( - 16 * U^3 + 32 * U^2) * Y2^2 * S2^2 * V + (4 * U^3 - 8 * U^2) * A^2 * S2^2 * V + (8 * U^3) * S2^4 * V + (128 * U^2) * Y1^2 * Y2^2 + ( - 128 * U^2) * Y1 * Y2^3 + ( - 128 * U^2) * Y1^2 * S2^2 + (128 * U^2) * Y1 * Y2 * S2^2 + (4 * U^3 - 16 * U^2 + 32 * U) * Y1^2 * R2 * V + ( - U^3 + 4 * U^2 - 8 * U) * A^2 * R2 * V + ( - 4 * U^3 + 8 * U^2) * R2^3 * V + ( - 4 * U^3 + 16 * U^2 - 64 * U) * Y1^2 * S2 * V + ( - 12 * U^3 + 48 * U^2) * Y1 * Y2 * S2 * V + (44 * U^3 - 144 * U^2 + 96 * U) * Y2^2 * S2 * V + ( - 7 * U^3 + 20 * U^2 - 8 * U) * A^2 * S2 * V + ( - 44 * U^3 + 56 * U^2) * S2^3 * V + (16 * U^2) * A^2 * R2 + (224 * U^2) * Y1^2 * S2 + ( - 192 * U^2) * Y1 * Y2 * S2 + ( - 32 * U^2) * Y2^2 * S2 + ( - 16 * U^2) * A^2 * S2 + (32 * U^2) * R2^2 * S2 + ( - 64 * U^2) * R2 * S2^2 + (32 * U^2) * S2^3 + ( - 4 * U^3 + 24 * U^2 - 16 * U) * Y1^2 * V + (18 * U^3 - 96 * U^2 + 96 * U) * Y1 * Y2 * V + ( - 30 * U^3 + 136 * U^2 - 144 * U) * Y2^2 * V + (4 * U^3 - 16 * U^2 + 16 * U) * A^2 * V + (16 * U^3 - 52 * U^2 + 48 * U) * R2^2 * V + (82 * U^3 - 196 * U^2 + 96 * U) * S2^2 * V + ( - 96 * U^2 + 32 * U) * Y1^2 + (112 * U^2 - 96 * U) * Y1 * Y2 + ( - 32 * U^2 + 96 * U) * Y2^2 + (4 * U^2 - 8 * U) * A^2 + ( - 40 * U^2) * R2^2 + (40 * U^2) * R2 * S2 + (8 * U^2) * S2^2 + ( - 19 * U^3 + 82 * U^2 - 120 * U + 48) * R2 * V + ( - 65 * U^3 + 226 * U^2 - 216 * U + 48) * S2 * V + (20 * U^2) * R2 + ( - 52 * U^2 + 48 * U) * S2 + (26 * U^3 - 124 * U^2 + 192 * U - 96) * V + (26 * U^2 - 72 * U + 48), (64 * U^4 - 256 * U^3) * Y1 * Y2^3 * S2 * V + ( - 64 * U^4 + 256 * U^3) * Y2^4 * S2 * V + (128 * U^4 - 256 * U^3) * Y2^2 * S2^3 * V + ( - 64 * U^4) * S2^5 * V + (16 * U^4 - 64 * U^3) * Y1^2 * Y2^2 * V + ( - 96 * U^4 + 384 * U^3) * Y1 * Y2^3 * V + (80 * U^4 - 320 * U^3) * Y2^4 * V + ( - 448 * U^4 + 1216 * U^3 - 256 * U^2) * Y2^2 * S2^2 * V + (8 * U^4 - 48 * U^3) * A^2 * S2^2 * V + (368 * U^4 - 320 * U^3) * S2^4 * V + ( - 256 * U^3) * Y1 * Y2^3 + (256 * U^3) * Y2^4 + (256 * U^3) * Y1 * Y2 * S2^2 + ( - 256 * U^3) * Y2^2 * S2^2 + ( - 8 * U^3 + 64 * U) * A^2 * R2 * V + (32 * U^4 - 64 * U^3 - 64 * U^2) * Y1^2 * S2 * V + ( - 80 * U^4 + 288 * U^3 - 64 * U^2 + 256 * U) * Y1 * Y2 * S2 * V + (560 * U^4 - 2016 * U^3 + 1024 * U^2 + 256 * U) * Y2^2 * S2 * V + ( - 16 * U^4 + 120 * U^3 - 96 * U^2 - 64 * U) * A^2 * S2 * V + ( - 880 * U^4 + 1600 * U^3 - 448 * U^2) * S2^3 * V + ( - 64 * U^2) * A^2 * R2 + ( - 576 * U^3) * Y1 * Y2 * S2 + (704 * U^3 - 256 * U^2) * Y2^2 * S2 + (64 * U^2) * A^2 * S2 + (64 * U^3) * R2 * S2^2 + ( - 128 * U^3) * S2^3 + ( - 32 * U^4 + 96 * U^3 - 32 * U^2) * Y1^2 * V + (80 * U^4 - 384 * U^3 + 352 * U^2 - 128 * U) * Y1 * Y2 * V + ( - 240 * U^4 + 1120 * U^3 - 960 * U^2 - 384 * U) * Y2^2 * V + (8 * U^4 - 64 * U^3 + 96 * U^2) * A^2 * V + (16 * U^2) * R2^2 * V + (1064 * U^4 - 2976 * U^3 + 1840 * U^2 + 64 * U) * S2^2 * V + (384 * U^3 - 320 * U^2) * Y1 * Y2 + ( - 576 * U^3 + 768 * U^2 + 256 * U) * Y2^2 + (8 * U^3 - 48 * U^2) * A^2 + ( - 176 * U^3 + 256 * U^2) * R2 * S2 + (416 * U^3 - 448 * U^2) * S2^2 + (8 * U^3 - 80 * U^2 + 192) * R2 * V + ( - 640 * U^4 + 2408 * U^3 - 2288 * U^2 + 192) * S2 * V + (144 * U^3 - 272 * U^2) * R2 + ( - 480 * U^3 + 880 * U^2 - 64 * U) * S2 + (152 * U^4 - 720 * U^3 + 960 * U^2 - 64 * U - 384) * V + (152 * U^3 - 416 * U^2 + 128 * U + 192), (8 * U^3) * X2 * A * S2^3 * V + (8 * U^3 - 32 * U^2) * X1 * Y1^2 * Y2 * V + ( - 24 * U^3 + 96 * U^2) * X1 * Y1 * Y2^2 * V + (24 * U^3 - 96 * U^2) * X1 * Y2^3 * V + ( - 8 * U^3 + 32 * U^2) * X2 * Y2^3 * V + ( - 4 * U^3 + 8 * U^2) * X1 * A * R2^2 * V + (16 * U^3 - 32 * U^2) * X2 * Y2 * S2^2 * V + (4 * U^3 - 24 * U^2) * X1 * A * S2^2 * V + ( - 32 * U^3 + 40 * U^2) * X2 * A * S2^2 * V + ( - 128 * U^2) * X1 * Y1 * Y2^2 + (128 * U^2) * X1 * Y2^3 + (32 * U^2) * X1 * A * R2 * S2 + ( - 32 * U^2) * X2 * A * R2 * S2 + (128 * U^2) * X1 * Y1 * S2^2 + ( - 128 * U^2) * X1 * Y2 * S2^2 + ( - 32 * U^2) * X1 * A * S2^2 + (32 * U^2) * X2 * A * S2^2 + ( - 4 * U^3 + 16 * U^2 - 32 * U) * X1 * Y1 * R2 * V + (10 * U^3 - 32 * U^2 + 32 * U) * X1 * A * R2 * V + (8 * U^2 - 24 * U) * X2 * A * R2 * V + (64 * U) * X1 * Y1 * S2 * V + (12 * U^3 - 48 * U^2) * X1 * Y2 * S2 * V + ( - 40 * U^3 + 128 * U^2 - 96 * U) * X2 * Y2 * S2 * V + ( - 10 * U^3 + 64 * U^2 - 64 * U) * X1 * A * S2 * V + (40 * U^3 - 104 * U^2 + 72 * U) * X2 * A * S2 * V + ( - 40 * U^2) * X1 * A * R2 + (16 * U^2) * X2 * A * R2 + ( - 224 * U^2) * X1 * Y1 * S2 + (192 * U^2) * X1 * Y2 * S2 + (32 * U^2) * X2 * Y2 * S2 + (40 * U^2) * X1 * A * S2 + ( - 8 * U^2) * X2 * A * S2 + (6 * U^3 - 32 * U^2 + 16 * U) * X1 * Y1 * V + ( - 14 * U^3 + 80 * U^2 - 96 * U) * X1 * Y2 * V + (24 * U^3 - 112 * U^2 + 144 * U) * X2 * Y2 * V + ( - 16 * U^2 + 32 * U) * X1 * A * V + ( - 16 * U^3 + 56 * U^2 - 48 * U) * X2 * A * V + (96 * U^2 - 32 * U) * X1 * Y1 + ( - 96 * U^2 + 96 * U) * X1 * Y2 + (16 * U^2 - 96 * U) * X2 * Y2 + ( - 16 * U) * X1 * A + ( - 16 * U^2 + 24 * U) * X2 * A, (16 * U^3 - 64 * U^2) * Y1^4 * V + ( - 96 * U^3 + 384 * U^2) * Y1^2 * Y2^2 * V + (128 * U^3 - 512 * U^2) * Y1 * Y2^3 * V + ( - 48 * U^3 + 192 * U^2) * Y2^4 * V + ( - 32 * U^3 + 64 * U^2) * Y1^2 * R2^2 * V + (16 * U^3) * R2^4 * V + (96 * U^3 - 192 * U^2) * Y2^2 * S2^2 * V + ( - 16 * U^3 + 32 * U^2) * A^2 * S2^2 * V + ( - 48 * U^3) * S2^4 * V + ( - 256 * U^2) * Y1^3 * Y2 + ( - 512 * U^2) * Y1^2 * Y2^2 + (768 * U^2) * Y1 * Y2^3 + (256 * U^2) * Y1^2 * R2 * S2 + ( - 64 * U^2) * A^2 * R2 * S2 + (512 * U^2) * Y1^2 * S2^2 + ( - 768 * U^2) * Y1 * Y2 * S2^2 + (64 * U^2) * A^2 * S2^2 + (64 * U^3 - 192 * U^2) * Y1^2 * R2 * V + (16 * U^2) * A^2 * R2 * V + ( - 64 * U^3 + 64 * U^2) * R2^3 * V + ( - 32 * U^3 + 64 * U^2 + 384 * U) * Y1^2 * S2 * V + (96 * U^3 - 320 * U^2 - 128 * U) * Y1 * Y2 * S2 * V + ( - 256 * U^3 + 832 * U^2 - 512 * U) * Y2^2 * S2 * V + (32 * U^3 - 112 * U^2 + 64 * U) * A^2 * S2 * V + (256 * U^3 - 320 * U^2) * S2^3 * V + ( - 192 * U^2) * Y1^2 * R2 + ( - 80 * U^2) * A^2 * R2 + ( - 64 * U^2) * R2^3 + ( - 1344 * U^2) * Y1^2 * S2 + (1344 * U^2) * Y1 * Y2 * S2 + (192 * U^2) * Y2^2 * S2 + (80 * U^2) * A^2 * S2 + (64 * U^2) * R2^2 * S2 + (192 * U^2) * R2 * S2^2 + ( - 192 * U^2) * S2^3 + (32 * U^2 - 192 * U) * Y1^2 * V + ( - 96 * U^3 + 448 * U^2 - 320 * U) * Y1 * Y2 * V + (160 * U^3 - 736 * U^2 + 768 * U) * Y2^2 * V + ( - 16 * U^3 + 64 * U^2 - 64 * U) * A^2 * V + (96 * U^3 - 192 * U^2 - 32 * U) * R2^2 * V + ( - 464 * U^3 + 1120 * U^2 - 608 * U) * S2^2 * V + (576 * U^2) * Y1^2 + ( - 672 * U^2 + 384 * U) * Y1 * Y2 + (160 * U^2 - 512 * U) * Y2^2 + ( - 16 * U^2 + 32 * U) * A^2 + (320 * U^2) * R2^2 + ( - 448 * U^2) * R2 * S2 + (96 * U^2) * S2^2 + ( - 64 * U^3 + 176 * U^2 + 128 * U - 256) * R2 * V + (352 * U^3 - 1232 * U^2 + 1216 * U - 256) * S2 * V + ( - 208 * U^2 + 160 * U) * R2 + (336 * U^2 - 352 * U) * S2 + ( - 80 * U^3 + 384 * U^2 - 704 * U + 512) * V + ( - 80 * U^2 + 224 * U - 256), ( - 32 * U^5 + 128 * U^4) * X1 * Y1^2 * Y2^2 * V + (96 * U^5 - 384 * U^4) * X1 * Y1 * Y2^3 * V + ( - 96 * U^5 + 384 * U^4) * X1 * Y2^4 * V + (32 * U^5 - 128 * U^4) * X2 * Y2^4 * V + ( - 64 * U^5 + 128 * U^4) * X2 * Y2^2 * S2^2 * V + (16 * U^5 - 32 * U^4) * X2 * A^2 * S2^2 * V + (32 * U^5) * X2 * S2^4 * V + (512 * U^4) * X1 * Y1 * Y2^3 + ( - 512 * U^4) * X1 * Y2^4 + ( - 256 * U^4) * X2 * R2^2 * S2^2 + ( - 256 * U^4) * X1 * R2 * S2^3 + (256 * U^4) * X2 * R2 * S2^3 + (256 * U^4) * X1 * S2^4 + ( - 48 * U^5 + 192 * U^4 - 128 * U^3) * X1 * Y2^2 * S2 * V + (176 * U^5 - 576 * U^4 + 384 * U^3) * X2 * Y2^2 * S2 * V + ( - 32 * U^5 + 96 * U^4 - 64 * U^3) * X2 * A^2 * S2 * V + ( - 8 * U^5 + 128 * U^3) * X1 * S2^3 * V + ( - 176 * U^5 + 224 * U^4) * X2 * S2^3 * V + (64 * U^4) * X2 * A^2 * R2 + ( - 64 * U^4) * X2 * A^2 * S2 + (512 * U^4) * X2 * R2^2 * S2 + (768 * U^4) * X1 * R2 * S2^2 + ( - 256 * U^4) * X2 * R2 * S2^2 + ( - 768 * U^4) * X1 * S2^3 + ( - 256 * U^4) * X2 * S2^3 + (64 * U^3 - 128 * U^2) * X1 * Y1^2 * V + ( - 4 * U^5 + 48 * U^4 - 256 * U^3 + 384 * U^2) * X1 * Y1 * Y2 * V + (56 * U^5 - 320 * U^4 + 512 * U^3 - 384 * U^2) * X1 * Y2^2 * V + ( - 116 * U^5 + 528 * U^4 - 576 * U^3 + 128 * U^2) * X2 * Y2^2 * V + (16 * U^5 - 64 * U^4 + 64 * U^3) * X2 * A^2 * V + ( - 32 * U^3) * X1 * R2^2 * V + (4 * U^5 - 40 * U^4 + 96 * U^3 - 128 * U^2) * X2 * R2^2 * V + (24 * U^5 - 8 * U^4 - 480 * U^3 + 384 * U^2) * X1 * S2^2 * V + (324 * U^5 - 776 * U^4 + 384 * U^3 - 128 * U^2) * X2 * S2^2 * V + (64 * U^4 + 128 * U^3 - 512 * U^2) * X1 * Y1 * Y2 + (128 * U^4 - 384 * U^3 + 512 * U^2) * X1 * Y2^2 + ( - 256 * U^4 + 384 * U^3) * X2 * Y2^2 + (16 * U^4 - 32 * U^3) * X2 * A^2 + ( - 320 * U^4 + 256 * U^2) * X2 * R2^2 + ( - 800 * U^4 + 256 * U^2) * X1 * R2 * S2 + ( - 320 * U^4 - 256 * U^2) * X2 * R2 * S2 + (800 * U^4 - 256 * U^2) * X1 * S2^2 + (672 * U^4) * X2 * S2^2 + (72 * U^3 - 128 * U^2 + 128 * U) * X1 * R2 * V + ( - 8 * U^5 + 88 * U^4 - 272 * U^3 + 416 * U^2 - 256 * U) * X2 * R2 * V + ( - 24 * U^5 + 16 * U^4 + 584 * U^3 - 896 * U^2 + 128 * U) * X1 * S2 * V + ( - 248 * U^5 + 856 * U^4 - 784 * U^3 + 416 * U^2 - 256 * U) * X2 * S2 * V + (288 * U^4 + 32 * U^3 - 384 * U^2) * X1 * R2 + (392 * U^4 - 32 * U^3 - 256 * U^2) * X2 * R2 + ( - 296 * U^4 - 32 * U^3 + 512 * U^2) * X1 * S2 + ( - 504 * U^4 + 192 * U^3 + 256 * U^2) * X2 * S2 + (8 * U^5 - 8 * U^4 - 272 * U^3 + 640 * U^2 - 256 * U) * X1 * V + (72 * U^5 - 352 * U^4 + 576 * U^3 - 576 * U^2 + 512 * U) * X2 * V + (8 * U^4 + 8 * U^3 - 256 * U^2 + 128 * U) * X1 + (72 * U^4 - 208 * U^3 + 160 * U^2 - 256 * U) * X2, (256 * U^5 - 1024 * U^4) * Y2^4 * S2^2 * V + ( - 16 * U^5 + 64 * U^4) * A^4 * S2^2 * V + ( - 512 * U^5 + 1024 * U^4) * Y2^2 * S2^4 * V + (256 * U^5) * S2^6 * V + ( - 512 * U^5 + 2560 * U^4 - 2048 * U^3) * Y2^4 * S2 * V + (32 * U^5 - 160 * U^4 + 128 * U^3) * A^4 * S2 * V + (2048 * U^5 - 6144 * U^4 + 2048 * U^3) * Y2^2 * S2^3 * V + ( - 1536 * U^5 + 1536 * U^4) * S2^5 * V + (1024 * U^4) * Y1 * Y2^3 * S2 + ( - 1024 * U^4) * Y2^4 * S2 + ( - 1024 * U^4) * Y1 * Y2 * S2^3 + (1024 * U^4) * Y2^2 * S2^3 + ( - 32 * U^5 + 64 * U^4 + 256 * U^3) * Y1^2 * Y2^2 * V + (64 * U^5 - 1024 * U^3) * Y1 * Y2^3 * V + (224 * U^5 - 1600 * U^4 + 2816 * U^3) * Y2^4 * V + ( - 16 * U^5 + 96 * U^4 - 128 * U^3) * A^4 * V + ( - 3008 * U^5 + 12544 * U^4 - 9984 * U^3) * Y2^2 * S2^2 * V + (48 * U^5 - 192 * U^4 + 192 * U^3) * A^2 * S2^2 * V + (3808 * U^5 - 7872 * U^4 + 3072 * U^3) * S2^4 * V + ( - 256 * U^4 + 1024 * U^3) * Y1 * Y2^3 + (512 * U^4 - 2048 * U^3) * Y2^4 + ( - 16 * U^4 + 64 * U^3) * A^4 + (256 * U^3) * A^2 * R2 * S2 + (2560 * U^4 - 1024 * U^3) * Y1 * Y2 * S2^2 + ( - 3072 * U^4 + 2048 * U^3) * Y2^2 * S2^2 + ( - 256 * U^3) * A^2 * S2^2 + ( - 256 * U^4) * R2 * S2^3 + (512 * U^4) * S2^4 + (16 * U^4 + 64 * U^3 - 256 * U^2) * A^2 * R2 * V + ( - 64 * U^5 + 384 * U^3 + 256 * U^2) * Y1^2 * S2 * V + (96 * U^5 - 896 * U^3 - 768 * U^2) * Y1 * Y2 * S2 * V + (1888 * U^5 - 10624 * U^4 + 14848 * U^3 - 3072 * U^2) * Y2^2 * S2 * V + ( - 96 * U^5 + 464 * U^4 - 832 * U^3 + 640 * U^2) * A^2 * S2 * V + ( - 4960 * U^5 + 16064 * U^4 - 13312 * U^3 + 2048 * U^2) * S2^3 * V + ( - 32 * U^4 + 256 * U^2) * A^2 * R2 + ( - 2048 * U^4 + 3328 * U^3) * Y1 * Y2 * S2 + (3072 * U^4 - 6400 * U^3) * Y2^2 * S2 + (32 * U^4 - 256 * U^2) * A^2 * S2 + (768 * U^4 - 1280 * U^3) * R2 * S2^2 + ( - 1792 * U^4 + 2304 * U^3) * S2^3 + (64 * U^5 - 64 * U^4 - 320 * U^3 + 128 * U^2) * Y1^2 * V + ( - 96 * U^5 + 128 * U^4 + 1024 * U^3 - 896 * U^2) * Y1 * Y2 * V + ( - 416 * U^5 + 3136 * U^4 - 7104 * U^3 + 4352 * U^2) * Y2^2 * V + (48 * U^5 - 288 * U^4 + 576 * U^3 - 384 * U^2) * A^2 * V + ( - 32 * U^3 - 64 * U^2) * R2^2 * V + (3520 * U^5 - 16032 * U^4 + 21472 * U^3 - 8384 * U^2) * S2^2 * V + (320 * U^4 - 1664 * U^3 + 1280 * U^2) * Y1 * Y2 + ( - 768 * U^4 + 3968 * U^3 - 3072 * U^2) * Y2^2 + (48 * U^4 - 192 * U^3 + 192 * U^2) * A^2 + ( - 608 * U^4 + 1728 * U^3 - 1024 * U^2) * R2 * S2 + (2112 * U^4 - 4992 * U^3 + 2048 * U^2) * S2^2 + ( - 16 * U^4 + 96 * U^3 + 512 * U^2 - 1024 * U) * R2 * V + ( - 1248 * U^5 + 7632 * U^4 - 14880 * U^3 + 10112 * U^2 - 1024 * U) * S2 * V + (64 * U^4 - 672 * U^3 + 1088 * U^2) * R2 + ( - 992 * U^4 + 4128 * U^3 - 3776 * U^2) * S2 + (160 * U^5 - 1312 * U^4 + 3584 * U^3 - 4224 * U^2 + 2048 * U) * V + (160 * U^4 - 992 * U^3 + 1600 * U^2 - 1024 * U), (64 * U^4 - 256 * U^3) * X1 * Y2^4 * S2 * V + ( - 64 * U^4 + 256 * U^3) * X2 * Y2^4 * S2 * V + (128 * U^4 - 256 * U^3) * X2 * Y2^2 * S2^3 * V + ( - 64 * U^4) * X2 * S2^5 * V + (16 * U^4 - 64 * U^3) * X1 * Y1 * Y2^3 * V + ( - 96 * U^4 + 384 * U^3) * X1 * Y2^4 * V + (80 * U^4 - 320 * U^3) * X2 * Y2^4 * V + ( - 448 * U^4 + 1216 * U^3 - 256 * U^2) * X2 * Y2^2 * S2^2 * V + (8 * U^4 - 48 * U^3) * X2 * A^2 * S2^2 * V + (368 * U^4 - 320 * U^3) * X2 * S2^4 * V + ( - 256 * U^3) * X1 * Y2^4 + (256 * U^3) * X2 * Y2^4 + (256 * U^3) * X1 * Y2^2 * S2^2 + ( - 256 * U^3) * X2 * Y2^2 * S2^2 + ( - 8 * U^3 + 64 * U) * X2 * A^2 * R2 * V + ( - 48 * U^4 + 224 * U^3 - 128 * U^2 + 256 * U) * X1 * Y2^2 * S2 * V + (560 * U^4 - 2016 * U^3 + 1024 * U^2 + 256 * U) * X2 * Y2^2 * S2 * V + ( - 16 * U^4 + 120 * U^3 - 96 * U^2 - 64 * U) * X2 * A^2 * S2 * V + ( - 16 * U^4 + 32 * U^3 + 32 * U^2) * X1 * S2^3 * V + ( - 880 * U^4 + 1600 * U^3 - 448 * U^2) * X2 * S2^3 * V + ( - 64 * U^2) * X2 * A^2 * R2 + ( - 576 * U^3) * X1 * Y2^2 * S2 + (704 * U^3 - 256 * U^2) * X2 * Y2^2 * S2 + (64 * U^2) * X2 * A^2 * S2 + (64 * U^3) * X2 * R2 * S2^2 + ( - 128 * U^3) * X2 * S2^3 + ( - 8 * U^4 + 48 * U^3 - 80 * U^2) * X1 * Y1 * Y2 * V + (64 * U^4 - 352 * U^3 + 384 * U^2 - 128 * U) * X1 * Y2^2 * V + ( - 248 * U^4 + 1136 * U^3 - 944 * U^2 - 384 * U) * X2 * Y2^2 * V + (8 * U^4 - 64 * U^3 + 96 * U^2) * X2 * A^2 * V + (8 * U^4 - 32 * U^3 + 32 * U^2 + 32 * U) * X2 * R2^2 * V + (48 * U^4 - 112 * U^3 - 64 * U^2 + 32 * U) * X1 * S2^2 * V + (1072 * U^4 - 2976 * U^3 + 1792 * U^2 + 32 * U) * X2 * S2^2 * V + (384 * U^3 - 320 * U^2) * X1 * Y2^2 + ( - 576 * U^3 + 768 * U^2 + 256 * U) * X2 * Y2^2 + (8 * U^3 - 48 * U^2) * X2 * A^2 + ( - 176 * U^3 + 256 * U^2) * X2 * R2 * S2 + (416 * U^3 - 448 * U^2) * X2 * S2^2 + (16 * U^2 - 32 * U - 32) * X1 * R2 * V + ( - 16 * U^4 + 88 * U^3 - 144 * U^2 - 96 * U + 192) * X2 * R2 * V + ( - 48 * U^4 + 128 * U^3 + 48 * U^2 - 96 * U - 32) * X1 * S2 * V + ( - 656 * U^4 + 2424 * U^3 - 2224 * U^2 + 32 * U + 192) * X2 * S2 * V + (128 * U^3 - 240 * U^2 + 32 * U) * X2 * R2 + ( - 16 * U^3 + 32 * U^2 + 32 * U) * X1 * S2 + ( - 464 * U^3 + 848 * U^2 - 96 * U) * X2 * S2 + (16 * U^4 - 48 * U^3 - 32 * U^2 + 96 * U + 64) * X1 * V + (168 * U^4 - 784 * U^3 + 992 * U^2 - 384) * X2 * V + (16 * U^3 - 16 * U^2 - 64 * U - 32) * X1 + (168 * U^3 - 448 * U^2 + 96 * U + 192) * X2 ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [ U - 4, 2 * A^2 - 1 ]
+  Red list: [ A ]
+ Basis: [ ( - 1) * X1^2 + ( - 1) * Y1^2 + (1) * R2^2 + ( - 2) * R2 + (1), (1) * R1 + (1) * R2 + ( - 1), ( - 1) * X2^2 + ( - 1) * Y2^2 + (1) * S2^2 + ( - 2) * S2 + (1), (1) * S1 + (1) * S2 + ( - 1), ( - 1) * Y1 * X2 + (1) * X1 * Y2, ( - 2) * Y2 * A + (1) * A^2 + ( - 2) * S2 + (1), ( - 2) * Y1 * A + (1) * A^2 + ( - 2) * R2 + (1), (4) * R2 * S2 * V + ( - 3) * R2 * V + ( - 3) * S2 * V + (2) * V + (1), ( - 4) * Y2 * R2 + (2) * A * R2 + (4) * Y1 * S2 + ( - 2) * A * S2 + ( - 2) * Y1 + (2) * Y2, (1) * X1 * A^2 + ( - 1) * X2 * A^2 + (2) * X2 * R2 + ( - 2) * X1 * S2 + (1) * X1 + ( - 1) * X2, ( - 1) * X1 * X2 * Y2 + ( - 1) * Y1 * Y2^2 + (1) * Y1 * S2^2 + ( - 2) * Y1 * S2 + (1) * Y1, ( - 16) * Y1 * S2^2 * V + (8) * A * S2^2 * V + (20) * Y1 * S2 * V + (4) * Y2 * S2 * V + ( - 12) * A * S2 * V + ( - 6) * Y1 * V + ( - 2) * Y2 * V + (4) * A * V + ( - 4) * Y2 + (2) * A, (4) * A^2 * R2^2 + ( - 4) * A^2 * S2^2 + ( - 8) * A^2 * R2 + (16) * Y1^2 * S2 + ( - 16) * Y1 * Y2 * S2 + (8) * A^2 * S2 + ( - 16) * R2^2 * S2 + (16) * R2 * S2^2 + ( - 12) * Y1^2 + (8) * Y1 * Y2 + (4) * Y2^2 + (8) * R2^2 + (8) * R2 * S2 + ( - 16) * S2^2 + ( - 8) * R2 + (8) * S2, ( - 8) * X1 * X2 * R2 + ( - 2) * A^2 * R2 + (8) * Y1^2 * S2 + (8) * X1 * X2 * S2 + ( - 8) * Y1 * Y2 * S2 + (2) * A^2 * S2 + ( - 8) * R2^2 * S2 + (8) * R2 * S2^2 + ( - 8) * Y1^2 + (4) * Y1 * Y2 + (4) * Y2^2 + (8) * R2^2 + (4) * R2 * S2 + ( - 12) * S2^2 + ( - 10) * R2 + (10) * S2, ( - 32) * Y1^2 * Y2 * S2 + (32) * Y1 * Y2^2 * S2 + (8) * A * R2^2 * S2 + (32) * Y1 * R2 * S2^2 + ( - 16) * A * R2 * S2^2 + ( - 32) * Y1 * S2^3 + (8) * A * S2^3 + (24) * Y1^2 * Y2 + ( - 16) * Y1 * Y2^2 + ( - 8) * Y2^3 + ( - 4) * A * R2^2 + ( - 48) * Y1 * R2 * S2 + (32) * Y1 * S2^2 + (16) * Y2 * S2^2 + (4) * A * S2^2 + (20) * Y1 * R2 + (6) * A * R2 + ( - 20) * Y2 * S2 + ( - 6) * A * S2 + ( - 6) * Y1 + (6) * Y2, (16) * X1 * Y1 * Y2 * S2 + ( - 16) * X1 * Y2^2 * S2 + ( - 8) * X2 * R2^2 * S2 + ( - 8) * X1 * R2 * S2^2 + (8) * X2 * R2 * S2^2 + (8) * X1 * S2^3 + ( - 12) * X1 * Y1 * Y2 + (8) * X1 * Y2^2 + (4) * X2 * Y2^2 + (4) * X2 * R2^2 + (16) * X1 * R2 * S2 + (8) * X2 * R2 * S2 + ( - 16) * X1 * S2^2 + ( - 12) * X2 * S2^2 + ( - 8) * X1 * R2 + ( - 8) * X2 * R2 + (8) * X1 * S2 + (8) * X2 * S2, (8) * A * R2^3 + ( - 32) * Y1^3 * S2 + (32) * Y1 * Y2^2 * S2 + (32) * Y1 * R2^2 * S2 + ( - 8) * A * R2^2 * S2 + ( - 8) * A * R2 * S2^2 + ( - 32) * Y1 * S2^3 + (8) * A * S2^3 + (24) * Y1^3 + (8) * Y1^2 * Y2 + ( - 24) * Y1 * Y2^2 + ( - 8) * Y2^3 + ( - 16) * Y1 * R2^2 + ( - 16) * A * R2^2 + ( - 80) * Y1 * R2 * S2 + (24) * A * R2 * S2 + (80) * Y1 * S2^2 + (16) * Y2 * S2^2 + ( - 8) * A * S2^2 + (48) * Y1 * R2 + (8) * A * R2 + ( - 24) * Y1 * S2 + ( - 24) * Y2 * S2 + ( - 8) * A * S2 + ( - 8) * Y1 + (8) * Y2, ( - 8) * X2 * R2^3 + (16) * X1 * Y1^2 * S2 + ( - 16) * X1 * Y2^2 * S2 + ( - 8) * X1 * R2^2 * S2 + (8) * X2 * R2 * S2^2 + (8) * X1 * S2^3 + ( - 12) * X1 * Y1^2 + ( - 4) * X1 * Y1 * Y2 + (12) * X1 * Y2^2 + (4) * X2 * Y2^2 + (4) * X1 * R2^2 + (20) * X2 * R2^2 + (24) * X1 * R2 * S2 + ( - 8) * X2 * R2 * S2 + ( - 28) * X1 * S2^2 + ( - 12) * X2 * S2^2 + ( - 16) * X1 * R2 + ( - 16) * X2 * R2 + (16) * X1 * S2 + (16) * X2 * S2, (4) * X2 * A * R2^2 + (4) * X1 * A * R2 * S2 + ( - 4) * X2 * A * R2 * S2 + ( - 4) * X1 * A * S2^2 + ( - 2) * X1 * A * R2 + ( - 6) * X2 * A * R2 + (8) * X1 * Y1 * S2 + ( - 8) * X1 * Y2 * S2 + (2) * X1 * A * S2 + (6) * X2 * A * S2 + ( - 6) * X1 * Y1 + (4) * X1 * Y2 + (2) * X2 * Y2, (16) * X1 * Y2 * S2^2 * V + ( - 8) * X2 * A * S2^2 * V + ( - 20) * X1 * Y2 * S2 * V + ( - 4) * X2 * Y2 * S2 * V + (12) * X2 * A * S2 * V + (6) * X1 * Y2 * V + (2) * X2 * Y2 * V + ( - 4) * X2 * A * V + (4) * X2 * Y2 + ( - 2) * X2 * A, ( - 512) * X1 * X2 * S2^2 * V + ( - 128) * A^2 * S2^2 * V + (256) * Y1^2 * S2 * V + (768) * X1 * X2 * S2 * V + ( - 128) * Y1 * Y2 * S2 * V + ( - 128) * Y2^2 * S2 * V + (192) * A^2 * S2 * V + (128) * S2^3 * V + ( - 192) * Y1^2 * V + ( - 256) * X1 * X2 * V + (64) * Y1 * Y2 * V + (128) * Y2^2 * V + ( - 64) * A^2 * V + ( - 288) * S2^2 * V + ( - 128) * X1 * X2 + (128) * Y1 * Y2 + ( - 128) * Y2^2 + ( - 32) * A^2 + ( - 128) * R2 * S2 + (128) * S2^2 + ( - 24) * R2 * V + (232) * S2 * V + (192) * R2 + ( - 160) * S2 + ( - 48) * V + ( - 24), (64) * Y1^4 * S2 + ( - 64) * Y1 * Y2^3 * S2 + ( - 64) * Y1^2 * R2^2 * S2 + (64) * Y1 * Y2 * S2^3 + ( - 48) * Y1^4 + ( - 16) * Y1^3 * Y2 + (48) * Y1 * Y2^3 + (16) * Y2^4 + (32) * Y1^2 * R2^2 + (16) * R2^4 + (192) * Y1^2 * R2 * S2 + (8) * A^2 * R2 * S2 + ( - 48) * R2^3 * S2 + ( - 64) * Y1^2 * S2^2 + ( - 128) * Y1 * Y2 * S2^2 + ( - 32) * Y2^2 * S2^2 + ( - 8) * A^2 * S2^2 + (64) * R2^2 * S2^2 + ( - 48) * R2 * S2^3 + (16) * S2^4 + ( - 120) * Y1^2 * R2 + ( - 10) * A^2 * R2 + ( - 24) * R2^3 + ( - 24) * Y1^2 * S2 + (104) * Y1 * Y2 * S2 + (40) * Y2^2 * S2 + (10) * A^2 * S2 + (40) * R2^2 * S2 + ( - 24) * R2 * S2^2 + (8) * S2^3 + (40) * Y1^2 + ( - 28) * Y1 * Y2 + ( - 12) * Y2^2 + (24) * R2^2 + ( - 20) * R2 * S2 + ( - 4) * S2^2 + ( - 10) * R2 + (10) * S2, ( - 2048) * A * S2^4 * V + ( - 2048) * Y2 * S2^3 * V + (7168) * A * S2^3 * V + (128) * A * R2^2 * V + (5120) * Y2 * S2^2 * V + ( - 9088) * A * S2^2 * V + (2048) * Y1 * Y2^2 + ( - 2048) * Y2^3 + ( - 512) * A * R2 * S2 + ( - 2048) * Y1 * S2^2 + (2048) * Y2 * S2^2 + (128) * Y1 * R2 * V + ( - 256) * A * R2 * V + ( - 256) * Y1 * S2 * V + ( - 3968) * Y2 * S2 * V + (4992) * A * S2 * V + (640) * A * R2 + (3584) * Y1 * S2 + ( - 4096) * Y2 * S2 + (384) * A * S2 + (64) * Y1 * V + (960) * Y2 * V + ( - 896) * A * V + ( - 1408) * Y1 + (1920) * Y2 + ( - 448) * A, (2048) * X1 * S2^4 * V + ( - 6656) * X1 * S2^3 * V + (512) * X2 * S2^3 * V + ( - 128) * X2 * R2^2 * V + (7808) * X1 * S2^2 * V + ( - 1280) * X2 * S2^2 * V + ( - 1024) * X1 * Y2^2 + (1024) * X2 * Y2^2 + (512) * X2 * R2 * S2 + (512) * X1 * S2^2 + ( - 512) * X2 * S2^2 + ( - 32) * X1 * R2 * V + (224) * X2 * R2 * V + ( - 3872) * X1 * S2 * V + (992) * X2 * S2 * V + ( - 640) * X2 * R2 + ( - 896) * X1 * S2 + (768) * X2 * S2 + (704) * X1 * V + ( - 320) * X2 * V + (352) * X1 + ( - 160) * X2, (1024) * Y1^3 * S2 * V + ( - 1024) * Y1 * Y2^2 * S2 * V + ( - 768) * Y1^3 * V + ( - 256) * Y1^2 * Y2 * V + (768) * Y1 * Y2^2 * V + (256) * Y2^3 * V + ( - 512) * Y2 * S2^2 * V + ( - 256) * A * S2^2 * V + (1024) * Y1^2 * Y2 + ( - 1024) * Y1 * Y2^2 + ( - 256) * A * R2^2 + ( - 1024) * Y1 * R2 * S2 + (512) * A * R2 * S2 + (1024) * Y1 * S2^2 + ( - 256) * A * S2^2 + ( - 128) * Y1 * R2 * V + ( - 64) * A * R2 * V + (128) * Y1 * S2 * V + (768) * Y2 * S2 * V + (448) * A * S2 * V + (1024) * Y1 * R2 + (256) * A * R2 + ( - 512) * Y1 * S2 + ( - 512) * Y2 * S2 + ( - 256) * A * S2 + ( - 256) * Y2 * V + ( - 128) * A * V + ( - 384) * Y1 + (256) * Y2 + ( - 64) * A, ( - 512) * X1 * Y1^2 * S2 * V + (512) * X1 * Y2^2 * S2 * V + (384) * X1 * Y1^2 * V + (128) * X1 * Y1 * Y2 * V + ( - 384) * X1 * Y2^2 * V + ( - 128) * X2 * Y2^2 * V + (256) * X1 * S2^2 * V + (256) * X2 * S2^2 * V + ( - 512) * X1 * Y1 * Y2 + (512) * X1 * Y2^2 + (256) * X2 * R2^2 + (256) * X1 * R2 * S2 + ( - 256) * X2 * R2 * S2 + ( - 256) * X1 * S2^2 + (64) * X1 * R2 * V + (64) * X2 * R2 * V + ( - 448) * X1 * S2 * V + ( - 448) * X2 * S2 * V + ( - 384) * X1 * R2 + ( - 384) * X2 * R2 + (384) * X1 * S2 + (384) * X2 * S2 + (128) * X1 * V + (128) * X2 * V + (64) * X1 + (64) * X2, (256) * A^2 * S2^3 * V + ( - 704) * A^2 * S2^2 * V + ( - 16) * A^2 * R2 * V + (256) * Y1^2 * S2 * V + ( - 256) * Y1 * Y2 * S2 * V + (624) * A^2 * S2 * V + ( - 256) * S2^3 * V + (64) * A^2 * R2 + ( - 192) * Y1^2 * V + (128) * Y1 * Y2 * V + (64) * Y2^2 * V + ( - 160) * A^2 * V + (576) * S2^2 * V + (256) * Y1 * Y2 + ( - 256) * Y2^2 + ( - 80) * A^2 + ( - 256) * R2 * S2 + (256) * S2^2 + ( - 16) * R2 * V + ( - 400) * S2 * V + (256) * R2 + ( - 320) * S2 + (96) * V + (48), (64) * X1 * A * S2^3 * V + ( - 192) * X1 * A * S2^2 * V + (16) * X2 * A * S2^2 * V + ( - 4) * X2 * A * R2 * V + (32) * X1 * Y1 * S2 * V + ( - 32) * X1 * Y2 * S2 * V + (176) * X1 * A * S2 * V + ( - 20) * X2 * A * S2 * V + (16) * X2 * A * R2 + (16) * X1 * A * S2 + ( - 16) * X2 * A * S2 + ( - 24) * X1 * Y1 * V + (16) * X1 * Y2 * V + (8) * X2 * Y2 * V + ( - 48) * X1 * A * V + (8) * X2 * A * V + (32) * X1 * Y2 + ( - 32) * X2 * Y2 + ( - 24) * X1 * A + (4) * X2 * A, ( - 512) * Y2^2 * S2^2 * V + (128) * A^2 * S2^2 * V + (512) * S2^4 * V + (2048) * Y1^2 * Y2^2 + ( - 2048) * Y1 * Y2^3 + ( - 2048) * Y1^2 * S2^2 + (2048) * Y1 * Y2 * S2^2 + (128) * Y1^2 * R2 * V + ( - 32) * A^2 * R2 * V + ( - 128) * R2^3 * V + ( - 256) * Y1^2 * S2 * V + (896) * Y2^2 * S2 * V + ( - 160) * A^2 * S2 * V + ( - 1920) * S2^3 * V + (256) * A^2 * R2 + (3584) * Y1^2 * S2 + ( - 3072) * Y1 * Y2 * S2 + ( - 512) * Y2^2 * S2 + ( - 256) * A^2 * S2 + (512) * R2^2 * S2 + ( - 1024) * R2 * S2^2 + (512) * S2^3 + (64) * Y1^2 * V + ( - 320) * Y2^2 * V + (64) * A^2 * V + (384) * R2^2 * V + (2496) * S2^2 * V + ( - 1408) * Y1^2 + (1408) * Y1 * Y2 + ( - 128) * Y2^2 + (32) * A^2 + ( - 640) * R2^2 + (640) * R2 * S2 + (128) * S2^2 + ( - 336) * R2 * V + ( - 1360) * S2 * V + (320) * R2 + ( - 640) * S2 + (352) * V + (176), ( - 2048) * Y1^2 * R2^2 * V + (2048) * R2^4 * V + (512) * A^2 * S2^2 * V + ( - 8192) * Y1^3 * Y2 + (8192) * Y1^2 * Y2^2 + (8192) * Y1^2 * R2 * S2 + ( - 2048) * A^2 * R2 * S2 + ( - 8192) * Y1^2 * S2^2 + (2048) * A^2 * S2^2 + (3584) * Y1^2 * R2 * V + (128) * A^2 * R2 * V + ( - 7680) * R2^3 * V + ( - 2048) * Y1^2 * S2 * V + (1024) * Y1 * Y2 * S2 * V + (512) * Y2^2 * S2 * V + ( - 896) * A^2 * S2 * V + ( - 512) * S2^3 * V + ( - 6144) * Y1^2 * R2 + (512) * A^2 * R2 + ( - 2048) * R2^3 + (6144) * Y1 * Y2 * S2 + ( - 512) * A^2 * S2 + (8192) * R2^2 * S2 + ( - 6144) * R2 * S2^2 + (256) * Y1^2 * V + ( - 512) * Y1 * Y2 * V + ( - 768) * Y2^2 * V + (256) * A^2 * V + (10496) * R2^2 * V + (1536) * S2^2 * V + (1536) * Y1^2 + ( - 1536) * Y1 * Y2 + ( - 512) * Y2^2 + (128) * A^2 + (2560) * R2^2 + ( - 6656) * R2 * S2 + (4608) * S2^2 + ( - 6080) * R2 * V + ( - 1472) * S2 * V + ( - 1536) * R2 + (256) * S2 + (1664) * V + (832), ( - 262144) * Y1^3 * Y2^2 + (262144) * Y1^2 * Y2^3 + (262144) * Y1^3 * S2^2 + ( - 262144) * Y1 * Y2^2 * S2^2 + ( - 65536) * A * R2^2 * S2^2 + ( - 262144) * Y1 * R2 * S2^3 + (131072) * A * R2 * S2^3 + (262144) * Y1 * S2^4 + ( - 65536) * A * S2^4 + ( - 16384) * Y1^3 * R2 * V + (2048) * A^3 * R2 * V + (16384) * Y1 * R2^3 * V + (16384) * Y2^3 * S2 * V + ( - 2048) * A^3 * S2 * V + ( - 16384) * Y2 * S2^3 * V + ( - 16384) * A^3 * R2 + ( - 458752) * Y1^3 * S2 + (393216) * Y1 * Y2^2 * S2 + (65536) * Y2^3 * S2 + (16384) * A^3 * S2 + ( - 65536) * Y1 * R2^2 * S2 + (81920) * A * R2^2 * S2 + (720896) * Y1 * R2 * S2^2 + ( - 98304) * A * R2 * S2^2 + ( - 524288) * Y1 * S2^3 + ( - 131072) * Y2 * S2^3 + (16384) * A * S2^3 + (16384) * Y1^3 * V + (8192) * Y1^2 * Y2 * V + ( - 8192) * Y1 * Y2^2 * V + ( - 16384) * Y2^3 * V + ( - 49152) * Y1 * R2^2 * V + ( - 6144) * A * R2^2 * V + (49152) * Y2 * S2^2 * V + (6144) * A * S2^2 * V + (180224) * Y1^3 + ( - 65536) * Y1^2 * Y2 + ( - 81920) * Y1 * Y2^2 + ( - 32768) * Y2^3 + (81920) * Y1 * R2^2 + (16384) * A * R2^2 + ( - 507904) * Y1 * R2 * S2 + ( - 90112) * A * R2 * S2 + (180224) * Y1 * S2^2 + (245760) * Y2 * S2^2 + (73728) * A * S2^2 + (45056) * Y1 * R2 * V + (10240) * A * R2 * V + ( - 45056) * Y2 * S2 * V + ( - 10240) * A * S2 * V + (49152) * Y1 * R2 + (6144) * A * R2 + (90112) * Y1 * S2 + ( - 139264) * Y2 * S2 + ( - 6144) * A * S2 + ( - 12288) * Y1 * V + (12288) * Y2 * V + ( - 24576) * Y1 + (24576) * Y2, (131072) * X1 * Y1^2 * Y2^2 + ( - 131072) * X1 * Y1 * Y2^3 + ( - 131072) * X1 * Y1^2 * S2^2 + (131072) * X1 * Y2^2 * S2^2 + (65536) * X2 * R2^2 * S2^2 + (65536) * X1 * R2 * S2^3 + ( - 65536) * X2 * R2 * S2^3 + ( - 65536) * X1 * S2^4 + (8192) * X1 * Y1^2 * R2 * V + ( - 2048) * X2 * A^2 * R2 * V + ( - 8192) * X1 * R2^3 * V + ( - 8192) * X2 * Y2^2 * S2 * V + (2048) * X2 * A^2 * S2 * V + (8192) * X2 * S2^3 * V + (16384) * X2 * A^2 * R2 + (229376) * X1 * Y1^2 * S2 + ( - 196608) * X1 * Y2^2 * S2 + ( - 32768) * X2 * Y2^2 * S2 + ( - 16384) * X2 * A^2 * S2 + (32768) * X1 * R2^2 * S2 + ( - 81920) * X2 * R2^2 * S2 + ( - 245760) * X1 * R2 * S2^2 + ( - 16384) * X2 * R2 * S2^2 + (212992) * X1 * S2^3 + (98304) * X2 * S2^3 + ( - 8192) * X1 * Y1^2 * V + ( - 4096) * X1 * Y1 * Y2 * V + (4096) * X1 * Y2^2 * V + (8192) * X2 * Y2^2 * V + (24576) * X1 * R2^2 * V + (6144) * X2 * R2^2 * V + ( - 2048) * X1 * S2^2 * V + ( - 24576) * X2 * S2^2 * V + ( - 90112) * X1 * Y1^2 + (32768) * X1 * Y1 * Y2 + (40960) * X1 * Y2^2 + (16384) * X2 * Y2^2 + ( - 40960) * X1 * R2^2 + ( - 16384) * X2 * R2^2 + (229376) * X1 * R2 * S2 + (147456) * X2 * R2 * S2 + ( - 188416) * X1 * S2^2 + ( - 131072) * X2 * S2^2 + ( - 24064) * X1 * R2 * V + ( - 9728) * X2 * R2 * V + (4608) * X1 * S2 * V + (23040) * X2 * S2 * V + ( - 32768) * X1 * R2 + ( - 14336) * X2 * R2 + (30720) * X1 * S2 + (16384) * X2 * S2 + (5120) * X1 * V + ( - 3072) * X2 * V + (2560) * X1 + ( - 1536) * X2, (512) * X2 * A * S2^3 * V + ( - 128) * X1 * A * R2^2 * V + (512) * X2 * Y2 * S2^2 * V + ( - 128) * X1 * A * S2^2 * V + ( - 1408) * X2 * A * S2^2 * V + ( - 2048) * X1 * Y1 * Y2^2 + (2048) * X1 * Y2^3 + (512) * X1 * A * R2 * S2 + ( - 512) * X2 * A * R2 * S2 + (2048) * X1 * Y1 * S2^2 + ( - 2048) * X1 * Y2 * S2^2 + ( - 512) * X1 * A * S2^2 + (512) * X2 * A * S2^2 + ( - 128) * X1 * Y1 * R2 * V + (256) * X1 * A * R2 * V + (32) * X2 * A * R2 * V + (256) * X1 * Y1 * S2 * V + ( - 896) * X2 * Y2 * S2 * V + (128) * X1 * A * S2 * V + (1184) * X2 * A * S2 * V + ( - 640) * X1 * A * R2 + (256) * X2 * A * R2 + ( - 3584) * X1 * Y1 * S2 + (3072) * X1 * Y2 * S2 + (512) * X2 * Y2 * S2 + (640) * X1 * A * S2 + ( - 128) * X2 * A * S2 + ( - 64) * X1 * Y1 * V + (320) * X2 * Y2 * V + ( - 128) * X1 * A * V + ( - 320) * X2 * A * V + (1408) * X1 * Y1 + ( - 1152) * X1 * Y2 + ( - 128) * X2 * Y2 + ( - 64) * X1 * A + ( - 160) * X2 * A ]
Index: /trunk/examples/klee2.lisp
===================================================================
--- /trunk/examples/klee2.lisp	(revision 8)
+++ /trunk/examples/klee2.lisp	(revision 8)
@@ -0,0 +1,13 @@
+(setf *colored-poly-debug* t)
+(setf *grobner-debug* t)
+(string-grobner-system 
+ "[r1+s1-u*r1*s1]"
+ '()
+ '(A X1 Y1 X2 Y2 R1 R2 S1 S2)
+ :cover
+ '(("[-Y1^2-X1^2+2*A*X1+R1^2-A^2,-Y1^2-X1^2-2*A*X1+R2^2-A^2,R2+R1-2,-Y2^2-X2^2+2*A*X2+S1^2-A^2,-Y2^2-X2^2-2*A*X2+S2^2-A^2,S2+S1-2,X1*Y2-A*Y2-X2*Y1+A*Y1,-A^2*U+U-2]"
+    "[A,X1-X2]"
+    ))
+ :main-order #'grevlex>
+ :parameter-order #'grevlex>
+)
Index: /trunk/examples/klee2.macsyma
===================================================================
--- /trunk/examples/klee2.macsyma	(revision 8)
+++ /trunk/examples/klee2.macsyma	(revision 8)
@@ -0,0 +1,27 @@
+if get('geometry2, 'version)=false then load(geometry2);
+X:[x1,y1]; Y:[x2,y2]; O1:[-p,0]; O2:[p,0];
+/* Semi-axes are 1 and sqrt(1-p^2) */
+f(W) := (1-p^2)*w[1]^2+w[2]^2-(1-p^2); /* W is on the ellipse */
+vars: []; params: [p,u,x1,y1,x2,y2,r1,r2,s1,s2];
+cover: [
+	[
+		f(X), f(Y),
+		distance(X,O1,r1),
+		distance(Y,O1,s1),
+		collinear(X,Y,O1),
+		u*(1-p^2)-2
+	],
+	[
+		p,
+		(x1-x2)*(y1-y2)
+	]
+];
+concl: (r1+s1-u*r1*s1)*(r1+s1+u*r1*s1)*(r1-s1-u*r1*s1)*(r1-s1+u*r1*s1);
+
+
+
+eqns:[concl];
+
+eqns:expand(eqns);
+cover:expand(cover);
+stringout("klee2.out",eqns,vars,params,cover);
Index: /trunk/examples/klee2.out
===================================================================
--- /trunk/examples/klee2.out	(revision 8)
+++ /trunk/examples/klee2.out	(revision 8)
@@ -0,0 +1,5 @@
+
+[R1^4*S1^4*U^4-2*R1^2*S1^4*U^2-2*R1^4*S1^2*U^2+S1^4-2*R1^2*S1^2+R1^4];
+[];
+[P,U,X1,Y1,X2,Y2,R1,R2,S1,S2];
+[[Y1^2-P^2*X1^2+X1^2+P^2-1,Y2^2-P^2*X2^2+X2^2+P^2-1,-Y1^2-X1^2-2*P*X1+R1^2-P^2,-Y2^2-X2^2-2*P*X2+S1^2-P^2,X1*Y2+P*Y2-X2*Y1-P*Y1,-P^2*U+U-2],[P,X2*Y2-X1*Y2-X2*Y1+X1*Y1]];
Index: /trunk/examples/klee3.lisp
===================================================================
--- /trunk/examples/klee3.lisp	(revision 8)
+++ /trunk/examples/klee3.lisp	(revision 8)
@@ -0,0 +1,13 @@
+(setf *colored-poly-debug* t)
+(setf *grobner-debug* t)
+(string-grobner-system 
+ "[r1+s1-u*r1*s1]"
+ '()
+ '(X1 Y1 X2 Y2 R1 R2 S1 S2 A U)
+ :cover
+ '(("[-Y1^2-X1^2+2*A*X1+R1^2-A^2,-Y1^2-X1^2-2*A*X1+R2^2-A^2,R2+R1-2,-Y2^2-X2^2+2*A*X2+S1^2-A^2,-Y2^2-X2^2-2*A*X2+S2^2-A^2,S2+S1-2,X1*Y2-A*Y2-X2*Y1+A*Y1,-A^2*U+U-2]"
+    "[A,X1-X2]"
+    ))
+ :main-order #'grevlex>
+ :parameter-order #'grevlex>
+)
Index: /trunk/examples/klee3.macsyma
===================================================================
--- /trunk/examples/klee3.macsyma	(revision 8)
+++ /trunk/examples/klee3.macsyma	(revision 8)
@@ -0,0 +1,23 @@
+if get('geometry2, 'version)=false then load(geometry2);
+X:[x1,y1]; Y:[x2,y2]; O1:[a,0]; O2:[-a,0];
+vars:[]; params:[a,x1,y1,x2,y2,r1,r2,s1,s2];
+
+eqns:[r1+s1-u*r1*s1];
+
+cover:[
+[
+	distance(X,O1,r1),
+	distance(X,O2,r2),
+	r1+r2-2,
+	distance(Y,O1,s1),
+	distance(Y,O2,s2),
+	s1+s2-2,
+	collinear(X,Y,O1),
+	u*(1-a^2)-2
+],
+[a,x1-x2]
+];
+
+eqns:expand(eqns);
+cover:expand(cover);
+stringout("klee3.out",eqns,vars,params,cover);
Index: /trunk/examples/klee3.out
===================================================================
--- /trunk/examples/klee3.out	(revision 8)
+++ /trunk/examples/klee3.out	(revision 8)
@@ -0,0 +1,5 @@
+
+[-R1*S1*U+S1+R1];
+[];
+[A,X1,Y1,X2,Y2,R1,R2,S1,S2];
+[[-Y1^2-X1^2+2*A*X1+R1^2-A^2,-Y1^2-X1^2-2*A*X1+R2^2-A^2,R2+R1-2,-Y2^2-X2^2+2*A*X2+S1^2-A^2,-Y2^2-X2^2-2*A*X2+S2^2-A^2,S2+S1-2,X1*Y2-A*Y2-X2*Y1+A*Y1,-A^2*U+U-2],[A,X1-X2]];
Index: /trunk/examples/klee3.result
===================================================================
--- /trunk/examples/klee3.result	(revision 8)
+++ /trunk/examples/klee3.result	(revision 8)
@@ -0,0 +1,7 @@
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [ 2 * Y1 * Y2 * S2 + 2 * R2 * S2^2 + 2 * S2 * A^2 - 3 * Y1 * Y2 - Y2^2 - 8 * R2 * S2 - 4 * S2^2 - 4 * A^2 + 8 * R2 + 14 * S2 - 12, 2 * Y1^2 * S2 - 2 * R2^2 * S2 + 2 * S2 * A^2 - 3 * Y1^2 - Y1 * Y2 + 4 * R2^2 + 4 * R2 * S2 - 4 * A^2 - 8 * R2 - 2 * S2 + 4, 2 * X2 * R2 - R2 * A - S2 * A - X1 - 3 * X2 + 4 * A, Y1 * A^2 - Y2 * A^2 - 2 * Y1 * S2 + 3 * Y1 + Y2, X2^2 + Y2^2 - S2^2 + A^2 + 2 * S2 - 2, X1^2 + Y1^2 - R2^2 + A^2 + 2 * R2 - 2, R1 + R2 - 2, S1 + S2 - 2, Y1 * X2 - X1 * Y2 - Y1 * A + Y2 * A, A^2 * U - U + 2, X2 * A - S2 + 1, X1 * A - R2 + 1, Y2^2 * A - S2^2 * A + A^3 + X2 * S2 + 2 * S2 * A - X2 - 2 * A, Y1^2 * A - R2^2 * A + A^3 + X1 * R2 + 2 * R2 * A - X1 - 2 * A, S2 * A * U - X2 * U - A * U + 2 * X2, R2 * A * U - X1 * U - A * U + 2 * X1, Y2^2 * U - 2 * Y2^2 + 2 * S2^2 - 2 * A^2 - 4 * S2 + 2, Y1^2 * U - 2 * Y1^2 + 2 * R2^2 - 2 * A^2 - 4 * R2 + 2, R2 * A^2 + S2 * A^2 - 2 * R2 * S2 - 4 * A^2 + 3 * R2 + 3 * S2 - 4, R2 * S2 * U - 2 * R2 * U - 2 * S2 * U + R2 + S2 + 4 * U - 4, 2 * X1 * S2 - R2 * A - S2 * A - 3 * X1 - X2 + 4 * A, Y2 * R2 + Y1 * S2 - 2 * Y1 - 2 * Y2, Y1 * S2 * U - 2 * Y1 * U + Y1 - Y2, X1 * Y2 * U - Y2 * A * U - 2 * X1 * Y2 - Y1 * A + Y2 * A, X1 * X2 + Y1 * Y2 + R2 * S2 + A^2 - 3 * R2 - 3 * S2 + 6, Y1 * Y2 * U - 2 * Y1 * Y2 - 2 * R2 * S2 - 2 * A^2 + 4 * R2 + 4 * S2 - 6, 2 * Y1 * Y2 * A + 2 * R2 * S2 * A + 2 * A^3 - 5 * R2 * A - 5 * S2 * A + X1 + X2 + 8 * A ]
+  Red list: [ A, X1 - X2 ]
+ Basis: [ ]
+Finished loading klee3.lisp
+T
Index: /trunk/examples/midpoints.lisp
===================================================================
--- /trunk/examples/midpoints.lisp	(revision 8)
+++ /trunk/examples/midpoints.lisp	(revision 8)
@@ -0,0 +1,11 @@
+
+;; This is supposed to prove that the 3 bisectors of a triangle
+;; intersect at a single point
+(string-grobner-system
+"[U1*Y-V1*X,-X2*Y+U2*Y+V2*X2-V2*X,X*Y3-U3*Y3-X3*Y+U3*Y+V3*X3-V3*X,-X3-X2+2*U1,2*V1-Y3,2*U2-X3,2*V2-Y3,2*U3-X2,2*V3]"
+'(x y u1 v1 u2 v2 u3 v3)
+'(x2 x3 y3)
+:main-order #'grlex>
+:parameter-order #'grlex>)
+
+
Index: /trunk/examples/midpoints.macsyma
===================================================================
--- /trunk/examples/midpoints.macsyma	(revision 8)
+++ /trunk/examples/midpoints.macsyma	(revision 8)
@@ -0,0 +1,25 @@
+if get('geometry,'version)=false then load(geometry);
+x1:0;
+y1:0;
+y2:0;
+
+/* Triangle */
+A:[x1,y1];
+B:[x2,y2];
+C:[x3,y3];
+M:[x,y];
+P:[u1,v1];
+Q:[u2,v2];
+R:[u3,v3];
+eqns:append([
+	collinear(M,A,P),
+	collinear(M,B,Q),
+	collinear(M,C,R)
+	],
+	append(
+		midpoint(P,B,C),
+		midpoint(Q,A,C),
+		midpoint(R,A,B)
+	)
+);
+
Index: /trunk/examples/ngeometry.macsyma
===================================================================
--- /trunk/examples/ngeometry.macsyma	(revision 8)
+++ /trunk/examples/ngeometry.macsyma	(revision 8)
@@ -0,0 +1,21 @@
+/* 
+	A declarative language for specifying geometric problems
+		and geometric theorem proving
+ */
+
+/* Conventions:
+   *    Points and angles are denoted with a symbol;
+   *	If A is a point then xA, yA denote its x and y coordinates;
+   *    If A is an angle then cA and sA denote ist cos and sin
+   *    If A and B are points than lA_B denotes the distance from A to B
+
+A specification of a geometric problem will look like this
+begin_hypotheses();
+parallel(A,B,C,D);
+parallel(A,C,B,D);
+angle(P,A,B,C);
+end_hypotheses();
+
+....
+*/
+
Index: /trunk/examples/pappus.lisp
===================================================================
--- /trunk/examples/pappus.lisp	(revision 8)
+++ /trunk/examples/pappus.lisp	(revision 8)
@@ -0,0 +1,15 @@
+(dribble "pappus.dribble")
+(setf *colored-poly-debug* t)
+(setf *grobner-debug* t)
+
+(string-grobner-system
+"[U2*V3-U1*V3-U3*V2+U1*V2+U3*V1-U2*V1]"
+'()
+'(u1 u2 v2 v1 u3 v3 X3 Z1 W1 Z2 W2 Z3 W3)
+:cover 
+'(("[U1*W2-V1*Z2,V1*Z1-U1*W1+W1-V1,-V3*Z3+U3*W3-W3+V3,-V3*Z2-W2*X3+V3*X3+U3*W2,V2*Z1+W1*X3-V2*X3-U2*W1,U2*W3-V2*Z3,-W2*Z3+W1*Z3+W3*Z2-W1*Z2-W3*Z1+W2*Z1]"
+"[]"))
+:parameter-order #'grevlex>
+:main-order #'grlex>
+)
+(dribble)
Index: /trunk/examples/pappus.macsyma
===================================================================
--- /trunk/examples/pappus.macsyma	(revision 8)
+++ /trunk/examples/pappus.macsyma	(revision 8)
@@ -0,0 +1,33 @@
+if get('geometry2, 'version)=false then load(geometry2);
+/* Specifications */
+x1:0;
+y1:0;
+x2:1;
+y2:0;
+y3:0;
+
+X:[x1,y1]; Y:[x2,y2]; Z:[x3,y3]; /* First line */
+P:[u1,v1]; Q:[u2,v2]; R:[u3,v3]; /* Second line */
+U:[z1,w1]; V:[z2,w2]; W:[z3,w3]; /* Intersection points */
+
+params:cons(s,listofvars(append(X,Y,Z,U,V,W)));
+vars:listofvars(append(P,Q,R));
+concl: collinear(P,Q,R);
+eqns:
+[
+	collinear(X,Y,Z),
+	collinear(X,P,V),
+	collinear(U,P,Y),
+	collinear(Y,R,W),
+	collinear(Z,R,V),
+	collinear(U,Q,Z),
+	collinear(X,Q,W),
+	collinear(U,V,W),
+	1-s*concl
+];
+
+cover: [[],[]];
+
+eqns:expand(eqns);
+cover:expand(cover);
+stringout("pappus.out",eqns,vars,params,cover);
Index: /trunk/examples/pappus.out
===================================================================
--- /trunk/examples/pappus.out	(revision 8)
+++ /trunk/examples/pappus.out	(revision 8)
@@ -0,0 +1,5 @@
+
+[0,U1*W2-V1*Z2,V1*Z1-U1*W1+W1-V1,-V3*Z3+U3*W3-W3+V3,-V3*Z2-W2*X3+V3*X3+U3*W2,V2*Z1+W1*X3-V2*X3-U2*W1,U2*W3-V2*Z3,-W2*Z3+W1*Z3+W3*Z2-W1*Z2-W3*Z1+W2*Z1,-S*U2*V3+S*U1*V3+S*U3*V2-S*U1*V2-S*U3*V1+S*U2*V1+1];
+[S,X3,Z1,W1,Z2,W2,Z3,W3];
+[U1,V1,U2,V2,U3,V3];
+[[],[]];
Index: /trunk/examples/pappus0.lisp
===================================================================
--- /trunk/examples/pappus0.lisp	(revision 8)
+++ /trunk/examples/pappus0.lisp	(revision 8)
@@ -0,0 +1,13 @@
+(dribble "pappus.dribble")
+(setf *colored-poly-debug* t)
+(setf *grobner-debug* nil)
+
+(string-grobner-system
+"[U1*W2-V1*Z2,V1*Z1-U1*W1+W1-V1,-V3*Z3+U3*W3-W3+V3,-V3*Z2-W2*X3+V3*X3+U3*W2,V2*Z1+W1*X3-V2*X3-U2*W1,U2*W3-V2*Z3,-W2*Z3+W1*Z3+W3*Z2-W1*Z2-W3*Z1+W2*Z1,-S*U2*V3+S*U1*V3+S*U3*V2-S*U1*V2-S*U3*V1+S*U2*V1+1]"
+'(S U1 V1 U2 V2 U3 V3)
+'(X3 Z1 W1 Z2 W2 Z3 W3)
+:cover '(("[]" "[]"))
+:main-order #'grevlex>
+:parameter-order #'grevlex>
+)
+(dribble)
Index: /trunk/examples/pappus2.lisp
===================================================================
--- /trunk/examples/pappus2.lisp	(revision 8)
+++ /trunk/examples/pappus2.lisp	(revision 8)
@@ -0,0 +1,13 @@
+(dribble "pappus2.dribble")
+(setf *colored-poly-debug* t)
+(setf *grobner-debug* nil)
+
+(string-grobner-system
+"[U1*W2-V1*Z2,V1*Z1-U1*W1+W1-V1,-V3*Z3+U3*W3-W3+V3,-V3*Z2-W2*X3+V3*X3+U3*W2,V2*Z1+W1*X3-V2*X3-U2*W1,U2*W3-V2*Z3,-W2*Z3+W1*Z3+W3*Z2-W1*Z2-W3*Z1+W2*Z1,-S*U2*V3+S*U1*V3+S*U3*V2-S*U1*V2-S*U3*V1+S*U2*V1+1]"
+'(S U1 V1 U2 V2 U3 V3 Z3 W3)
+'(X3 Z1 W1 Z2 W2)
+:cover '(("[]" "[]"))
+:main-order #'grevlex>
+:parameter-order #'grevlex>
+)
+(dribble)
Index: /trunk/examples/pappus2.macsyma
===================================================================
--- /trunk/examples/pappus2.macsyma	(revision 8)
+++ /trunk/examples/pappus2.macsyma	(revision 8)
@@ -0,0 +1,33 @@
+if get('geometry2, 'version)=false then load(geometry2);
+/* Specifications */
+x1:0;
+y1:0;
+x2:1;
+y2:0;
+y3:0;
+
+X:[x1,y1]; Y:[x2,y2]; Z:[x3,y3]; /* First line */
+P:[u1,v1]; Q:[u2,v2]; R:[u3,v3]; /* Second line */
+U:[z1,w1]; V:[z2,w2]; W:[z3,w3]; /* Intersection points */
+
+params:listofvars(append(X,Y,U,V));
+vars:cons(s,listofvars(append(P,Q,R,Z,W)));
+concl: collinear(P,Q,R);
+eqns:
+[
+	/* collinear(X,Y,Z), */
+	collinear(X,P,V),
+	collinear(U,P,Y),
+	collinear(Y,R,W),
+	collinear(Z,R,V),
+	collinear(U,Q,Z),
+	collinear(X,Q,W),
+	collinear(U,V,W),
+	1-s*concl
+];
+
+cover: [[],[]];
+
+eqns:expand(eqns);
+cover:expand(cover);
+stringout("pappus2.out",eqns,vars,params,cover);
Index: /trunk/examples/pappus2.out
===================================================================
--- /trunk/examples/pappus2.out	(revision 8)
+++ /trunk/examples/pappus2.out	(revision 8)
@@ -0,0 +1,5 @@
+
+[U1*W2-V1*Z2,V1*Z1-U1*W1+W1-V1,-V3*Z3+U3*W3-W3+V3,-V3*Z2-W2*X3+V3*X3+U3*W2,V2*Z1+W1*X3-V2*X3-U2*W1,U2*W3-V2*Z3,-W2*Z3+W1*Z3+W3*Z2-W1*Z2-W3*Z1+W2*Z1,-S*U2*V3+S*U1*V3+S*U3*V2-S*U1*V2-S*U3*V1+S*U2*V1+1];
+[U1,V1,U2,V2,U3,V3,X3,Z3,W3];
+[S,Z1,W1,Z2,W2];
+[[],[]];
Index: /trunk/examples/pappus3.lisp
===================================================================
--- /trunk/examples/pappus3.lisp	(revision 8)
+++ /trunk/examples/pappus3.lisp	(revision 8)
@@ -0,0 +1,13 @@
+(dribble "pappus3.dribble")
+(setf *colored-poly-debug* t)
+(setf *grobner-debug* nil)
+
+(string-grobner-system
+"[U1*W2-V1*Z2,V1*Z1-U1*W1+W1-V1,-V3*Z3+U3*W3-W3+V3,-V3*Z2-W2*X3+V3*X3+U3*W2,V2*Z1+W1*X3-V2*X3-U2*W1,U2*W3-V2*Z3,W1-K*Z1-L,W2-K*Z2-L,W3-K*Z3-L,-S*U2*V3+S*U1*V3+S*U3*V2-S*U1*V2-S*U3*V1+S*U2*V1+1]"
+'(S U1 V1 U2 V2 U3 V3 z1 w1 z2 w2 Z3 W3)
+'(x3 k l)
+:cover '(("[]" "[]"))
+:main-order #'grevlex>
+:parameter-order #'grevlex>
+)
+(dribble)
Index: /trunk/examples/pappus4.lisp
===================================================================
--- /trunk/examples/pappus4.lisp	(revision 8)
+++ /trunk/examples/pappus4.lisp	(revision 8)
@@ -0,0 +1,14 @@
+(dribble "pappus4.dribble")
+(setf *colored-poly-debug* t)
+(setf *grobner-debug* t)
+
+(string-grobner-system
+"[-C01*C12*V+C00*C12*V+C02*C11*V-C00*C11*V-C02*C10*V+C01*C10*V+1,L20,B21*L20+B11*L10+B01*L00,C20*L20+C10*L10+C00*L00,L21,B22*L21+B12*L11+B02*L01,C21*L21+C11*L11+C01*L01,L22+L02,B20*L22+B10*L12+B00*L02,C20*L22+C10*L12+C00*L02,L23+L03,B22*L23+B12*L13+B02*L03,C22*L23+C12*L13+C02*L03,L24+A02*L04,B20*L24+B10*L14+B00*L04,C21*L24+C11*L14+C01*L04,L25+A02*L05,B21*L25+B11*L15+B01*L05,C22*L25+C12*L15+C02*L05,0,0,0,B20*L27+B10*L17+B00*L07,B21*L27+B11*L17+B01*L07,B22*L27+B12*L17+B02*L07]"
+'(L00 L10 L20 L01 L11 L21 L02 L12 L22 L03 L13 L23 L04 L14 L24 L05 L15 L25 L06 L16 L26 L07 L17 L27 C00 C10 C20 C01 C11 C21 C02 C12 C22 A02 A12 A22 B02 B12 B22 V)
+'(A00 A10 A20 B00 B10 B20 A01 A11 A21 B01 B11 B21)
+:cover
+'(("[]" "[]"))
+:main-order #'grevlex>
+:parameter-order #'grevlex>
+)
+(dribble)
Index: /trunk/examples/pappus4.macsyma
===================================================================
--- /trunk/examples/pappus4.macsyma	(revision 8)
+++ /trunk/examples/pappus4.macsyma	(revision 8)
@@ -0,0 +1,55 @@
+if get('geometry2,'version)=false then load(geometry2);
+/* Pappus theorem;
+9 points and 9 lines
+Points: a0, a1, a2, b0, b1, b2, c0, c1, c2
+line		contains points
+l0		a0 b1 c0
+l1		a0 b2 c1
+l2		a1 b0 c0
+l3		a1 b2 c2
+l4		a2 b0 c1
+l5		a2 b1 c2
+l6		a0 a1 a2
+l7		b0 b1 b2
+l8		c0 c1 c2
+*/
+/* Specs */
+a00:a10:0; a20:1;
+a01:1; a11:0; a21:1;
+a12:0; a22:1; /* a02 # 0 */
+l06:0; l16:1; l26:0;
+
+for i:0 thru 2 do (
+	a[i]:[concat('a0,i),concat('a1,i),concat('a2,i)],
+	b[i]:[concat('b0,i),concat('b1,i),concat('b2,i)],		
+	c[i]:[concat('c0,i),concat('c1,i),concat('c2,i)]
+);		
+
+for i:0 thru 8 do 
+	l[i]:[concat('l0,i),concat('l1,i),concat('l2,i)];
+
+rel(l,a,b,c):=[l.a,l.b,l.c];
+
+eqns:append(
+[1-v*collinear(c[0], c[1], c[2])],
+rel(l[0],a[0], b[1], c[0]),
+rel(l[1],a[0], b[2], c[1]),
+rel(l[2],a[1], b[0], c[0]),
+rel(l[3],a[1], b[2], c[2]),
+rel(l[4],a[2], b[0], c[1]),
+rel(l[5],a[2], b[1], c[2]),
+rel(l[6],a[0], a[1], a[2]),
+rel(l[7],b[0], b[1], b[2]));
+
+
+vars:append(makelist(l[j],j,0,7),
+	makelist([c[i]],i,0,2),[a[2],b[2]]);
+params:makelist([a[i],b[i]],i,0,1);
+vars:''vars;
+params:''params;
+vars:listofvars(vars);
+params:listofvars(params);
+cover:expand([[[],[]]]);
+eqns:expand(''eqns);
+cover:expand(''cover);
+stringout("pappus4.out",eqns,vars,params,cover);
Index: /trunk/examples/pappus4.out
===================================================================
--- /trunk/examples/pappus4.out	(revision 8)
+++ /trunk/examples/pappus4.out	(revision 8)
@@ -0,0 +1,5 @@
+
+[-C01*C12*V+C00*C12*V+C02*C11*V-C00*C11*V-C02*C10*V+C01*C10*V+1,L20,B21*L20+B11*L10+B01*L00,C20*L20+C10*L10+C00*L00,L21,B22*L21+B12*L11+B02*L01,C21*L21+C11*L11+C01*L01,L22+L02,B20*L22+B10*L12+B00*L02,C20*L22+C10*L12+C00*L02,L23+L03,B22*L23+B12*L13+B02*L03,C22*L23+C12*L13+C02*L03,L24+A02*L04,B20*L24+B10*L14+B00*L04,C21*L24+C11*L14+C01*L04,L25+A02*L05,B21*L25+B11*L15+B01*L05,C22*L25+C12*L15+C02*L05,0,0,0,B20*L27+B10*L17+B00*L07,B21*L27+B11*L17+B01*L07,B22*L27+B12*L17+B02*L07];
+[L00,L10,L20,L01,L11,L21,L02,L12,L22,L03,L13,L23,L04,L14,L24,L05,L15,L25,L07,L17,L27,C00,C10,C20,C01,C11,C21,C02,C12,C22,A02,B02,B12,B22];
+[B00,B10,B20,B01,B11,B21];
+[[[],[]]];
Index: /trunk/examples/parallelogram
===================================================================
--- /trunk/examples/parallelogram	(revision 8)
+++ /trunk/examples/parallelogram	(revision 8)
@@ -0,0 +1,2 @@
+
+"(string-grobner-system \"[2*X5-X3-X1,2*Y5-Y3-Y1,2*X6-X4-X2,2*Y6-Y4-Y2,U1*X6-U1*X5+1,U2*Y6-U2*Y5+1]\" '( X1  Y1  X2  Y2  X3  Y3  X4  Y4  X5  Y5  X6  Y6  X7  Y7  X8  Y8  X9  Y9  U1  U2 ) '( X1  Y1  X2  Y2  X3  Y3 ))";
Index: /trunk/examples/parallelogram.lisp
===================================================================
--- /trunk/examples/parallelogram.lisp	(revision 8)
+++ /trunk/examples/parallelogram.lisp	(revision 8)
@@ -0,0 +1,5 @@
+
+(string-grobner-system 
+"[2*X5-X3-X1,2*Y5-Y3-Y1,2*X6-X4-X2,2*Y6-Y4-Y2,U1*X6-U1*X5+1,U2*Y6-U2*Y5+1]"
+'(X1 Y1 X2 Y2 X3 Y3 X4 Y4 X5 Y5 X6 Y6 X7 Y7 X8 Y8 X9 Y9 U1 U2)
+'(X1 Y1 X2 Y2 X3 Y3))
Index: /trunk/examples/parallelogram.macsyma
===================================================================
--- /trunk/examples/parallelogram.macsyma	(revision 8)
+++ /trunk/examples/parallelogram.macsyma	(revision 8)
@@ -0,0 +1,19 @@
+if get('geometry,'version)=false then load(geometry);
+ginit();
+
+gpoints(A,B,C,D,M1,M2,P,Q,R); /* Declare points */
+garbitrary(A,B,C); /* Declare arbitrary points */
+
+/* Geometrical hypotheses */
+parallel(A,B,C,D);
+parallel(A,C,B,D);
+midpoint(M1,A,C);
+midpoint(M2,B,D);
+ghypot();
+
+/* Geometrical conclusions */
+identical(M1,M2);
+gconcl();
+
+/* Generate ideal */
+gideal();
Index: /trunk/examples/parallelogram.macsyma-batch
===================================================================
--- /trunk/examples/parallelogram.macsyma-batch	(revision 8)
+++ /trunk/examples/parallelogram.macsyma-batch	(revision 8)
@@ -0,0 +1,76 @@
+(D1)    /dept3/rychlik/LISP/CGB2/EXAMPLES/parallelogram.macsyma-batch
+(C2) BATCH(PARALLELOGRAM);
+
+
+(C3) if get('geometry,'version)=false then load(geometry);
+Batching the file /dept3/rychlik/lisp/cgb2/examples/geometry.macsyma
+Batchload done.
+(D3) 	      /dept3/rychlik/lisp/cgb2/examples/geometry.macsyma
+
+
+(C4) ginit();
+(D4) 				      1
+
+
+
+(C5) gpoints(A,B,C,D,M1,M2,P,Q,R);
+(D5) [[X1, Y1], [X1, Y1, X2, Y2], [X1, Y1, X2, Y2, X3, Y3], 
+
+[X1, Y1, X2, Y2, X3, Y3, X4, Y4], [X1, Y1, X2, Y2, X3, Y3, X4, Y4, X5, Y5], 
+
+[X1, Y1, X2, Y2, X3, Y3, X4, Y4, X5, Y5, X6, Y6], 
+
+[X1, Y1, X2, Y2, X3, Y3, X4, Y4, X5, Y5, X6, Y6, X7, Y7], 
+
+[X1, Y1, X2, Y2, X3, Y3, X4, Y4, X5, Y5, X6, Y6, X7, Y7, X8, Y8], 
+
+[X1, Y1, X2, Y2, X3, Y3, X4, Y4, X5, Y5, X6, Y6, X7, Y7, X8, Y8, X9, Y9]]
+ 
+(C6) /* Declare points */
+garbitrary(A,B,C);
+(D6) 	    [[X1, Y1], [X1, Y1, X2, Y2], [X1, Y1, X2, Y2, X3, Y3]]
+ 
+(C7) /* Declare arbitrary points */
+
+/* Geometrical hypotheses */
+parallel(A,B,C,D);
+/usr/export/home/macsyma/share/determ.o being loaded.
+(D7) 				      []
+
+
+(C8) parallel(A,C,B,D);
+(D8) 				      []
+
+
+(C9) midpoint(M1,A,C);
+(D9) 		       [2 X5 - X3 - X1, 2 Y5 - Y3 - Y1]
+
+
+(C10) midpoint(M2,B,D);
+(D10)  [2 X5 - X3 - X1, 2 Y5 - Y3 - Y1, 2 X6 - X4 - X2, 2 Y6 - Y4 - Y2]
+
+
+(C11) ghypot();
+(D11) 				      []
+
+
+
+(C12) /* Geometrical conclusions */
+identical(M1,M2);
+(D12) 			      [X5 - X6, Y5 - Y6]
+
+
+(C13) gconcl();
+(D13) 				      []
+
+
+
+(C14) /* Generate ideal */
+gideal();
+(D14) [2 X5 - X3 - X1, 2 Y5 - Y3 - Y1, 2 X6 - X4 - X2, 2 Y6 - Y4 - Y2, 
+
+					   1 - U1 (X5 - X6), 1 - U2 (Y5 - Y6)]
+
+(D15) 				     DONE
+(C16) CLOSEFILE();
+
Index: /trunk/examples/pilgrim1.lisp
===================================================================
--- /trunk/examples/pilgrim1.lisp	(revision 8)
+++ /trunk/examples/pilgrim1.lisp	(revision 8)
@@ -0,0 +1,237 @@
+#| 
+From pilgrim@polygon.math.cornell.edu  Tue Oct 21 12:07:20 1997
+Return-Path: pilgrim@polygon.math.cornell.edu
+Date: Tue, 21 Oct 1997 15:06:59 -0400 (EDT)
+From: "Kevin M. Pilgrim - Math H.C. Wang Visiting Prof." <pilgrim@math.cornell.edu>
+X-Sender: pilgrim@polygon
+To: rychlik@math.arizona.edu
+Subject: A test for grobner bases algorithms
+Mime-Version: 1.0
+Content-Type: TEXT/PLAIN; charset=US-ASCII
+
+Hi, 
+
+Below are some sample equations I looked at this summer.
+
+Here's the setup:
+
+A general degree two rational map is (generically) conjugate in at 
+most six ways to a map of the form 
+
+	f_ab = z(az^2 + bz + a) = 1/ (a (z+1/z) + b), a nonzero.
+
+as you can easily check using algebra.  The critical points are at 
++/- 1 and infinity maps to zero, which is fixed.  
+Such a map has three fixed points whose multipliers are, say, m1, m2, m3.
+Let s1=m1+m2+m3 and s2=m1*m2 + m1*m3 + m2*m3 be the first two 
+elementary symmetric functions of these multipliers.   From work of 
+Milnor (generalized by Silverman) one knows that s1 and s2 give canonical
+coordinates for the moduli space of degree two rational maps, i.e. the space
+of rational maps of degree two modulo moebius conjugation is biholomorphic
+to C^2 with these canonical coordinates s1 and s2.
+
+One can easily check that 
+
+	a*s1-4*a^2-1+b^2+2*a = 0				
+and								(E1)
+	a^2*s2-4*a^4+4*a^3+2*a+b^2+b^2*a^2-5*a^2 = 0.		
+
+Now, let s denote the ith elementary symmetric function of the multipliers 
+of the points of period n.  From work of Silverman, 
+
+	s is a polynomial with integer coefficients in s1 and s2.
+
+PROBLEM:  Calculate s in terms of i and n.
+
+Even for n=3 and i=1 this is not easy to do using "brute force" 
+symbolic computation.  But somehow there ought to be a way to do 
+this using this approach.  
+
+Case n=3 and i=1:  
+-----------------
+
+A degree two rational map has two three-cycles, generically.  
+Let s = s(3,1) denote the sum of the multipliers of these two three-cycles.
+We want to find s in terms of s1 and s2.
+
+Let 
+	z00 -> z10 -> z20 -> z00 
+and								(E2)
+	z01 -> z11 -> z21 -> z01
+
+denote the points in the two three-cycles (the arrows denote application
+of f_ab).  Then 
+
+	s = f'(z00)*f'(z10)*f'(z20)+f'(z01)*f'(z11)*f'(z21) 	(E3)
+
+and s is the sum of these two quantities and depends only on s1 and s2.
+
+The conditions in (E2) and (E3) can be translated into polynomial
+equations.  Adding in the equations (E1) gives us a system of poly.
+equations.  Here are the details, in a maple-readable form:
+
+variables:=[z21, z11, z01, z20, z10, z00, a, b, s1, s2, s];
+equations:=
+[a*s1-4*a^2-1+b^2+2*a, 
+a^2*s2-4*a^4+4*a^3+2*a+b^2+b^2*a^2-5*a^2, 
+z00-z10*(a*z00^2+b*z00+a), z10-z20*(a*z10^2+b*z10+a), 
+z20-z00*(a*z20^2+b*z20+a), z01-z11*(a*z01^2+b*z01+a), 
+z11-z21*(a*z11^2+b*z11+a), z21-z01*(a*z21^2+b*z21+a), 
+s-a^3*(1-z00^2)*(1-z10^2)*(1-z20^2)-a^3*(1-z01^2)*(1-z11^2)*(1-z21^2)];
+
+There are, however, some degeneracy constraints:  we may not allow the
+coefficient a to be zero.  Also, there will be solutions to the equations
+where e.g. z00=z01, z10=z11, z20=z21 which we must discard.  So we have
+the following quantities which must be nonzero: 
+
+(D1) 	a 
+ 
+(D2)	z00-z10, z00-z20, z10-z20,
+	z01-z11, z01-z21, z11-z21,
+
+	(where points in the same cycle collide)
+and
+
+(D3) 	z00-z01, z00-z11, z00-z21,
+	z10-z01, z10-z11, z10-z21,
+	z20-z01, z20-z11, z20-z21
+	
+	(where points in different cycles collide).
+
+But in fact one can reduce this set of 1 + 6 + 9 = 16 
+degeneracy conditions somewhat using the fact that the 
+zij's are period of the prime period 3 to:
+
+degs:=[a, z00-z10, z01-z11, z00-z01, z00-z11, z00-z21];
+
+which is a great improvement.  
+
+Thus our problem is:
+
+	Solve "equations" in "variables" subject to the 
+	constraint that "degs" are nonzero, and eliminate
+	all the variables save s,s1,s2.
+
+An alternative approach, which you mentioned, is to first 
+omit consideration of the degeneracy equations.  
+
+I'm curious to see how you would approach this problem
+using what you called parameters.  I'd be grateful for
+any input you could give.  
+
+If this one looks too easy, I can send you the data for 
+higher periods.  For e.g. n=4 there are 3 four-cycles and the 
+degeneracies which can occur are more complicated.  
+
+Another useful thing to have would be the equations in a,b, and 
+the zij's defining the locus where the values of the zij's represent 
+precisely the locations of the points in the two three-cycles
+(i.e. calculate a basis for the ideal corresponding to the variety 
+defined by (E2) subject to the constraint that the degeneracies (D1)-(D3)
+are nonzero.  Even this looks hard.
+
+If you're interested I can send some samples of the equations which 
+arise when trying to find postcritically finite maps.  
+
+I enjoyed your talk in Atlanta, and thank you for organizing a great
+session and allowing me the opportunity to speak.
+
+	Kevin M. Pilgrim 	
+	Dept. of Mathematics
+	B-35 White Hall
+	Cornell University
+	Ithaca, NY 14853-7901
+	(607) 255-5380 w
+	(607) 256-1634 h, before 9PM
+	pilgrim@math.cornell.edu
+
+|#
+
+
+(setf main-variables '(s s1 s2))
+(setf parameters '(a b z00 z10 z20 z01 z11 z21))
+(setf variables (append main-variables parameters))
+      
+(setf equations 
+  "[
+z00-z10*(a*z00^2+b*z00+a),
+z10-z20*(a*z10^2+b*z10+a), 
+z20-z00*(a*z20^2+b*z20+a),
+z01-z11*(a*z01^2+b*z01+a), 
+z11-z21*(a*z11^2+b*z11+a),
+z21-z01*(a*z21^2+b*z21+a),
+a*s1-4*a^2-1+b^2+2*a,
+a^2*s2-4*a^4+4*a^3+2*a+b^2+b^2*a^2-5*a^2,
+s-a^3*(1-z00^2)*(1-z10^2)*(1-z20^2)-a^3*(1-z01^2)*(1-z11^2)*(1-z21^2)
+]"
+)
+
+(setf parametric-equations "[
+a*s1-4*a^2-1+b^2+2*a,
+a^2*s2-4*a^4+4*a^3+2*a+b^2+b^2*a^2-5*a^2,
+s-a^3*(1-z00^2)*(1-z10^2)*(1-z20^2)-a^3*(1-z01^2)*(1-z11^2)*(1-z21^2)
+]")
+
+(setf green-list "[
+z00-z10*(a*z00^2+b*z00+a),
+z10-z20*(a*z10^2+b*z10+a), 
+z20-z00*(a*z20^2+b*z20+a),
+z01-z11*(a*z01^2+b*z01+a), 
+z11-z21*(a*z11^2+b*z11+a),
+z21-z01*(a*z21^2+b*z21+a)
+]")
+
+(setf red-list "[a,
+z00-z10, z00-z20, z10-z20,
+z01-z11, z01-z21, z11-z21,
+z00-z01, z00-z11, z00-z21,
+z10-z01, z10-z11, z10-z21,
+z20-z01, z20-z11, z20-z21,
+z00-z10,
+z01-z11,
+z00-z01,
+z00-z11,
+z00-z21]")
+
+(setf order #'grevlex>)
+
+
+#|
+(string-grobner
+ equations
+ variables
+ :order order)
+|#
+
+#|
+(string-ideal-polysaturation-1
+ equations 
+ red-list
+ variables
+ :order order
+) 
+|#
+
+#|
+(string-grobner-system 
+ parametric-equations
+ main-variables
+ parameters
+ :cover (list (list green-list red-list))
+ :main-order #'grevlex>
+ :parameter-order #'grevlex>)
+|#
+
+#|
+(string-grobner 
+ green-list
+ parameters
+ :order #'grevlex>)
+|#
+
+(string-ideal-polysaturation-1
+ green-list
+ red-list
+ parameters
+ :order order
+)
Index: /trunk/examples/pilgrim2.lisp
===================================================================
--- /trunk/examples/pilgrim2.lisp	(revision 8)
+++ /trunk/examples/pilgrim2.lisp	(revision 8)
@@ -0,0 +1,175 @@
+#| 
+From pilgrim@polygon.math.cornell.edu  Tue Oct 21 12:07:20 1997
+Return-Path: pilgrim@polygon.math.cornell.edu
+Date: Tue, 21 Oct 1997 15:06:59 -0400 (EDT)
+From: "Kevin M. Pilgrim - Math H.C. Wang Visiting Prof." <pilgrim@math.cornell.edu>
+X-Sender: pilgrim@polygon
+To: rychlik@math.arizona.edu
+Subject: A test for grobner bases algorithms
+Mime-Version: 1.0
+Content-Type: TEXT/PLAIN; charset=US-ASCII
+
+Hi, 
+
+Below are some sample equations I looked at this summer.
+
+Here's the setup:
+
+A general degree two rational map is (generically) conjugate in at 
+most six ways to a map of the form 
+
+	f_ab = z(az^2 + bz + a) = 1/ (a (z+1/z) + b), a nonzero.
+
+as you can easily check using algebra.  The critical points are at 
++/- 1 and infinity maps to zero, which is fixed.  
+Such a map has three fixed points whose multipliers are, say, m1, m2, m3.
+Let s1=m1+m2+m3 and s2=m1*m2 + m1*m3 + m2*m3 be the first two 
+elementary symmetric functions of these multipliers.   From work of 
+Milnor (generalized by Silverman) one knows that s1 and s2 give canonical
+coordinates for the moduli space of degree two rational maps, i.e. the space
+of rational maps of degree two modulo moebius conjugation is biholomorphic
+to C^2 with these canonical coordinates s1 and s2.
+
+One can easily check that 
+
+	a*s1-4*a^2-1+b^2+2*a = 0				
+and								(E1)
+	a^2*s2-4*a^4+4*a^3+2*a+b^2+b^2*a^2-5*a^2 = 0.		
+
+Now, let s denote the ith elementary symmetric function of the multipliers 
+of the points of period n.  From work of Silverman, 
+
+	s is a polynomial with integer coefficients in s1 and s2.
+
+PROBLEM:  Calculate s in terms of i and n.
+
+Even for n=3 and i=1 this is not easy to do using "brute force" 
+symbolic computation.  But somehow there ought to be a way to do 
+this using this approach.  
+
+Case n=3 and i=1:  
+-----------------
+
+A degree two rational map has two three-cycles, generically.  
+Let s = s(3,1) denote the sum of the multipliers of these two three-cycles.
+We want to find s in terms of s1 and s2.
+
+Let 
+	z00 -> z10 -> z20 -> z00 
+and								(E2)
+	z01 -> z11 -> z21 -> z01
+
+denote the points in the two three-cycles (the arrows denote application
+of f_ab).  Then 
+
+	s = f'(z00)*f'(z10)*f'(z20)+f'(z01)*f'(z11)*f'(z21) 	(E3)
+
+and s is the sum of these two quantities and depends only on s1 and s2.
+
+The conditions in (E2) and (E3) can be translated into polynomial
+equations.  Adding in the equations (E1) gives us a system of poly.
+equations.  Here are the details, in a maple-readable form:
+
+variables:=[z21, z11, z01, z20, z10, z00, a, b, s1, s2, s];
+equations:=
+[a*s1-4*a^2-1+b^2+2*a, 
+a^2*s2-4*a^4+4*a^3+2*a+b^2+b^2*a^2-5*a^2, 
+z00-z10*(a*z00^2+b*z00+a), z10-z20*(a*z10^2+b*z10+a), 
+z20-z00*(a*z20^2+b*z20+a), z01-z11*(a*z01^2+b*z01+a), 
+z11-z21*(a*z11^2+b*z11+a), z21-z01*(a*z21^2+b*z21+a), 
+s-a^3*(1-z00^2)*(1-z10^2)*(1-z20^2)-a^3*(1-z01^2)*(1-z11^2)*(1-z21^2)];
+
+There are, however, some degeneracy constraints:  we may not allow the
+coefficient a to be zero.  Also, there will be solutions to the equations
+where e.g. z00=z01, z10=z11, z20=z21 which we must discard.  So we have
+the following quantities which must be nonzero: 
+
+(D1) 	a 
+ 
+(D2)	z00-z10, z00-z20, z10-z20,
+	z01-z11, z01-z21, z11-z21,
+
+	(where points in the same cycle collide)
+and
+
+(D3) 	z00-z01, z00-z11, z00-z21,
+	z10-z01, z10-z11, z10-z21,
+	z20-z01, z20-z11, z20-z21
+	
+	(where points in different cycles collide).
+
+But in fact one can reduce this set of 1 + 6 + 9 = 16 
+degeneracy conditions somewhat using the fact that the 
+zij's are period of the prime period 3 to:
+
+degs:=[a, z00-z10, z01-z11, z00-z01, z00-z11, z00-z21];
+
+which is a great improvement.  
+
+Thus our problem is:
+
+	Solve "equations" in "variables" subject to the 
+	constraint that "degs" are nonzero, and eliminate
+	all the variables save s,s1,s2.
+
+An alternative approach, which you mentioned, is to first 
+omit consideration of the degeneracy equations.  
+
+I'm curious to see how you would approach this problem
+using what you called parameters.  I'd be grateful for
+any input you could give.  
+
+If this one looks too easy, I can send you the data for 
+higher periods.  For e.g. n=4 there are 3 four-cycles and the 
+degeneracies which can occur are more complicated.  
+
+Another useful thing to have would be the equations in a,b, and 
+the zij's defining the locus where the values of the zij's represent 
+precisely the locations of the points in the two three-cycles
+(i.e. calculate a basis for the ideal corresponding to the variety 
+defined by (E2) subject to the constraint that the degeneracies (D1)-(D3)
+are nonzero.  Even this looks hard.
+
+If you're interested I can send some samples of the equations which 
+arise when trying to find postcritically finite maps.  
+
+I enjoyed your talk in Atlanta, and thank you for organizing a great
+session and allowing me the opportunity to speak.
+
+	Kevin M. Pilgrim 	
+	Dept. of Mathematics
+	B-35 White Hall
+	Cornell University
+	Ithaca, NY 14853-7901
+	(607) 255-5380 w
+	(607) 256-1634 h, before 9PM
+	pilgrim@math.cornell.edu
+
+|#
+
+
+(setf variables '(s1 s2 s)) 
+(setf parameters '(a b z21 z11 z01 z20 z10 z00)) 
+(setf equations 
+"[ a*s1-4*a^2-1+b^2+2*a,  a^2*s2-4*a^4+4*a^3+2*a+b^2+b^2*a^2-5*a^2, s-2*a^3+a^3*z20^2+a^3*z10^2-a^3*z10^2*z20^2+a^3*z00^2-a^3*z00^2*z20^2-a^3*z00^2*z10^2+a^3*z00^2*z10^2*z20^2+a^3*z21^2+a^3*z11^2-a^3*z11^2*z21^2+a^3*z01^2-a^3*z01^2*z21^2-a^3*z01^2*z11^2+a^3*z01^2*z11^2*z21^2]"
+)
+
+(setf red-list "[a, z00-z10, z01-z11, z00-z01, z00-z11, z00-z21]")
+(setf green-list "[z00-z10*a*z00^2-z10*b*z00-z10*a, z10-z20*a*z10^2-z20*b*z10-z20*a, z20-z00*a*z20^2-z00*b*z20-z00*a, z01-z11*a*z01^2-z11*b*z01-z11*a, z11-z21*a*z11^2-z21*b*z11-z21*a, z21-z01*a*z21^2-z01*b*z21-z01*a]")
+
+(setf order #'lex>)
+
+#|
+(setf eqns (string-grobner equations variables :order order))
+|#
+
+(string-grobner-system
+ equations 
+ variables
+ parameters
+ :cover (list (list green-list red-list))
+ :main-order #'lex>
+ :parameter-order #'lex>
+) 
+
+	
Index: /trunk/examples/pilgrim3.lisp
===================================================================
--- /trunk/examples/pilgrim3.lisp	(revision 8)
+++ /trunk/examples/pilgrim3.lisp	(revision 8)
@@ -0,0 +1,208 @@
+#| 
+From pilgrim@polygon.math.cornell.edu  Tue Oct 21 12:07:20 1997
+Return-Path: pilgrim@polygon.math.cornell.edu
+Date: Tue, 21 Oct 1997 15:06:59 -0400 (EDT)
+From: "Kevin M. Pilgrim - Math H.C. Wang Visiting Prof." <pilgrim@math.cornell.edu>
+X-Sender: pilgrim@polygon
+To: rychlik@math.arizona.edu
+Subject: A test for grobner bases algorithms
+Mime-Version: 1.0
+Content-Type: TEXT/PLAIN; charset=US-ASCII
+
+Hi, 
+
+Below are some sample equations I looked at this summer.
+
+Here's the setup:
+
+A general degree two rational map is (generically) conjugate in at 
+most six ways to a map of the form 
+
+	f_ab = z(az^2 + bz + a) = 1/ (a (z+1/z) + b), a nonzero.
+
+as you can easily check using algebra.  The critical points are at 
++/- 1 and infinity maps to zero, which is fixed.  
+Such a map has three fixed points whose multipliers are, say, m1, m2, m3.
+Let s1=m1+m2+m3 and s2=m1*m2 + m1*m3 + m2*m3 be the first two 
+elementary symmetric functions of these multipliers.   From work of 
+Milnor (generalized by Silverman) one knows that s1 and s2 give canonical
+coordinates for the moduli space of degree two rational maps, i.e. the space
+of rational maps of degree two modulo moebius conjugation is biholomorphic
+to C^2 with these canonical coordinates s1 and s2.
+
+One can easily check that 
+
+	a*s1-4*a^2-1+b^2+2*a = 0				
+and								(E1)
+	a^2*s2-4*a^4+4*a^3+2*a+b^2+b^2*a^2-5*a^2 = 0.		
+
+Now, let s denote the ith elementary symmetric function of the multipliers 
+of the points of period n.  From work of Silverman, 
+
+	s is a polynomial with integer coefficients in s1 and s2.
+
+PROBLEM:  Calculate s in terms of i and n.
+
+Even for n=3 and i=1 this is not easy to do using "brute force" 
+symbolic computation.  But somehow there ought to be a way to do 
+this using this approach.  
+
+Case n=3 and i=1:  
+-----------------
+
+A degree two rational map has two three-cycles, generically.  
+Let s = s(3,1) denote the sum of the multipliers of these two three-cycles.
+We want to find s in terms of s1 and s2.
+
+Let 
+	z00 -> z10 -> z20 -> z00 
+and								(E2)
+	z01 -> z11 -> z21 -> z01
+
+denote the points in the two three-cycles (the arrows denote application
+of f_ab).  Then 
+
+	s = f'(z00)*f'(z10)*f'(z20)+f'(z01)*f'(z11)*f'(z21) 	(E3)
+
+and s is the sum of these two quantities and depends only on s1 and s2.
+
+The conditions in (E2) and (E3) can be translated into polynomial
+equations.  Adding in the equations (E1) gives us a system of poly.
+equations.  Here are the details, in a maple-readable form:
+
+variables:=[z21, z11, z01, z20, z10, z00, a, b, s1, s2, s];
+equations:=
+[a*s1-4*a^2-1+b^2+2*a, 
+a^2*s2-4*a^4+4*a^3+2*a+b^2+b^2*a^2-5*a^2, 
+z00-z10*(a*z00^2+b*z00+a), z10-z20*(a*z10^2+b*z10+a), 
+z20-z00*(a*z20^2+b*z20+a), z01-z11*(a*z01^2+b*z01+a), 
+z11-z21*(a*z11^2+b*z11+a), z21-z01*(a*z21^2+b*z21+a), 
+s-a^3*(1-z00^2)*(1-z10^2)*(1-z20^2)-a^3*(1-z01^2)*(1-z11^2)*(1-z21^2)];
+
+There are, however, some degeneracy constraints:  we may not allow the
+coefficient a to be zero.  Also, there will be solutions to the equations
+where e.g. z00=z01, z10=z11, z20=z21 which we must discard.  So we have
+the following quantities which must be nonzero: 
+
+(D1) 	a 
+ 
+(D2)	z00-z10, z00-z20, z10-z20,
+	z01-z11, z01-z21, z11-z21,
+
+	(where points in the same cycle collide)
+and
+
+(D3) 	z00-z01, z00-z11, z00-z21,
+	z10-z01, z10-z11, z10-z21,
+	z20-z01, z20-z11, z20-z21
+	
+	(where points in different cycles collide).
+
+But in fact one can reduce this set of 1 + 6 + 9 = 16 
+degeneracy conditions somewhat using the fact that the 
+zij's are period of the prime period 3 to:
+
+degs:=[a, z00-z10, z01-z11, z00-z01, z00-z11, z00-z21];
+
+which is a great improvement.  
+
+Thus our problem is:
+
+	Solve "equations" in "variables" subject to the 
+	constraint that "degs" are nonzero, and eliminate
+	all the variables save s,s1,s2.
+
+An alternative approach, which you mentioned, is to first 
+omit consideration of the degeneracy equations.  
+
+I'm curious to see how you would approach this problem
+using what you called parameters.  I'd be grateful for
+any input you could give.  
+
+If this one looks too easy, I can send you the data for 
+higher periods.  For e.g. n=4 there are 3 four-cycles and the 
+degeneracies which can occur are more complicated.  
+
+Another useful thing to have would be the equations in a,b, and 
+the zij's defining the locus where the values of the zij's represent 
+precisely the locations of the points in the two three-cycles
+(i.e. calculate a basis for the ideal corresponding to the variety 
+defined by (E2) subject to the constraint that the degeneracies (D1)-(D3)
+are nonzero.  Even this looks hard.
+
+If you're interested I can send some samples of the equations which 
+arise when trying to find postcritically finite maps.  
+
+I enjoyed your talk in Atlanta, and thank you for organizing a great
+session and allowing me the opportunity to speak.
+
+	Kevin M. Pilgrim 	
+	Dept. of Mathematics
+	B-35 White Hall
+	Cornell University
+	Ithaca, NY 14853-7901
+	(607) 255-5380 w
+	(607) 256-1634 h, before 9PM
+	pilgrim@math.cornell.edu
+
+|#
+
+
+(setf variables '(s1 s2 s)) 
+(setf parameters '(w00 w10 w20 w01 w11 w21 r00 r10 r20 r01 r11 r21 z21 z11  z01 z20 z10 z00 a b)) 
+
+(setf equations
+"[ a*s1-4*a^2-1+b^2+2*a,
+ a^2*s2-4*a^4+4*a^3+2*a+b^2+b^2*a^2-5*a^2,
+ s-a^3*r00*r10*r20-a^3*r01*r11*r21
+]"
+)
+
+(setf green-list "[
+ a*z00^2+b*z00+a-w00,
+ a*z10^2+b*z10+a-w10,
+ a*z20^2+b*z20+a-w20, 
+ a*z01^2+b*z01+a-w01,
+ a*z11^2+b*z11+a-w11,
+ a*z21^2+b*z21+a-w21,
+ z00-z10*w00,
+ z10-z20*w10, 
+ z20-z00*w20,
+ z01-z11*w01, 
+ z11-z21*w11,
+ z21-z01*w21, 
+ 1-z00^2-r00,
+ 1-z10^2-r10,
+ 1-z20^2-r20,
+ 1-z01^2-r01,
+ 1-z11^2-r11,
+ 1-z21^2-r21
+]")
+
+(setf red-list "[a
+ z00-z10
+ z01-z11
+ z00-z01
+ z00-z11
+ z00-z21]")
+
+(setf order #'lex>)
+
+#|
+(string-grobner green-list parameters :order order)
+|#
+
+#|
+(setf eqns (string-grobner equations variables :order order))
+|#
+
+
+#|
+(string-ideal-polysaturation-1
+ equations
+ red-list
+ (append parameters variables)
+ :order order
+) 
+|#
+	
Index: /trunk/examples/prover-alt.lisp
===================================================================
--- /trunk/examples/prover-alt.lisp	(revision 8)
+++ /trunk/examples/prover-alt.lisp	(revision 8)
@@ -0,0 +1,16 @@
+;; $Id: prover-alt.lisp,v 1.4 1998/01/19 09:18:53 marek Exp $
+
+(prove-theorem
+ ((perpendicular C P A B)
+  (perpendicular A Q B C)
+  (perpendicular B R A C)
+  (collinear A P B)
+  (collinear B Q C)
+  (collinear A R C)
+  (collinear A H Q)
+  (collinear B H R))
+ ((identical-points A B)
+  (identical-points A C)
+  (identical-points B C)
+  (collinear C H P)))
+  
Index: /trunk/examples/prover-apollonius.lisp
===================================================================
--- /trunk/examples/prover-apollonius.lisp	(revision 8)
+++ /trunk/examples/prover-apollonius.lisp	(revision 8)
@@ -0,0 +1,12 @@
+;;
+;; Prove Apollonius circle theorem
+;;
+(prove-theorem
+ ((perpendicular A B A C)
+  (midpoint B C M)
+  (midpoint A M O)
+  (collinear B H C)
+  (perpendicular A H B C))
+ ((equidistant M O H O)
+  (identical-points B C)
+  ))
Index: /trunk/examples/prover-pappus.lisp
===================================================================
--- /trunk/examples/prover-pappus.lisp	(revision 8)
+++ /trunk/examples/prover-pappus.lisp	(revision 8)
@@ -0,0 +1,15 @@
+;;----------------------------------------------------------------
+;; Encoding of the Pappus theorem in the formalism
+;; implemented in the PROVER package.
+;;----------------------------------------------------------------
+(prove-theorem
+ ((collinear X Y Z)
+  (collinear X P V)
+  (collinear U P Y)
+  (collinear Y R W)
+  (collinear Z R V)
+  (collinear U Q Z)
+  (collinear X Q W)
+  (collinear U V W))
+ ((collinear P Q R))
+ :order #'grevlex>)
Index: /trunk/examples/robot.lisp
===================================================================
--- /trunk/examples/robot.lisp	(revision 8)
+++ /trunk/examples/robot.lisp	(revision 8)
@@ -0,0 +1,9 @@
+(time
+(STRING-GROBNER-SYSTEM
+"[a-l3*c1*c2+l3*s1*s2-l2*c1, b-l3*c1*s2-l3*c2*s1-l2*s1, c1^2+s1^2-1, c2^2+s2^2-1]"
+'(C2 S2 C1 S1) 
+'(A B L2 L3) 
+:COVER '(("[]" "[l2,l3]"))
+:main-order #'lex>
+:parameter-order #'lex>
+))
Index: /trunk/examples/robot2.lisp
===================================================================
--- /trunk/examples/robot2.lisp	(revision 8)
+++ /trunk/examples/robot2.lisp	(revision 8)
@@ -0,0 +1,11 @@
+;;For the robot with arms of length 1, determine the 
+;;dimensions of f^{-1}(c) for all c
+(time
+(STRING-GROBNER-SYSTEM
+"[a-l3*c1*c2+l3*s1*s2-l2*c1, b-l3*c1*s2-l3*c2*s1-l2*s1, c1^2+s1^2-1, c2^2+s2^2-1]"
+'(C2 S2 C1 S1) 
+'(A B L2 L3) 
+:COVER '(("[l2-1,l3-1]" "[]"))
+:main-order #'grevlex>
+:parameter-order #'lex>
+))
Index: /trunk/examples/robot2.output
===================================================================
--- /trunk/examples/robot2.output	(revision 8)
+++ /trunk/examples/robot2.output	(revision 8)
@@ -0,0 +1,32 @@
+Starts dribbling to robot2.output (1995/7/5, 14:40:15).
+NIL
+
+>
+(load "robot2.lisp")Loading robot2.lisp
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [ L2 - 1, L3 - 1 ]
+  Red list: [ A^2 + B^2, L2, A, L3 ]
+ Basis: [ ( - 2 * A) * S2 + ( - 2 * A^2 - 2 * B^2) * S1 + (A^2 * B + B^3), ( - 2) * C2 + (A^2 + B^2 - 2), (2 * A) * C1 + (2 * B) * S1 + ( - A^2 - B^2), (4 * A^2 + 4 * B^2) * S1^2 + ( - 4 * A^2 * B - 4 * B^3) * S1 + (A^4 + 2 * A^2 * B^2 - 4 * A^2 + B^4) ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [ L2 - 1, L3 - 1, A^2 + B^2 ]
+  Red list: [ A^4 + 2 * A^2 * B^2 - 2 * A^2 * L2^2 - 2 * A^2 * L3^2 + B^4 + 2 * B^2 * L2^2 - 2 * B^2 * L3^2 + L2^4 - 2 * L2^2 * L3^2 + L3^4, L2, A, L3 ]
+ Basis: [ (32 * B^4) ]
+------------------- CASE 3 -------------------
+Condition:
+  Green list: [ L2 - 1, L3 - 1, A ]
+  Red list: [ L3, B * L2 ]
+ Basis: [ (4 * B^2) * C1^2 + (B^4 - 4 * B^2), (2 * B) * S2 + ( - 2 * B^2) * C1, ( - 2) * C2 + (B^2 - 2), (2 * B) * S1 + ( - B^2) ]
+------------------- CASE 4 -------------------
+Condition:
+  Green list: [ L2 - 1, L3 - 1, A, B ]
+  Red list: [ L3 ]
+ Basis: [ (1) * C1^2 + (1) * S1^2 + ( - 1), (1) * S2, (1) * C2 + (1) ]
+real time : 49.333 secs
+run time  : 41.650 secs
+Finished loading robot2.lisp
+T
+
+>
+(dribble)
Index: /trunk/examples/shash2.lisp
===================================================================
--- /trunk/examples/shash2.lisp	(revision 8)
+++ /trunk/examples/shash2.lisp	(revision 8)
@@ -0,0 +1,25 @@
+(setf *grobner-debug* t)
+
+(setf vars '(e1 e2 e3 e4 h1 h2 h3 h4 x1 x2 x3 x4 y1 y2 y3 y4))
+
+(setf ord #'lex>)
+
+(string-ideal-polysaturation
+ "[x1^2+e1+e2*x1+e3*y1+e4*x1*y1,
+ y1^2+h1+h2*x1+h3*y1+h4*x1*y1,
+ x2^2+e1+e2*x2+e3*y2+e4*x2*y2,
+ y2^2+h1+h2*x2+h3*y2+h4*x2*y2,
+ x3^2+e1+e2*x3+e3*y3+e4*x3*y3,
+ y3^2+h1+h2*x3+h3*y3+h4*x3*y3,
+ x4^2+e1+e2*x4+e3*y4+e4*x4*y4,
+ y4^2+h1+h2*x4+h3*y4+h4*x4*y4]"
+ (list "[x1-x2,y1-y2]"
+       "[x1-x3,y1-y3]"
+       "[x1-x4,y1-y4]"
+       "[x2-x3,y2-y3]"
+       "[x2-x4,y2-y4]"
+       "[x3-x4,y3-y4]")
+ vars :order ord)
+  
+ 
+
Index: /trunk/examples/shash2.output
===================================================================
--- /trunk/examples/shash2.output	(revision 8)
+++ /trunk/examples/shash2.output	(revision 8)
@@ -0,0 +1,1 @@
+[ 2 * E1 + E3 * E4 * H4^2 * X4 + E3 * H4 * X4 + 2 * E3 * Y4 - 2 * E4^2 * H2 * X4 - E4^2 * H3 * H4 * X4 - E4^2 * H4 * X4 * Y1 - E4^2 * H4 * X4 * Y2 - E4^2 * H4 * X4 * Y3 - E4^2 * H4 * X4 * Y4 + 3 * E4 * H3 * X4 + E4 * H4 * X1 * X4 + E4 * H4 * X2 * X4 + E4 * H4 * X3 * X4 + E4 * H4 * X4^2 + E4 * X4 * Y1 + E4 * X4 * Y2 + E4 * X4 * Y3 + 3 * E4 * X4 * Y4 - X1 * X4 - X2 * X4 - X3 * X4 + X4^2, 2 * E2 - E3 * E4 * H4^2 - E3 * H4 + 2 * E4^2 * H2 + E4^2 * H3 * H4 + E4^2 * H4 * Y1 + E4^2 * H4 * Y2 + E4^2 * H4 * Y3 + E4^2 * H4 * Y4 - 3 * E4 * H3 - E4 * H4 * X1 - E4 * H4 * X2 - E4 * H4 * X3 - E4 * H4 * X4 - E4 * Y1 - E4 * Y2 - E4 * Y3 - E4 * Y4 + X1 + X2 + X3 + X4, E3 * E4 * H3 * H4^2 + 2 * E3 * E4 * H4^2 * Y4 - 2 * E3 * H2 + E3 * H3 * H4 + 2 * E3 * H4^2 * X4 - 2 * E4^2 * H2 * H3 - 4 * E4^2 * H2 * Y4 - E4^2 * H3^2 * H4 - E4^2 * H3 * H4 * Y1 - E4^2 * H3 * H4 * Y2 - E4^2 * H3 * H4 * Y3 - 3 * E4^2 * H3 * H4 * Y4 - 2 * E4^2 * H4 * Y1 * Y4 - 2 * E4^2 * H4 * Y2 * Y4 - 2 * E4^2 * H4 * Y3 * Y4 - 2 * E4^2 * H4 * Y4^2 - 4 * E4 * H2 * X4 + 3 * E4 * H3^2 + E4 * H3 * H4 * X1 + E4 * H3 * H4 * X2 + E4 * H3 * H4 * X3 - E4 * H3 * H4 * X4 + E4 * H3 * Y1 + E4 * H3 * Y2 + E4 * H3 * Y3 + 9 * E4 * H3 * Y4 + 2 * E4 * H4 * X1 * Y4 + 2 * E4 * H4 * X2 * Y4 + 2 * E4 * H4 * X3 * Y4 - 2 * E4 * H4 * X4 * Y1 - 2 * E4 * H4 * X4 * Y2 - 2 * E4 * H4 * X4 * Y3 + 2 * E4 * Y1 * Y4 - 2 * E4 * Y2 * Y3 + 4 * E4 * Y2 * Y4 + 4 * E4 * Y3 * Y4 + 4 * E4 * Y4^2 - H3 * X1 - H3 * X2 - H3 * X3 + 7 * H3 * X4 - 2 * H4 * X2 * X3 + 2 * H4 * X2 * X4 + 2 * H4 * X3 * X4 + 2 * H4 * X4^2 - 2 * X1 * Y4 - 2 * X2 * Y3 - 2 * X3 * Y2 + 2 * X4 * Y1 + 4 * X4 * Y2 + 4 * X4 * Y3 + 4 * X4 * Y4, E3 * E4 * H4^3 - E3 * H4^2 - 2 * E4^2 * H2 * H4 - E4^2 * H3 * H4^2 - E4^2 * H4^2 * Y1 - E4^2 * H4^2 * Y2 - E4^2 * H4^2 * Y3 - E4^2 * H4^2 * Y4 + 2 * E4 * H2 + 5 * E4 * H3 * H4 + E4 * H4^2 * X1 + E4 * H4^2 * X2 + E4 * H4^2 * X3 + E4 * H4^2 * X4 + 3 * E4 * H4 * Y1 + 3 * E4 * H4 * Y2 + 3 * E4 * H4 * Y3 + 3 * E4 * H4 * Y4 - 4 * H3 - H4 * X1 - H4 * X2 - H4 * X3 - H4 * X4 - 2 * Y1 - 2 * Y2 - 2 * Y3 - 2 * Y4, E3 * E4 * H4 * Y1 - E3 * E4 * H4 * Y4 - E3 * H4 * X1 + E3 * H4 * X4 - 2 * E3 * Y1 + 2 * E3 * Y4 - E4^2 * H3 * Y1 + E4^2 * H3 * Y4 - E4^2 * Y1^2 + E4^2 * Y4^2 - E4 * H3 * X1 + E4 * H3 * X4 - E4 * H4 * X1 * X2 - E4 * H4 * X1 * X3 + E4 * H4 * X2 * X4 + E4 * H4 * X3 * X4 - 2 * E4 * X1 * Y1 + 2 * E4 * X4 * Y4 - X1^2 + X1 * X2 + X1 * X3 - X2 * X4 - X3 * X4 + X4^2, E3 * E4 * H4 * Y2 - E3 * E4 * H4 * Y4 - E3 * H4 * X2 + E3 * H4 * X4 - 2 * E3 * Y2 + 2 * E3 * Y4 - E4^2 * H3 * Y2 + E4^2 * H3 * Y4 - E4^2 * Y2^2 + E4^2 * Y4^2 - E4 * H3 * X2 + E4 * H3 * X4 - E4 * H4 * X1 * X2 + E4 * H4 * X1 * X4 - E4 * H4 * X2 * X3 + E4 * H4 * X3 * X4 - 2 * E4 * X2 * Y2 + 2 * E4 * X4 * Y4 + X1 * X2 - X1 * X4 - X2^2 + X2 * X3 - X3 * X4 + X4^2, E3 * E4 * H4 * Y3 - E3 * E4 * H4 * Y4 - E3 * H4 * X3 + E3 * H4 * X4 - 2 * E3 * Y3 + 2 * E3 * Y4 - E4^2 * H3 * Y3 + E4^2 * H3 * Y4 - E4^2 * Y3^2 + E4^2 * Y4^2 - E4 * H3 * X3 + E4 * H3 * X4 - E4 * H4 * X1 * X3 + E4 * H4 * X1 * X4 - E4 * H4 * X2 * X3 + E4 * H4 * X2 * X4 - 2 * E4 * X3 * Y3 + 2 * E4 * X4 * Y4 + X1 * X3 - X1 * X4 + X2 * X3 - X2 * X4 - X3^2 + X4^2, E3 * E4 * Y1^2 - 2 * E3 * E4 * Y1 * Y4 + E3 * E4 * Y4^2 + E3 * H4 * X1^2 - 2 * E3 * H4 * X1 * X4 + E3 * H4 * X4^2 + 2 * E3 * X1 * Y1 - 2 * E3 * X1 * Y4 - 2 * E3 * X4 * Y1 + 2 * E3 * X4 * Y4 + E4^2 * X1 * Y1^2 - 2 * E4^2 * X1 * Y1 * Y4 - E4^2 * X1 * Y2 * Y3 + E4^2 * X1 * Y2 * Y4 + E4^2 * X1 * Y3 * Y4 + E4^2 * X4 * Y2 * Y3 - E4^2 * X4 * Y2 * Y4 - E4^2 * X4 * Y3 * Y4 + E4^2 * X4 * Y4^2 + E4 * H4 * X1^2 * X2 + E4 * H4 * X1^2 * X3 - E4 * H4 * X1^2 * X4 - E4 * H4 * X1 * X2 * X3 - E4 * H4 * X1 * X2 * X4 - E4 * H4 * X1 * X3 * X4 + E4 * H4 * X1 * X4^2 + E4 * H4 * X2 * X3 * X4 + 2 * E4 * X1^2 * Y1 - 2 * E4 * X1^2 * Y4 - E4 * X1 * X2 * Y3 + E4 * X1 * X2 * Y4 - E4 * X1 * X3 * Y2 + E4 * X1 * X3 * Y4 - 2 * E4 * X1 * X4 * Y1 + E4 * X1 * X4 * Y2 + E4 * X1 * X4 * Y3 + E4 * X2 * X4 * Y3 - E4 * X2 * X4 * Y4 + E4 * X3 * X4 * Y2 - E4 * X3 * X4 * Y4 - E4 * X4^2 * Y2 - E4 * X4^2 * Y3 + 2 * E4 * X4^2 * Y4 + X1^3 - X1^2 * X2 - X1^2 * X3 - X1^2 * X4 + 2 * X1 * X2 * X4 + 2 * X1 * X3 * X4 - X1 * X4^2 - X2 * X4^2 - X3 * X4^2 + X4^3, E3 * E4 * Y2^2 - 2 * E3 * E4 * Y2 * Y4 + E3 * E4 * Y4^2 + E3 * H4 * X2^2 - 2 * E3 * H4 * X2 * X4 + E3 * H4 * X4^2 + 2 * E3 * X2 * Y2 - 2 * E3 * X2 * Y4 - 2 * E3 * X4 * Y2 + 2 * E3 * X4 * Y4 + E4^2 * X2 * Y2^2 - E4^2 * X2 * Y2 * Y3 - E4^2 * X2 * Y2 * Y4 + E4^2 * X2 * Y3 * Y4 + E4^2 * X4 * Y2 * Y3 - E4^2 * X4 * Y2 * Y4 - E4^2 * X4 * Y3 * Y4 + E4^2 * X4 * Y4^2 + E4 * H4 * X1 * X2^2 - 2 * E4 * H4 * X1 * X2 * X4 + E4 * H4 * X1 * X4^2 + 2 * E4 * X2^2 * Y2 - E4 * X2^2 * Y3 - E4 * X2^2 * Y4 - E4 * X2 * X3 * Y2 + E4 * X2 * X3 * Y4 - E4 * X2 * X4 * Y2 + 2 * E4 * X2 * X4 * Y3 - E4 * X2 * X4 * Y4 + E4 * X3 * X4 * Y2 - E4 * X3 * X4 * Y4 - E4 * X4^2 * Y2 - E4 * X4^2 * Y3 + 2 * E4 * X4^2 * Y4 - X1 * X2^2 + 2 * X1 * X2 * X4 - X1 * X4^2 + X2^3 - X2^2 * X3 - X2^2 * X4 + 2 * X2 * X3 * X4 - X2 * X4^2 - X3 * X4^2 + X4^3, E3 * E4 * Y2 * Y3 - E3 * E4 * Y2 * Y4 - E3 * E4 * Y3 * Y4 + E3 * E4 * Y4^2 + E3 * H4 * X2 * X3 - E3 * H4 * X2 * X4 - E3 * H4 * X3 * X4 + E3 * H4 * X4^2 + 2 * E3 * X3 * Y2 - 2 * E3 * X3 * Y4 - 2 * E3 * X4 * Y2 + 2 * E3 * X4 * Y4 + E4^2 * X4 * Y2 * Y3 - E4^2 * X4 * Y2 * Y4 - E4^2 * X4 * Y3 * Y4 + E4^2 * X4 * Y4^2 + E4 * H4 * X1 * X2 * X3 - E4 * H4 * X1 * X2 * X4 - E4 * H4 * X1 * X3 * X4 + E4 * H4 * X1 * X4^2 + E4 * X2 * X3 * Y2 - E4 * X2 * X3 * Y3 - E4 * X2 * X4 * Y2 + E4 * X2 * X4 * Y3 + E4 * X3 * X4 * Y2 + E4 * X3 * X4 * Y3 - 2 * E4 * X3 * X4 * Y4 - E4 * X4^2 * Y2 - E4 * X4^2 * Y3 + 2 * E4 * X4^2 * Y4 - X1 * X2 * X3 + X1 * X2 * X4 + X1 * X3 * X4 - X1 * X4^2 + X2^2 * X3 - X2^2 * X4 - X2 * X3^2 + X2 * X3 * X4 + X3^2 * X4 - 2 * X3 * X4^2 + X4^3, E3 * E4 * Y3^2 - 2 * E3 * E4 * Y3 * Y4 + E3 * E4 * Y4^2 + E3 * H4 * X3^2 - 2 * E3 * H4 * X3 * X4 + E3 * H4 * X4^2 + 2 * E3 * X3 * Y3 - 2 * E3 * X3 * Y4 - 2 * E3 * X4 * Y3 + 2 * E3 * X4 * Y4 - E4^2 * X3 * Y2 * Y3 + E4^2 * X3 * Y2 * Y4 + E4^2 * X3 * Y3^2 - E4^2 * X3 * Y3 * Y4 + E4^2 * X4 * Y2 * Y3 - E4^2 * X4 * Y2 * Y4 - E4^2 * X4 * Y3 * Y4 + E4^2 * X4 * Y4^2 + E4 * H4 * X1 * X3^2 - 2 * E4 * H4 * X1 * X3 * X4 + E4 * H4 * X1 * X4^2 - E4 * X2 * X3 * Y3 + E4 * X2 * X3 * Y4 + E4 * X2 * X4 * Y3 - E4 * X2 * X4 * Y4 - E4 * X3^2 * Y2 + 2 * E4 * X3^2 * Y3 - E4 * X3^2 * Y4 + 2 * E4 * X3 * X4 * Y2 - E4 * X3 * X4 * Y3 - E4 * X3 * X4 * Y4 - E4 * X4^2 * Y2 - E4 * X4^2 * Y3 + 2 * E4 * X4^2 * Y4 - X1 * X3^2 + 2 * X1 * X3 * X4 - X1 * X4^2 - X2 * X3^2 + 2 * X2 * X3 * X4 - X2 * X4^2 + X3^3 - X3^2 * X4 - X3 * X4^2 + X4^3, E3 * H2^2 - E3 * H3^2 * H4^2 - 2 * E3 * H3 * H4^3 * X4 - 2 * E3 * H3 * H4^2 * Y4 - E3 * H4^4 * X4^2 - 2 * E3 * H4^3 * X4 * Y4 - E3 * H4^2 * Y4^2 + 2 * E4 * H2 * H3^2 + 4 * E4 * H2 * H3 * H4 * X4 + 6 * E4 * H2 * H3 * Y4 + 2 * E4 * H2 * H4^2 * X4^2 + 4 * E4 * H2 * H4 * X4 * Y4 + 4 * E4 * H2 * Y4^2 + E4 * H3^3 * H4 + 2 * E4 * H3^2 * H4^2 * X4 + E4 * H3^2 * H4 * Y1 + E4 * H3^2 * H4 * Y2 + E4 * H3^2 * H4 * Y3 + 3 * E4 * H3^2 * H4 * Y4 + E4 * H3 * H4^3 * X4^2 + 2 * E4 * H3 * H4^2 * X4 * Y1 + 2 * E4 * H3 * H4^2 * X4 * Y2 + 2 * E4 * H3 * H4^2 * X4 * Y3 + 4 * E4 * H3 * H4^2 * X4 * Y4 + 2 * E4 * H3 * H4 * Y1 * Y4 + 2 * E4 * H3 * H4 * Y2 * Y4 + 2 * E4 * H3 * H4 * Y3 * Y4 + 4 * E4 * H3 * H4 * Y4^2 + E4 * H4^3 * X4^2 * Y1 + E4 * H4^3 * X4^2 * Y2 + E4 * H4^3 * X4^2 * Y3 + E4 * H4^3 * X4^2 * Y4 + 2 * E4 * H4^2 * X4 * Y1 * Y4 + E4 * H4^2 * X4 * Y2 * Y3 + E4 * H4^2 * X4 * Y2 * Y4 + E4 * H4^2 * X4 * Y3 * Y4 + 3 * E4 * H4^2 * X4 * Y4^2 - 2 * E4 * H4 * Y2 * Y3 * Y4 + 2 * E4 * H4 * Y2 * Y4^2 + 2 * E4 * H4 * Y3 * Y4^2 + 2 * E4 * H4 * Y4^3 + 2 * H2 * H3 * X4 + 2 * H2 * H4 * X4^2 + H2 * X4 * Y1 + H2 * X4 * Y2 + H2 * X4 * Y3 + H2 * X4 * Y4 - 3 * H3^3 - 10 * H3^2 * H4 * X4 - H3^2 * Y1 - H3^2 * Y2 - H3^2 * Y3 - 11 * H3^2 * Y4 + H3 * H4^2 * X1 * X2 + H3 * H4^2 * X1 * X3 - 3 * H3 * H4^2 * X1 * X4 + H3 * H4^2 * X2 * X3 - 3 * H3 * H4^2 * X2 * X4 - 3 * H3 * H4^2 * X3 * X4 - 5 * H3 * H4^2 * X4^2 + 2 * H3 * H4 * X2 * Y1 - 2 * H3 * H4 * X2 * Y4 + 2 * H3 * H4 * X3 * Y1 + 2 * H3 * H4 * X3 * Y2 - 4 * H3 * H4 * X3 * Y4 - 8 * H3 * H4 * X4 * Y1 - 6 * H3 * H4 * X4 * Y2 - 4 * H3 * H4 * X4 * Y3 - 12 * H3 * H4 * X4 * Y4 + H3 * Y1 * Y2 + H3 * Y1 * Y3 - 4 * H3 * Y1 * Y4 + H3 * Y2 * Y3 - 4 * H3 * Y2 * Y4 - 4 * H3 * Y3 * Y4 - 11 * H3 * Y4^2 + H4^3 * X1 * X2 * X3 - H4^3 * X1 * X2 * X4 - H4^3 * X1 * X3 * X4 - H4^3 * X2 * X4^2 - H4^3 * X3 * X4^2 - H4^3 * X4^3 + H4^2 * X1 * X2 * Y1 - H4^2 * X1 * X2 * Y2 + H4^2 * X1 * X2 * Y3 + H4^2 * X1 * X2 * Y4 + H4^2 * X1 * X3 * Y1 + H4^2 * X1 * X3 * Y2 - H4^2 * X1 * X3 * Y3 + H4^2 * X1 * X3 * Y4 - 3 * H4^2 * X1 * X4 * Y1 - H4^2 * X1 * X4 * Y2 - H4^2 * X1 * X4 * Y3 - H4^2 * X1 * X4 * Y4 + H4^2 * X2 * X3 * Y1 + H4^2 * X2 * X3 * Y2 - H4^2 * X2 * X3 * Y3 - H4^2 * X2 * X3 * Y4 - H4^2 * X2 * X4 * Y1 - H4^2 * X2 * X4 * Y2 - 2 * H4^2 * X2 * X4 * Y4 - H4^2 * X3 * X4 * Y1 + H4^2 * X3 * X4 * Y3 - 4 * H4^2 * X3 * X4 * Y4 - H4^2 * X4^2 * Y1 - 2 * H4^2 * X4^2 * Y2 - 2 * H4^2 * X4^2 * Y3 - H4^2 * X4^2 * Y4 - H4 * X1 * Y2^2 + H4 * X1 * Y2 * Y3 + H4 * X1 * Y2 * Y4 - H4 * X1 * Y3^2 + H4 * X1 * Y3 * Y4 - H4 * X1 * Y4^2 + H4 * X2 * Y1^2 + H4 * X2 * Y1 * Y3 + H4 * X2 * Y1 * Y4 - H4 * X2 * Y3^2 - H4 * X2 * Y3 * Y4 - H4 * X2 * Y4^2 + H4 * X3 * Y1^2 + H4 * X3 * Y1 * Y2 + H4 * X3 * Y1 * Y4 + H4 * X3 * Y2^2 - H4 * X3 * Y2 * Y4 - 3 * H4 * X3 * Y4^2 - 3 * H4 * X4 * Y1^2 - H4 * X4 * Y1 * Y2 - H4 * X4 * Y1 * Y3 - 5 * H4 * X4 * Y1 * Y4 - H4 * X4 * Y2^2 - H4 * X4 * Y2 * Y3 - 3 * H4 * X4 * Y2 * Y4 + H4 * X4 * Y3^2 - 3 * H4 * X4 * Y3 * Y4 - 3 * H4 * X4 * Y4^2 + Y1 * Y2 * Y3 + Y1 * Y2 * Y4 + Y1 * Y3 * Y4 - 3 * Y1 * Y4^2 + Y2 * Y3 * Y4 - 3 * Y2 * Y4^2 - 3 * Y3 * Y4^2 - 3 * Y4^3, E3 * H2 * H4 - E3 * H3 * H4^2 - E3 * H4^3 * X4 - E3 * H4^2 * Y4 + E4 * H2 * H3 + 2 * E4 * H2 * H4 * X4 + 2 * E4 * H2 * Y4 + E4 * H3^2 * H4 + E4 * H3 * H4^2 * X4 + E4 * H3 * H4 * Y1 + E4 * H3 * H4 * Y2 + E4 * H3 * H4 * Y3 + 2 * E4 * H3 * H4 * Y4 + E4 * H4^2 * X4 * Y1 + E4 * H4^2 * X4 * Y2 + E4 * H4^2 * X4 * Y3 + E4 * H4^2 * X4 * Y4 + 2 * E4 * H4 * Y1 * Y4 + E4 * H4 * Y2 * Y3 + E4 * H4 * Y2 * Y4 + E4 * H4 * Y3 * Y4 + E4 * H4 * Y4^2 - 2 * H3^2 - 4 * H3 * H4 * X4 - H3 * Y1 - H3 * Y2 - H3 * Y3 - 5 * H3 * Y4 + H4^2 * X2 * X3 - H4^2 * X2 * X4 - H4^2 * X3 * X4 - H4^2 * X4^2 + H4 * X2 * Y3 - H4 * X2 * Y4 + H4 * X3 * Y2 - H4 * X3 * Y4 - H4 * X4 * Y1 - 2 * H4 * X4 * Y2 - 2 * H4 * X4 * Y3 - 3 * H4 * X4 * Y4 - 2 * Y1 * Y4 - 2 * Y2 * Y4 - 2 * Y3 * Y4 - 2 * Y4^2, E3 * H2 * Y1 - E3 * H2 * Y4 - E3 * H3 * H4 * Y1 + E3 * H3 * H4 * Y4 - E3 * H4^2 * X4 * Y1 + E3 * H4^2 * X4 * Y4 - E3 * H4 * Y1 * Y4 + E3 * H4 * Y4^2 + E4 * H3^2 * Y1 - E4 * H3^2 * Y4 + E4 * H3 * H4 * X4 * Y1 - E4 * H3 * H4 * X4 * Y4 + 4 * E4 * H3 * Y1 * Y4 - 4 * E4 * H3 * Y4^2 - E4 * H4 * X1 * Y1^2 + 2 * E4 * H4 * X1 * Y1 * Y4 + E4 * H4 * X1 * Y2 * Y3 - E4 * H4 * X1 * Y2 * Y4 - E4 * H4 * X1 * Y3 * Y4 + E4 * H4 * X4 * Y1^2 - 2 * E4 * H4 * X4 * Y2 * Y3 + 2 * E4 * H4 * X4 * Y2 * Y4 + 2 * E4 * H4 * X4 * Y3 * Y4 - 3 * E4 * H4 * X4 * Y4^2 - E4 * Y1^3 + 3 * E4 * Y1^2 * Y4 + E4 * Y1 * Y4^2 - 3 * E4 * Y4^3 + H3^2 * X1 - H3^2 * X4 - H3 * H4 * X1^2 + 5 * H3 * H4 * X1 * X4 - 4 * H3 * H4 * X4^2 - H3 * X1 * Y1 + 5 * H3 * X1 * Y4 + 3 * H3 * X4 * Y1 - 7 * H3 * X4 * Y4 - H4^2 * X1^2 * X2 - H4^2 * X1^2 * X3 + H4^2 * X1^2 * X4 + 3 * H4^2 * X1 * X2 * X4 + 3 * H4^2 * X1 * X3 * X4 - 2 * H4^2 * X1 * X4^2 - H4^2 * X2 * X3 * X4 - H4^2 * X2 * X4^2 - H4^2 * X3 * X4^2 - H4 * X1^2 * Y1 - H4 * X1^2 * Y2 - H4 * X1^2 * Y3 + H4 * X1^2 * Y4 - H4 * X1 * X2 * Y1 + H4 * X1 * X2 * Y4 - H4 * X1 * X3 * Y1 + H4 * X1 * X3 * Y4 + 4 * H4 * X1 * X4 * Y1 + 3 * H4 * X1 * X4 * Y2 + 3 * H4 * X1 * X4 * Y3 + 2 * H4 * X2 * X4 * Y1 - H4 * X2 * X4 * Y3 - H4 * X2 * X4 * Y4 + 2 * H4 * X3 * X4 * Y1 - H4 * X3 * X4 * Y2 - H4 * X3 * X4 * Y4 - 3 * H4 * X4^2 * Y1 - H4 * X4^2 * Y2 - H4 * X4^2 * Y3 - 3 * H4 * X4^2 * Y4 - X1 * Y1^2 - X1 * Y1 * Y2 - X1 * Y1 * Y3 + 2 * X1 * Y1 * Y4 - X1 * Y2 * Y3 + 2 * X1 * Y2 * Y4 + 2 * X1 * Y3 * Y4 + 2 * X1 * Y4^2 + 2 * X4 * Y1^2 + 2 * X4 * Y1 * Y2 + 2 * X4 * Y1 * Y3 - 2 * X4 * Y1 * Y4 + X4 * Y2 * Y3 - 3 * X4 * Y2 * Y4 - 3 * X4 * Y3 * Y4 - 3 * X4 * Y4^2, E3 * H2 * Y2 - E3 * H2 * Y4 - E3 * H3 * H4 * Y2 + E3 * H3 * H4 * Y4 - E3 * H4^2 * X4 * Y2 + E3 * H4^2 * X4 * Y4 - E3 * H4 * Y2 * Y4 + E3 * H4 * Y4^2 + E4 * H3^2 * Y2 - E4 * H3^2 * Y4 + E4 * H3 * H4 * X4 * Y2 - E4 * H3 * H4 * X4 * Y4 + 4 * E4 * H3 * Y2 * Y4 - 4 * E4 * H3 * Y4^2 - E4 * H4 * X2 * Y2^2 + E4 * H4 * X2 * Y2 * Y3 + E4 * H4 * X2 * Y2 * Y4 - E4 * H4 * X2 * Y3 * Y4 + E4 * H4 * X4 * Y2^2 - 2 * E4 * H4 * X4 * Y2 * Y3 + 2 * E4 * H4 * X4 * Y2 * Y4 + 2 * E4 * H4 * X4 * Y3 * Y4 - 3 * E4 * H4 * X4 * Y4^2 - E4 * Y2^3 + 3 * E4 * Y2^2 * Y4 + E4 * Y2 * Y4^2 - 3 * E4 * Y4^3 + H3^2 * X2 - H3^2 * X4 - H3 * H4 * X2^2 + 5 * H3 * H4 * X2 * X4 - 4 * H3 * H4 * X4^2 - H3 * X2 * Y2 + 5 * H3 * X2 * Y4 + 3 * H3 * X4 * Y2 - 7 * H3 * X4 * Y4 - H4^2 * X1 * X2^2 - H4^2 * X1 * X2 * X3 + 4 * H4^2 * X1 * X2 * X4 + H4^2 * X1 * X3 * X4 - 3 * H4^2 * X1 * X4^2 + H4^2 * X2 * X3 * X4 - H4^2 * X3 * X4^2 - H4 * X1 * X2 * Y2 - H4 * X1 * X2 * Y3 + 2 * H4 * X1 * X2 * Y4 + 2 * H4 * X1 * X4 * Y2 + H4 * X1 * X4 * Y3 - 3 * H4 * X1 * X4 * Y4 - H4 * X2^2 * Y1 - H4 * X2^2 * Y2 - H4 * X2 * X3 * Y1 + H4 * X2 * X3 * Y4 + 4 * H4 * X2 * X4 * Y1 + 3 * H4 * X2 * X4 * Y2 + H4 * X2 * X4 * Y3 + 2 * H4 * X2 * X4 * Y4 + H4 * X3 * X4 * Y1 - H4 * X3 * X4 * Y4 - 3 * H4 * X4^2 * Y1 - H4 * X4^2 * Y2 - H4 * X4^2 * Y3 - 3 * H4 * X4^2 * Y4 - X2 * Y1 * Y2 - X2 * Y1 * Y3 + 2 * X2 * Y1 * Y4 - X2 * Y2^2 - X2 * Y2 * Y3 + 2 * X2 * Y2 * Y4 + 2 * X2 * Y3 * Y4 + 2 * X2 * Y4^2 + 2 * X4 * Y1 * Y2 + X4 * Y1 * Y3 - 3 * X4 * Y1 * Y4 + 2 * X4 * Y2^2 + 2 * X4 * Y2 * Y3 - 2 * X4 * Y2 * Y4 - 3 * X4 * Y3 * Y4 - 3 * X4 * Y4^2, E3 * H2 * Y3 - E3 * H2 * Y4 - E3 * H3 * H4 * Y3 + E3 * H3 * H4 * Y4 - E3 * H4^2 * X4 * Y3 + E3 * H4^2 * X4 * Y4 - E3 * H4 * Y3 * Y4 + E3 * H4 * Y4^2 + E4 * H3^2 * Y3 - E4 * H3^2 * Y4 + E4 * H3 * H4 * X4 * Y3 - E4 * H3 * H4 * X4 * Y4 + 4 * E4 * H3 * Y3 * Y4 - 4 * E4 * H3 * Y4^2 + E4 * H4 * X3 * Y2 * Y3 - E4 * H4 * X3 * Y2 * Y4 - E4 * H4 * X3 * Y3^2 + E4 * H4 * X3 * Y3 * Y4 - 2 * E4 * H4 * X4 * Y2 * Y3 + 2 * E4 * H4 * X4 * Y2 * Y4 + E4 * H4 * X4 * Y3^2 + 2 * E4 * H4 * X4 * Y3 * Y4 - 3 * E4 * H4 * X4 * Y4^2 - E4 * Y3^3 + 3 * E4 * Y3^2 * Y4 + E4 * Y3 * Y4^2 - 3 * E4 * Y4^3 + H3^2 * X3 - H3^2 * X4 - H3 * H4 * X3^2 + 5 * H3 * H4 * X3 * X4 - 4 * H3 * H4 * X4^2 - H3 * X3 * Y3 + 5 * H3 * X3 * Y4 + 3 * H3 * X4 * Y3 - 7 * H3 * X4 * Y4 - H4^2 * X1 * X2 * X3 + H4^2 * X1 * X2 * X4 - H4^2 * X1 * X3^2 + 4 * H4^2 * X1 * X3 * X4 - 3 * H4^2 * X1 * X4^2 + H4^2 * X2 * X3 * X4 - H4^2 * X2 * X4^2 - H4 * X1 * X3 * Y2 - H4 * X1 * X3 * Y3 + 2 * H4 * X1 * X3 * Y4 + H4 * X1 * X4 * Y2 + 2 * H4 * X1 * X4 * Y3 - 3 * H4 * X1 * X4 * Y4 - H4 * X2 * X3 * Y1 + H4 * X2 * X3 * Y4 + H4 * X2 * X4 * Y1 - H4 * X2 * X4 * Y4 - H4 * X3^2 * Y1 - H4 * X3^2 * Y3 + 4 * H4 * X3 * X4 * Y1 + H4 * X3 * X4 * Y2 + 3 * H4 * X3 * X4 * Y3 + 2 * H4 * X3 * X4 * Y4 - 3 * H4 * X4^2 * Y1 - H4 * X4^2 * Y2 - H4 * X4^2 * Y3 - 3 * H4 * X4^2 * Y4 - X3 * Y1 * Y2 - X3 * Y1 * Y3 + 2 * X3 * Y1 * Y4 - X3 * Y2 * Y3 + 2 * X3 * Y2 * Y4 - X3 * Y3^2 + 2 * X3 * Y3 * Y4 + 2 * X3 * Y4^2 + X4 * Y1 * Y2 + 2 * X4 * Y1 * Y3 - 3 * X4 * Y1 * Y4 + 2 * X4 * Y2 * Y3 - 3 * X4 * Y2 * Y4 + 2 * X4 * Y3^2 - 2 * X4 * Y3 * Y4 - 3 * X4 * Y4^2, E3 * H4^2 * X1 - E3 * H4^2 * X4 + E3 * H4 * Y1 - E3 * H4 * Y4 - E4 * H3 * H4 * X1 + E4 * H3 * H4 * X4 + E4 * H3 * Y1 - E4 * H3 * Y4 + E4 * H4 * X1 * Y1 - E4 * H4 * X1 * Y2 - E4 * H4 * X1 * Y3 - E4 * H4 * X1 * Y4 + E4 * H4 * X4 * Y1 + E4 * H4 * X4 * Y2 + E4 * H4 * X4 * Y3 - E4 * H4 * X4 * Y4 + E4 * Y1^2 - E4 * Y4^2 + 2 * H3 * X1 - 2 * H3 * X4 + H4 * X1^2 - H4 * X4^2 + X1 * Y1 + X1 * Y2 + X1 * Y3 + X1 * Y4 - X4 * Y1 - X4 * Y2 - X4 * Y3 - X4 * Y4, E3 * H4^2 * X2 - E3 * H4^2 * X4 + E3 * H4 * Y2 - E3 * H4 * Y4 - E4 * H3 * H4 * X2 + E4 * H3 * H4 * X4 + E4 * H3 * Y2 - E4 * H3 * Y4 - E4 * H4 * X2 * Y1 + E4 * H4 * X2 * Y2 - E4 * H4 * X2 * Y3 - E4 * H4 * X2 * Y4 + E4 * H4 * X4 * Y1 + E4 * H4 * X4 * Y2 + E4 * H4 * X4 * Y3 - E4 * H4 * X4 * Y4 + E4 * Y2^2 - E4 * Y4^2 + 2 * H3 * X2 - 2 * H3 * X4 + H4 * X2^2 - H4 * X4^2 + X2 * Y1 + X2 * Y2 + X2 * Y3 + X2 * Y4 - X4 * Y1 - X4 * Y2 - X4 * Y3 - X4 * Y4, E3 * H4^2 * X3 - E3 * H4^2 * X4 + E3 * H4 * Y3 - E3 * H4 * Y4 - E4 * H3 * H4 * X3 + E4 * H3 * H4 * X4 + E4 * H3 * Y3 - E4 * H3 * Y4 - E4 * H4 * X3 * Y1 - E4 * H4 * X3 * Y2 + E4 * H4 * X3 * Y3 - E4 * H4 * X3 * Y4 + E4 * H4 * X4 * Y1 + E4 * H4 * X4 * Y2 + E4 * H4 * X4 * Y3 - E4 * H4 * X4 * Y4 + E4 * Y3^2 - E4 * Y4^2 + 2 * H3 * X3 - 2 * H3 * X4 + H4 * X3^2 - H4 * X4^2 + X3 * Y1 + X3 * Y2 + X3 * Y3 + X3 * Y4 - X4 * Y1 - X4 * Y2 - X4 * Y3 - X4 * Y4, E3 * H4 * X1 * Y1 - E3 * H4 * X1 * Y4 - E3 * H4 * X4 * Y1 + E3 * H4 * X4 * Y4 + E3 * Y1^2 - 2 * E3 * Y1 * Y4 + E3 * Y4^2 - E4 * H3 * X1 * Y1 + E4 * H3 * X1 * Y4 + E4 * H3 * X4 * Y1 - E4 * H3 * X4 * Y4 - 2 * E4 * X1 * Y1 * Y4 - E4 * X1 * Y2 * Y3 + E4 * X1 * Y2 * Y4 + E4 * X1 * Y3 * Y4 + E4 * X1 * Y4^2 + E4 * X4 * Y1^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X1^2 + 2 * H3 * X1 * X4 - H3 * X4^2 - H4 * X1^2 * X4 - H4 * X1 * X2 * X3 + H4 * X1 * X2 * X4 + H4 * X1 * X3 * X4 + H4 * X1 * X4^2 + H4 * X2 * X3 * X4 - H4 * X2 * X4^2 - H4 * X3 * X4^2 - 2 * X1^2 * Y4 - X1 * X2 * Y3 + X1 * X2 * Y4 - X1 * X3 * Y2 + X1 * X3 * Y4 + X1 * X4 * Y2 + X1 * X4 * Y3 + 2 * X1 * X4 * Y4 + X2 * X4 * Y3 - X2 * X4 * Y4 + X3 * X4 * Y2 - X3 * X4 * Y4 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X2 * Y1 - E3 * H4 * X2 * Y4 - E3 * H4 * X4 * Y1 + E3 * H4 * X4 * Y4 + E3 * Y1 * Y2 - E3 * Y1 * Y4 - E3 * Y2 * Y4 + E3 * Y4^2 - E4 * H3 * X2 * Y1 + E4 * H3 * X2 * Y4 + E4 * H3 * X4 * Y1 - E4 * H3 * X4 * Y4 - E4 * X2 * Y1^2 + E4 * X2 * Y4^2 + E4 * X4 * Y1^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X1 * X2 + H3 * X1 * X4 + H3 * X2 * X4 - H3 * X4^2 - H4 * X1 * X2^2 + H4 * X1 * X4^2 + H4 * X2^2 * X4 + H4 * X2 * X3 * X4 - H4 * X2 * X4^2 - H4 * X3 * X4^2 - X1 * X2 * Y1 - X1 * X2 * Y2 + X1 * X4 * Y1 + X1 * X4 * Y4 + X2 * X4 * Y2 + X2 * X4 * Y3 + X3 * X4 * Y2 - X3 * X4 * Y4 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X2 * Y2 - E3 * H4 * X2 * Y4 - E3 * H4 * X4 * Y2 + E3 * H4 * X4 * Y4 + E3 * Y2^2 - 2 * E3 * Y2 * Y4 + E3 * Y4^2 - E4 * H3 * X2 * Y2 + E4 * H3 * X2 * Y4 + E4 * H3 * X4 * Y2 - E4 * H3 * X4 * Y4 - E4 * X2 * Y2 * Y3 - E4 * X2 * Y2 * Y4 + E4 * X2 * Y3 * Y4 + E4 * X2 * Y4^2 + E4 * X4 * Y2^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X2^2 + 2 * H3 * X2 * X4 - H3 * X4^2 - H4 * X2^2 * X3 + 2 * H4 * X2 * X3 * X4 - H4 * X3 * X4^2 - X2^2 * Y3 - X2^2 * Y4 - X2 * X3 * Y2 + X2 * X3 * Y4 + X2 * X4 * Y2 + 2 * X2 * X4 * Y3 + X2 * X4 * Y4 + X3 * X4 * Y2 - X3 * X4 * Y4 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X3 * Y1 - E3 * H4 * X3 * Y4 - E3 * H4 * X4 * Y1 + E3 * H4 * X4 * Y4 + E3 * Y1 * Y3 - E3 * Y1 * Y4 - E3 * Y3 * Y4 + E3 * Y4^2 - E4 * H3 * X3 * Y1 + E4 * H3 * X3 * Y4 + E4 * H3 * X4 * Y1 - E4 * H3 * X4 * Y4 - E4 * X3 * Y1^2 + E4 * X3 * Y4^2 + E4 * X4 * Y1^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X1 * X3 + H3 * X1 * X4 + H3 * X3 * X4 - H3 * X4^2 - H4 * X1 * X3^2 + H4 * X1 * X4^2 + H4 * X2 * X3 * X4 - H4 * X2 * X4^2 + H4 * X3^2 * X4 - H4 * X3 * X4^2 - X1 * X3 * Y1 - X1 * X3 * Y3 + X1 * X4 * Y1 + X1 * X4 * Y4 + X2 * X4 * Y3 - X2 * X4 * Y4 + X3 * X4 * Y2 + X3 * X4 * Y3 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X3 * Y2 - E3 * H4 * X3 * Y4 - E3 * H4 * X4 * Y2 + E3 * H4 * X4 * Y4 + E3 * Y2 * Y3 - E3 * Y2 * Y4 - E3 * Y3 * Y4 + E3 * Y4^2 - E4 * H3 * X3 * Y2 + E4 * H3 * X3 * Y4 + E4 * H3 * X4 * Y2 - E4 * H3 * X4 * Y4 - E4 * X3 * Y2^2 + E4 * X3 * Y4^2 + E4 * X4 * Y2^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X2 * X3 + H3 * X2 * X4 + H3 * X3 * X4 - H3 * X4^2 - H4 * X2 * X3^2 + H4 * X2 * X3 * X4 + H4 * X3^2 * X4 - H4 * X3 * X4^2 - X2 * X3 * Y2 - X2 * X3 * Y3 + X2 * X4 * Y2 + X2 * X4 * Y3 + X3 * X4 * Y2 + X3 * X4 * Y3 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X3 * Y3 - E3 * H4 * X3 * Y4 - E3 * H4 * X4 * Y3 + E3 * H4 * X4 * Y4 + E3 * Y3^2 - 2 * E3 * Y3 * Y4 + E3 * Y4^2 - E4 * H3 * X3 * Y3 + E4 * H3 * X3 * Y4 + E4 * H3 * X4 * Y3 - E4 * H3 * X4 * Y4 - E4 * X3 * Y2 * Y3 + E4 * X3 * Y2 * Y4 - E4 * X3 * Y3 * Y4 + E4 * X3 * Y4^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 + E4 * X4 * Y3^2 - E4 * X4 * Y3 * Y4 - H3 * X3^2 + 2 * H3 * X3 * X4 - H3 * X4^2 - H4 * X2 * X3^2 + 2 * H4 * X2 * X3 * X4 - H4 * X2 * X4^2 - X2 * X3 * Y3 + X2 * X3 * Y4 + X2 * X4 * Y3 - X2 * X4 * Y4 - X3^2 * Y2 - X3^2 * Y4 + 2 * X3 * X4 * Y2 + X3 * X4 * Y3 + X3 * X4 * Y4 - X4^2 * Y2 - X4^2 * Y3, E3 * X1 * Y2 - E3 * X1 * Y4 - E3 * X2 * Y1 + E3 * X2 * Y4 + E3 * X4 * Y1 - E3 * X4 * Y2 - E4 * X1 * X2 * Y1 + E4 * X1 * X2 * Y2 + E4 * X1 * X4 * Y1 - E4 * X1 * X4 * Y4 - E4 * X2 * X4 * Y2 + E4 * X2 * X4 * Y4 - X1^2 * X2 + X1^2 * X4 + X1 * X2^2 - X1 * X4^2 - X2^2 * X4 + X2 * X4^2, E3 * X1 * Y3 - E3 * X1 * Y4 - E3 * X3 * Y1 + E3 * X3 * Y4 + E3 * X4 * Y1 - E3 * X4 * Y3 - E4 * X1 * X3 * Y1 + E4 * X1 * X3 * Y3 + E4 * X1 * X4 * Y1 - E4 * X1 * X4 * Y4 - E4 * X3 * X4 * Y3 + E4 * X3 * X4 * Y4 - X1^2 * X3 + X1^2 * X4 + X1 * X3^2 - X1 * X4^2 - X3^2 * X4 + X3 * X4^2, E3 * X2 * Y3 - E3 * X2 * Y4 - E3 * X3 * Y2 + E3 * X3 * Y4 + E3 * X4 * Y2 - E3 * X4 * Y3 - E4 * X2 * X3 * Y2 + E4 * X2 * X3 * Y3 + E4 * X2 * X4 * Y2 - E4 * X2 * X4 * Y4 - E4 * X3 * X4 * Y3 + E4 * X3 * X4 * Y4 - X2^2 * X3 + X2^2 * X4 + X2 * X3^2 - X2 * X4^2 - X3^2 * X4 + X3 * X4^2, E4 * H2^2 + 2 * E4 * H2 * H4 * Y4 - E4 * H4^2 * Y2 * Y3 + E4 * H4^2 * Y2 * Y4 + E4 * H4^2 * Y3 * Y4 - 2 * H2 * H3 - 2 * H2 * H4 * X4 - H2 * Y1 - H2 * Y2 - H2 * Y3 - H2 * Y4 + H3^2 * H4 + H3 * H4^2 * X1 + H3 * H4^2 * X2 + H3 * H4^2 * X3 - H3 * H4^2 * X4 + 2 * H3 * H4 * Y1 + 2 * H3 * H4 * Y2 + 2 * H3 * H4 * Y3 - 4 * H3 * H4 * Y4 + H4^3 * X1 * X2 + H4^3 * X1 * X3 - H4^3 * X1 * X4 + H4^2 * X1 * Y1 + H4^2 * X1 * Y2 + H4^2 * X1 * Y3 - H4^2 * X1 * Y4 + H4^2 * X2 * Y1 + H4^2 * X2 * Y2 + H4^2 * X3 * Y1 + H4^2 * X3 * Y3 - H4^2 * X4 * Y1 - 3 * H4^2 * X4 * Y4 + H4 * Y1^2 + H4 * Y1 * Y2 + H4 * Y1 * Y3 - H4 * Y1 * Y4 + H4 * Y2^2 + H4 * Y2 * Y3 - H4 * Y2 * Y4 + H4 * Y3^2 - H4 * Y3 * Y4 - 3 * H4 * Y4^2, E4 * H2 * Y1 - E4 * H2 * Y4 + E4 * H4 * Y1 * Y4 + E4 * H4 * Y2 * Y3 - E4 * H4 * Y2 * Y4 - E4 * H4 * Y3 * Y4 - H3 * H4 * X1 + H3 * H4 * X4 - 2 * H3 * Y1 + 2 * H3 * Y4 - H4^2 * X1 * X2 - H4^2 * X1 * X3 + H4^2 * X1 * X4 + H4^2 * X2 * X3 - H4 * X1 * Y1 - H4 * X1 * Y2 - H4 * X1 * Y3 + H4 * X1 * Y4 - H4 * X2 * Y1 + H4 * X2 * Y3 - H4 * X3 * Y1 + H4 * X3 * Y2 + H4 * X4 * Y1 + H4 * X4 * Y4 - Y1^2 - Y1 * Y2 - Y1 * Y3 + Y2 * Y4 + Y3 * Y4 + Y4^2, E4 * H2 * Y2 - E4 * H2 * Y4 + E4 * H4 * Y2 * Y3 - E4 * H4 * Y3 * Y4 - H3 * H4 * X2 + H3 * H4 * X4 - 2 * H3 * Y2 + 2 * H3 * Y4 - H4^2 * X1 * X2 + H4^2 * X1 * X4 - H4 * X1 * Y2 + H4 * X1 * Y4 - H4 * X2 * Y1 - H4 * X2 * Y2 + H4 * X4 * Y1 + H4 * X4 * Y4 - Y1 * Y2 + Y1 * Y4 - Y2^2 - Y2 * Y3 + Y3 * Y4 + Y4^2, E4 * H2 * Y3 - E4 * H2 * Y4 + E4 * H4 * Y2 * Y3 - E4 * H4 * Y2 * Y4 - H3 * H4 * X3 + H3 * H4 * X4 - 2 * H3 * Y3 + 2 * H3 * Y4 - H4^2 * X1 * X3 + H4^2 * X1 * X4 - H4 * X1 * Y3 + H4 * X1 * Y4 - H4 * X3 * Y1 - H4 * X3 * Y3 + H4 * X4 * Y1 + H4 * X4 * Y4 - Y1 * Y3 + Y1 * Y4 - Y2 * Y3 + Y2 * Y4 - Y3^2 + Y4^2, E4 * H3 * Y1^2 - 2 * E4 * H3 * Y1 * Y4 + E4 * H3 * Y4^2 + E4 * H4 * X1 * Y1^2 - 2 * E4 * H4 * X1 * Y1 * Y4 - E4 * H4 * X1 * Y2 * Y3 + E4 * H4 * X1 * Y2 * Y4 + E4 * H4 * X1 * Y3 * Y4 + E4 * H4 * X4 * Y2 * Y3 - E4 * H4 * X4 * Y2 * Y4 - E4 * H4 * X4 * Y3 * Y4 + E4 * H4 * X4 * Y4^2 + E4 * Y1^3 - E4 * Y1^2 * Y4 - E4 * Y1 * Y4^2 + E4 * Y4^3 + H3 * H4 * X1^2 - 2 * H3 * H4 * X1 * X4 + H3 * H4 * X4^2 + 2 * H3 * X1 * Y1 - 2 * H3 * X1 * Y4 - 2 * H3 * X4 * Y1 + 2 * H3 * X4 * Y4 + H4^2 * X1^2 * X2 + H4^2 * X1^2 * X3 - H4^2 * X1^2 * X4 - H4^2 * X1 * X2 * X3 - H4^2 * X1 * X2 * X4 - H4^2 * X1 * X3 * X4 + H4^2 * X1 * X4^2 + H4^2 * X2 * X3 * X4 + H4 * X1^2 * Y1 + H4 * X1^2 * Y2 + H4 * X1^2 * Y3 - H4 * X1^2 * Y4 + H4 * X1 * X2 * Y1 - H4 * X1 * X2 * Y3 + H4 * X1 * X3 * Y1 - H4 * X1 * X3 * Y2 - 2 * H4 * X1 * X4 * Y1 - H4 * X1 * X4 * Y2 - H4 * X1 * X4 * Y3 - H4 * X2 * X4 * Y1 + H4 * X2 * X4 * Y3 - H4 * X3 * X4 * Y1 + H4 * X3 * X4 * Y2 + H4 * X4^2 * Y1 + H4 * X4^2 * Y4 + X1 * Y1^2 + X1 * Y1 * Y2 + X1 * Y1 * Y3 - X1 * Y2 * Y4 - X1 * Y3 * Y4 - X1 * Y4^2 - X4 * Y1^2 - X4 * Y1 * Y2 - X4 * Y1 * Y3 + X4 * Y2 * Y4 + X4 * Y3 * Y4 + X4 * Y4^2, E4 * H3 * Y2^2 - 2 * E4 * H3 * Y2 * Y4 + E4 * H3 * Y4^2 + E4 * H4 * X2 * Y2^2 - E4 * H4 * X2 * Y2 * Y3 - E4 * H4 * X2 * Y2 * Y4 + E4 * H4 * X2 * Y3 * Y4 + E4 * H4 * X4 * Y2 * Y3 - E4 * H4 * X4 * Y2 * Y4 - E4 * H4 * X4 * Y3 * Y4 + E4 * H4 * X4 * Y4^2 + E4 * Y2^3 - E4 * Y2^2 * Y4 - E4 * Y2 * Y4^2 + E4 * Y4^3 + H3 * H4 * X2^2 - 2 * H3 * H4 * X2 * X4 + H3 * H4 * X4^2 + 2 * H3 * X2 * Y2 - 2 * H3 * X2 * Y4 - 2 * H3 * X4 * Y2 + 2 * H3 * X4 * Y4 + H4^2 * X1 * X2^2 - 2 * H4^2 * X1 * X2 * X4 + H4^2 * X1 * X4^2 + H4 * X1 * X2 * Y2 - H4 * X1 * X2 * Y4 - H4 * X1 * X4 * Y2 + H4 * X1 * X4 * Y4 + H4 * X2^2 * Y1 + H4 * X2^2 * Y2 - 2 * H4 * X2 * X4 * Y1 - H4 * X2 * X4 * Y2 - H4 * X2 * X4 * Y4 + H4 * X4^2 * Y1 + H4 * X4^2 * Y4 + X2 * Y1 * Y2 - X2 * Y1 * Y4 + X2 * Y2^2 + X2 * Y2 * Y3 - X2 * Y3 * Y4 - X2 * Y4^2 - X4 * Y1 * Y2 + X4 * Y1 * Y4 - X4 * Y2^2 - X4 * Y2 * Y3 + X4 * Y3 * Y4 + X4 * Y4^2, E4 * H3 * Y2 * Y3 - E4 * H3 * Y2 * Y4 - E4 * H3 * Y3 * Y4 + E4 * H3 * Y4^2 + E4 * H4 * X4 * Y2 * Y3 - E4 * H4 * X4 * Y2 * Y4 - E4 * H4 * X4 * Y3 * Y4 + E4 * H4 * X4 * Y4^2 + E4 * Y2 * Y3^2 - E4 * Y2 * Y4^2 - E4 * Y3^2 * Y4 + E4 * Y4^3 + H3 * H4 * X2 * X3 - H3 * H4 * X2 * X4 - H3 * H4 * X3 * X4 + H3 * H4 * X4^2 + 2 * H3 * X3 * Y2 - 2 * H3 * X3 * Y4 - 2 * H3 * X4 * Y2 + 2 * H3 * X4 * Y4 + H4^2 * X1 * X2 * X3 - H4^2 * X1 * X2 * X4 - H4^2 * X1 * X3 * X4 + H4^2 * X1 * X4^2 + H4 * X1 * X3 * Y2 - H4 * X1 * X3 * Y4 - H4 * X1 * X4 * Y2 + H4 * X1 * X4 * Y4 + H4 * X2 * X3 * Y1 + H4 * X2 * X3 * Y2 - H4 * X2 * X4 * Y1 - H4 * X2 * X4 * Y2 - H4 * X3 * X4 * Y1 - H4 * X3 * X4 * Y4 + H4 * X4^2 * Y1 + H4 * X4^2 * Y4 + X3 * Y1 * Y2 - X3 * Y1 * Y4 + X3 * Y2^2 + X3 * Y2 * Y3 - X3 * Y3 * Y4 - X3 * Y4^2 - X4 * Y1 * Y2 + X4 * Y1 * Y4 - X4 * Y2^2 - X4 * Y2 * Y3 + X4 * Y3 * Y4 + X4 * Y4^2, E4 * H3 * Y3^2 - 2 * E4 * H3 * Y3 * Y4 + E4 * H3 * Y4^2 - E4 * H4 * X3 * Y2 * Y3 + E4 * H4 * X3 * Y2 * Y4 + E4 * H4 * X3 * Y3^2 - E4 * H4 * X3 * Y3 * Y4 + E4 * H4 * X4 * Y2 * Y3 - E4 * H4 * X4 * Y2 * Y4 - E4 * H4 * X4 * Y3 * Y4 + E4 * H4 * X4 * Y4^2 + E4 * Y3^3 - E4 * Y3^2 * Y4 - E4 * Y3 * Y4^2 + E4 * Y4^3 + H3 * H4 * X3^2 - 2 * H3 * H4 * X3 * X4 + H3 * H4 * X4^2 + 2 * H3 * X3 * Y3 - 2 * H3 * X3 * Y4 - 2 * H3 * X4 * Y3 + 2 * H3 * X4 * Y4 + H4^2 * X1 * X3^2 - 2 * H4^2 * X1 * X3 * X4 + H4^2 * X1 * X4^2 + H4 * X1 * X3 * Y3 - H4 * X1 * X3 * Y4 - H4 * X1 * X4 * Y3 + H4 * X1 * X4 * Y4 + H4 * X3^2 * Y1 + H4 * X3^2 * Y3 - 2 * H4 * X3 * X4 * Y1 - H4 * X3 * X4 * Y3 - H4 * X3 * X4 * Y4 + H4 * X4^2 * Y1 + H4 * X4^2 * Y4 + X3 * Y1 * Y3 - X3 * Y1 * Y4 + X3 * Y2 * Y3 - X3 * Y2 * Y4 + X3 * Y3^2 - X3 * Y4^2 - X4 * Y1 * Y3 + X4 * Y1 * Y4 - X4 * Y2 * Y3 + X4 * Y2 * Y4 - X4 * Y3^2 + X4 * Y4^2, E4 * Y1 * Y2 - E4 * Y1 * Y4 - E4 * Y2 * Y3 + E4 * Y3 * Y4 + H4 * X1 * X2 - H4 * X1 * X4 - H4 * X2 * X3 + H4 * X3 * X4 + X1 * Y2 - X1 * Y4 + X2 * Y1 - X2 * Y3 - X3 * Y2 + X3 * Y4 - X4 * Y1 + X4 * Y3, E4 * Y1 * Y3 - E4 * Y1 * Y4 - E4 * Y2 * Y3 + E4 * Y2 * Y4 + H4 * X1 * X3 - H4 * X1 * X4 - H4 * X2 * X3 + H4 * X2 * X4 + X1 * Y3 - X1 * Y4 - X2 * Y3 + X2 * Y4 + X3 * Y1 - X3 * Y2 - X4 * Y1 + X4 * Y2, E4 * Y2^2 * Y3 - E4 * Y2^2 * Y4 - E4 * Y2 * Y3^2 + E4 * Y2 * Y4^2 + E4 * Y3^2 * Y4 - E4 * Y3 * Y4^2 + H4 * X1 * X2 * Y3 - H4 * X1 * X2 * Y4 - H4 * X1 * X3 * Y2 + H4 * X1 * X3 * Y4 + H4 * X1 * X4 * Y2 - H4 * X1 * X4 * Y3 + H4 * X2 * X3 * Y2 - H4 * X2 * X3 * Y3 - H4 * X2 * X4 * Y2 + H4 * X2 * X4 * Y4 + H4 * X3 * X4 * Y3 - H4 * X3 * X4 * Y4 + X2 * Y1 * Y3 - X2 * Y1 * Y4 + X2 * Y2 * Y3 - X2 * Y2 * Y4 - X2 * Y3^2 + X2 * Y4^2 - X3 * Y1 * Y2 + X3 * Y1 * Y4 + X3 * Y2^2 - X3 * Y2 * Y3 + X3 * Y3 * Y4 - X3 * Y4^2 + X4 * Y1 * Y2 - X4 * Y1 * Y3 - X4 * Y2^2 + X4 * Y2 * Y4 + X4 * Y3^2 - X4 * Y3 * Y4, H1 + H2 * X4 + H3 * Y4 + H4 * X4 * Y4 + Y4^2, H2 * X1 - H2 * X4 + H3 * Y1 - H3 * Y4 + H4 * X1 * Y1 - H4 * X4 * Y4 + Y1^2 - Y4^2, H2 * X2 - H2 * X4 + H3 * Y2 - H3 * Y4 + H4 * X2 * Y2 - H4 * X4 * Y4 + Y2^2 - Y4^2, H2 * X3 - H2 * X4 + H3 * Y3 - H3 * Y4 + H4 * X3 * Y3 - H4 * X4 * Y4 + Y3^2 - Y4^2, H3 * X1 * Y2 - H3 * X1 * Y4 - H3 * X2 * Y1 + H3 * X2 * Y4 + H3 * X4 * Y1 - H3 * X4 * Y2 - H4 * X1 * X2 * Y1 + H4 * X1 * X2 * Y2 + H4 * X1 * X4 * Y1 - H4 * X1 * X4 * Y4 - H4 * X2 * X4 * Y2 + H4 * X2 * X4 * Y4 + X1 * Y2^2 - X1 * Y4^2 - X2 * Y1^2 + X2 * Y4^2 + X4 * Y1^2 - X4 * Y2^2, H3 * X1 * Y3 - H3 * X1 * Y4 - H3 * X3 * Y1 + H3 * X3 * Y4 + H3 * X4 * Y1 - H3 * X4 * Y3 - H4 * X1 * X3 * Y1 + H4 * X1 * X3 * Y3 + H4 * X1 * X4 * Y1 - H4 * X1 * X4 * Y4 - H4 * X3 * X4 * Y3 + H4 * X3 * X4 * Y4 + X1 * Y3^2 - X1 * Y4^2 - X3 * Y1^2 + X3 * Y4^2 + X4 * Y1^2 - X4 * Y3^2, H3 * X2 * Y3 - H3 * X2 * Y4 - H3 * X3 * Y2 + H3 * X3 * Y4 + H3 * X4 * Y2 - H3 * X4 * Y3 - H4 * X2 * X3 * Y2 + H4 * X2 * X3 * Y3 + H4 * X2 * X4 * Y2 - H4 * X2 * X4 * Y4 - H4 * X3 * X4 * Y3 + H4 * X3 * X4 * Y4 + X2 * Y3^2 - X2 * Y4^2 - X3 * Y2^2 + X3 * Y4^2 + X4 * Y2^2 - X4 * Y3^2, H4 * X1 * X2 * Y1 * Y3 - H4 * X1 * X2 * Y1 * Y4 - H4 * X1 * X2 * Y2 * Y3 + H4 * X1 * X2 * Y2 * Y4 - H4 * X1 * X3 * Y1 * Y2 + H4 * X1 * X3 * Y1 * Y4 + H4 * X1 * X3 * Y2 * Y3 - H4 * X1 * X3 * Y3 * Y4 + H4 * X1 * X4 * Y1 * Y2 - H4 * X1 * X4 * Y1 * Y3 - H4 * X1 * X4 * Y2 * Y4 + H4 * X1 * X4 * Y3 * Y4 + H4 * X2 * X3 * Y1 * Y2 - H4 * X2 * X3 * Y1 * Y3 - H4 * X2 * X3 * Y2 * Y4 + H4 * X2 * X3 * Y3 * Y4 - H4 * X2 * X4 * Y1 * Y2 + H4 * X2 * X4 * Y1 * Y4 + H4 * X2 * X4 * Y2 * Y3 - H4 * X2 * X4 * Y3 * Y4 + H4 * X3 * X4 * Y1 * Y3 - H4 * X3 * X4 * Y1 * Y4 - H4 * X3 * X4 * Y2 * Y3 + H4 * X3 * X4 * Y2 * Y4 - X1 * Y2^2 * Y3 + X1 * Y2^2 * Y4 + X1 * Y2 * Y3^2 - X1 * Y2 * Y4^2 - X1 * Y3^2 * Y4 + X1 * Y3 * Y4^2 + X2 * Y1^2 * Y3 - X2 * Y1^2 * Y4 - X2 * Y1 * Y3^2 + X2 * Y1 * Y4^2 + X2 * Y3^2 * Y4 - X2 * Y3 * Y4^2 - X3 * Y1^2 * Y2 + X3 * Y1^2 * Y4 + X3 * Y1 * Y2^2 - X3 * Y1 * Y4^2 - X3 * Y2^2 * Y4 + X3 * Y2 * Y4^2 + X4 * Y1^2 * Y2 - X4 * Y1^2 * Y3 - X4 * Y1 * Y2^2 + X4 * Y1 * Y3^2 + X4 * Y2^2 * Y3 - X4 * Y2 * Y3^2 ]
Index: /trunk/examples/shash2.output-new
===================================================================
--- /trunk/examples/shash2.output-new	(revision 8)
+++ /trunk/examples/shash2.output-new	(revision 8)
@@ -0,0 +1,1 @@
+[ 2 * E1 + E3 * E4 * H4^2 * X4 + E3 * H4 * X4 + 2 * E3 * Y4 - 2 * E4^2 * H2 * X4 - E4^2 * H3 * H4 * X4 - E4^2 * H4 * X4 * Y1 - E4^2 * H4 * X4 * Y2 - E4^2 * H4 * X4 * Y3 - E4^2 * H4 * X4 * Y4 + 3 * E4 * H3 * X4 + E4 * H4 * X1 * X4 + E4 * H4 * X2 * X4 + E4 * H4 * X3 * X4 + E4 * H4 * X4^2 + E4 * X4 * Y1 + E4 * X4 * Y2 + E4 * X4 * Y3 + 3 * E4 * X4 * Y4 - X1 * X4 - X2 * X4 - X3 * X4 + X4^2, E3 * E4 * H3 * H4^2 + 2 * E3 * E4 * H4^2 * Y4 - 2 * E3 * H2 + E3 * H3 * H4 + 2 * E3 * H4^2 * X4 - 2 * E4^2 * H2 * H3 - 4 * E4^2 * H2 * Y4 - E4^2 * H3^2 * H4 - E4^2 * H3 * H4 * Y1 - E4^2 * H3 * H4 * Y2 - E4^2 * H3 * H4 * Y3 - 3 * E4^2 * H3 * H4 * Y4 - 2 * E4^2 * H4 * Y1 * Y4 - 2 * E4^2 * H4 * Y2 * Y4 - 2 * E4^2 * H4 * Y3 * Y4 - 2 * E4^2 * H4 * Y4^2 - 4 * E4 * H2 * X4 + 3 * E4 * H3^2 + E4 * H3 * H4 * X1 + E4 * H3 * H4 * X2 + E4 * H3 * H4 * X3 - E4 * H3 * H4 * X4 + E4 * H3 * Y1 + E4 * H3 * Y2 + E4 * H3 * Y3 + 9 * E4 * H3 * Y4 + 2 * E4 * H4 * X1 * Y4 + 2 * E4 * H4 * X2 * Y4 + 2 * E4 * H4 * X3 * Y4 - 2 * E4 * H4 * X4 * Y1 - 2 * E4 * H4 * X4 * Y2 - 2 * E4 * H4 * X4 * Y3 + 2 * E4 * Y1 * Y4 - 2 * E4 * Y2 * Y3 + 4 * E4 * Y2 * Y4 + 4 * E4 * Y3 * Y4 + 4 * E4 * Y4^2 - H3 * X1 - H3 * X2 - H3 * X3 + 7 * H3 * X4 - 2 * H4 * X2 * X3 + 2 * H4 * X2 * X4 + 2 * H4 * X3 * X4 + 2 * H4 * X4^2 - 2 * X1 * Y4 - 2 * X2 * Y3 - 2 * X3 * Y2 + 2 * X4 * Y1 + 4 * X4 * Y2 + 4 * X4 * Y3 + 4 * X4 * Y4, E3 * H2^2 - E3 * H3^2 * H4^2 - 2 * E3 * H3 * H4^3 * X4 - 2 * E3 * H3 * H4^2 * Y4 - E3 * H4^4 * X4^2 - 2 * E3 * H4^3 * X4 * Y4 - E3 * H4^2 * Y4^2 + 2 * E4 * H2 * H3^2 + 4 * E4 * H2 * H3 * H4 * X4 + 6 * E4 * H2 * H3 * Y4 + 2 * E4 * H2 * H4^2 * X4^2 + 4 * E4 * H2 * H4 * X4 * Y4 + 4 * E4 * H2 * Y4^2 + E4 * H3^3 * H4 + 2 * E4 * H3^2 * H4^2 * X4 + E4 * H3^2 * H4 * Y1 + E4 * H3^2 * H4 * Y2 + E4 * H3^2 * H4 * Y3 + 3 * E4 * H3^2 * H4 * Y4 + E4 * H3 * H4^3 * X4^2 + 2 * E4 * H3 * H4^2 * X4 * Y1 + 2 * E4 * H3 * H4^2 * X4 * Y2 + 2 * E4 * H3 * H4^2 * X4 * Y3 + 4 * E4 * H3 * H4^2 * X4 * Y4 + 2 * E4 * H3 * H4 * Y1 * Y4 + 2 * E4 * H3 * H4 * Y2 * Y4 + 2 * E4 * H3 * H4 * Y3 * Y4 + 4 * E4 * H3 * H4 * Y4^2 + E4 * H4^3 * X4^2 * Y1 + E4 * H4^3 * X4^2 * Y2 + E4 * H4^3 * X4^2 * Y3 + E4 * H4^3 * X4^2 * Y4 + 2 * E4 * H4^2 * X4 * Y1 * Y4 + E4 * H4^2 * X4 * Y2 * Y3 + E4 * H4^2 * X4 * Y2 * Y4 + E4 * H4^2 * X4 * Y3 * Y4 + 3 * E4 * H4^2 * X4 * Y4^2 - 2 * E4 * H4 * Y2 * Y3 * Y4 + 2 * E4 * H4 * Y2 * Y4^2 + 2 * E4 * H4 * Y3 * Y4^2 + 2 * E4 * H4 * Y4^3 + 2 * H2 * H3 * X4 + 2 * H2 * H4 * X4^2 + H2 * X4 * Y1 + H2 * X4 * Y2 + H2 * X4 * Y3 + H2 * X4 * Y4 - 3 * H3^3 - 10 * H3^2 * H4 * X4 - H3^2 * Y1 - H3^2 * Y2 - H3^2 * Y3 - 11 * H3^2 * Y4 + H3 * H4^2 * X1 * X2 + H3 * H4^2 * X1 * X3 - 3 * H3 * H4^2 * X1 * X4 + H3 * H4^2 * X2 * X3 - 3 * H3 * H4^2 * X2 * X4 - 3 * H3 * H4^2 * X3 * X4 - 5 * H3 * H4^2 * X4^2 + 2 * H3 * H4 * X2 * Y1 - 2 * H3 * H4 * X2 * Y4 + 2 * H3 * H4 * X3 * Y1 + 2 * H3 * H4 * X3 * Y2 - 4 * H3 * H4 * X3 * Y4 - 8 * H3 * H4 * X4 * Y1 - 6 * H3 * H4 * X4 * Y2 - 4 * H3 * H4 * X4 * Y3 - 12 * H3 * H4 * X4 * Y4 + H3 * Y1 * Y2 + H3 * Y1 * Y3 - 4 * H3 * Y1 * Y4 + H3 * Y2 * Y3 - 4 * H3 * Y2 * Y4 - 4 * H3 * Y3 * Y4 - 11 * H3 * Y4^2 + H4^3 * X1 * X2 * X3 - H4^3 * X1 * X2 * X4 - H4^3 * X1 * X3 * X4 - H4^3 * X2 * X4^2 - H4^3 * X3 * X4^2 - H4^3 * X4^3 + H4^2 * X1 * X2 * Y1 - H4^2 * X1 * X2 * Y2 + H4^2 * X1 * X2 * Y3 + H4^2 * X1 * X2 * Y4 + H4^2 * X1 * X3 * Y1 + H4^2 * X1 * X3 * Y2 - H4^2 * X1 * X3 * Y3 + H4^2 * X1 * X3 * Y4 - 3 * H4^2 * X1 * X4 * Y1 - H4^2 * X1 * X4 * Y2 - H4^2 * X1 * X4 * Y3 - H4^2 * X1 * X4 * Y4 + H4^2 * X2 * X3 * Y1 + H4^2 * X2 * X3 * Y2 - H4^2 * X2 * X3 * Y3 - H4^2 * X2 * X3 * Y4 - H4^2 * X2 * X4 * Y1 - H4^2 * X2 * X4 * Y2 - 2 * H4^2 * X2 * X4 * Y4 - H4^2 * X3 * X4 * Y1 + H4^2 * X3 * X4 * Y3 - 4 * H4^2 * X3 * X4 * Y4 - H4^2 * X4^2 * Y1 - 2 * H4^2 * X4^2 * Y2 - 2 * H4^2 * X4^2 * Y3 - H4^2 * X4^2 * Y4 - H4 * X1 * Y2^2 + H4 * X1 * Y2 * Y3 + H4 * X1 * Y2 * Y4 - H4 * X1 * Y3^2 + H4 * X1 * Y3 * Y4 - H4 * X1 * Y4^2 + H4 * X2 * Y1^2 + H4 * X2 * Y1 * Y3 + H4 * X2 * Y1 * Y4 - H4 * X2 * Y3^2 - H4 * X2 * Y3 * Y4 - H4 * X2 * Y4^2 + H4 * X3 * Y1^2 + H4 * X3 * Y1 * Y2 + H4 * X3 * Y1 * Y4 + H4 * X3 * Y2^2 - H4 * X3 * Y2 * Y4 - 3 * H4 * X3 * Y4^2 - 3 * H4 * X4 * Y1^2 - H4 * X4 * Y1 * Y2 - H4 * X4 * Y1 * Y3 - 5 * H4 * X4 * Y1 * Y4 - H4 * X4 * Y2^2 - H4 * X4 * Y2 * Y3 - 3 * H4 * X4 * Y2 * Y4 + H4 * X4 * Y3^2 - 3 * H4 * X4 * Y3 * Y4 - 3 * H4 * X4 * Y4^2 + Y1 * Y2 * Y3 + Y1 * Y2 * Y4 + Y1 * Y3 * Y4 - 3 * Y1 * Y4^2 + Y2 * Y3 * Y4 - 3 * Y2 * Y4^2 - 3 * Y3 * Y4^2 - 3 * Y4^3, E3 * H2 * Y1 - E3 * H2 * Y4 - E3 * H3 * H4 * Y1 + E3 * H3 * H4 * Y4 - E3 * H4^2 * X4 * Y1 + E3 * H4^2 * X4 * Y4 - E3 * H4 * Y1 * Y4 + E3 * H4 * Y4^2 + E4 * H3^2 * Y1 - E4 * H3^2 * Y4 + E4 * H3 * H4 * X4 * Y1 - E4 * H3 * H4 * X4 * Y4 + 4 * E4 * H3 * Y1 * Y4 - 4 * E4 * H3 * Y4^2 - E4 * H4 * X1 * Y1^2 + 2 * E4 * H4 * X1 * Y1 * Y4 + E4 * H4 * X1 * Y2 * Y3 - E4 * H4 * X1 * Y2 * Y4 - E4 * H4 * X1 * Y3 * Y4 + E4 * H4 * X4 * Y1^2 - 2 * E4 * H4 * X4 * Y2 * Y3 + 2 * E4 * H4 * X4 * Y2 * Y4 + 2 * E4 * H4 * X4 * Y3 * Y4 - 3 * E4 * H4 * X4 * Y4^2 - E4 * Y1^3 + 3 * E4 * Y1^2 * Y4 + E4 * Y1 * Y4^2 - 3 * E4 * Y4^3 + H3^2 * X1 - H3^2 * X4 - H3 * H4 * X1^2 + 5 * H3 * H4 * X1 * X4 - 4 * H3 * H4 * X4^2 - H3 * X1 * Y1 + 5 * H3 * X1 * Y4 + 3 * H3 * X4 * Y1 - 7 * H3 * X4 * Y4 - H4^2 * X1^2 * X2 - H4^2 * X1^2 * X3 + H4^2 * X1^2 * X4 + 3 * H4^2 * X1 * X2 * X4 + 3 * H4^2 * X1 * X3 * X4 - 2 * H4^2 * X1 * X4^2 - H4^2 * X2 * X3 * X4 - H4^2 * X2 * X4^2 - H4^2 * X3 * X4^2 - H4 * X1^2 * Y1 - H4 * X1^2 * Y2 - H4 * X1^2 * Y3 + H4 * X1^2 * Y4 - H4 * X1 * X2 * Y1 + H4 * X1 * X2 * Y4 - H4 * X1 * X3 * Y1 + H4 * X1 * X3 * Y4 + 4 * H4 * X1 * X4 * Y1 + 3 * H4 * X1 * X4 * Y2 + 3 * H4 * X1 * X4 * Y3 + 2 * H4 * X2 * X4 * Y1 - H4 * X2 * X4 * Y3 - H4 * X2 * X4 * Y4 + 2 * H4 * X3 * X4 * Y1 - H4 * X3 * X4 * Y2 - H4 * X3 * X4 * Y4 - 3 * H4 * X4^2 * Y1 - H4 * X4^2 * Y2 - H4 * X4^2 * Y3 - 3 * H4 * X4^2 * Y4 - X1 * Y1^2 - X1 * Y1 * Y2 - X1 * Y1 * Y3 + 2 * X1 * Y1 * Y4 - X1 * Y2 * Y3 + 2 * X1 * Y2 * Y4 + 2 * X1 * Y3 * Y4 + 2 * X1 * Y4^2 + 2 * X4 * Y1^2 + 2 * X4 * Y1 * Y2 + 2 * X4 * Y1 * Y3 - 2 * X4 * Y1 * Y4 + X4 * Y2 * Y3 - 3 * X4 * Y2 * Y4 - 3 * X4 * Y3 * Y4 - 3 * X4 * Y4^2, E3 * H2 * Y2 - E3 * H2 * Y4 - E3 * H3 * H4 * Y2 + E3 * H3 * H4 * Y4 - E3 * H4^2 * X4 * Y2 + E3 * H4^2 * X4 * Y4 - E3 * H4 * Y2 * Y4 + E3 * H4 * Y4^2 + E4 * H3^2 * Y2 - E4 * H3^2 * Y4 + E4 * H3 * H4 * X4 * Y2 - E4 * H3 * H4 * X4 * Y4 + 4 * E4 * H3 * Y2 * Y4 - 4 * E4 * H3 * Y4^2 - E4 * H4 * X2 * Y2^2 + E4 * H4 * X2 * Y2 * Y3 + E4 * H4 * X2 * Y2 * Y4 - E4 * H4 * X2 * Y3 * Y4 + E4 * H4 * X4 * Y2^2 - 2 * E4 * H4 * X4 * Y2 * Y3 + 2 * E4 * H4 * X4 * Y2 * Y4 + 2 * E4 * H4 * X4 * Y3 * Y4 - 3 * E4 * H4 * X4 * Y4^2 - E4 * Y2^3 + 3 * E4 * Y2^2 * Y4 + E4 * Y2 * Y4^2 - 3 * E4 * Y4^3 + H3^2 * X2 - H3^2 * X4 - H3 * H4 * X2^2 + 5 * H3 * H4 * X2 * X4 - 4 * H3 * H4 * X4^2 - H3 * X2 * Y2 + 5 * H3 * X2 * Y4 + 3 * H3 * X4 * Y2 - 7 * H3 * X4 * Y4 - H4^2 * X1 * X2^2 - H4^2 * X1 * X2 * X3 + 4 * H4^2 * X1 * X2 * X4 + H4^2 * X1 * X3 * X4 - 3 * H4^2 * X1 * X4^2 + H4^2 * X2 * X3 * X4 - H4^2 * X3 * X4^2 - H4 * X1 * X2 * Y2 - H4 * X1 * X2 * Y3 + 2 * H4 * X1 * X2 * Y4 + 2 * H4 * X1 * X4 * Y2 + H4 * X1 * X4 * Y3 - 3 * H4 * X1 * X4 * Y4 - H4 * X2^2 * Y1 - H4 * X2^2 * Y2 - H4 * X2 * X3 * Y1 + H4 * X2 * X3 * Y4 + 4 * H4 * X2 * X4 * Y1 + 3 * H4 * X2 * X4 * Y2 + H4 * X2 * X4 * Y3 + 2 * H4 * X2 * X4 * Y4 + H4 * X3 * X4 * Y1 - H4 * X3 * X4 * Y4 - 3 * H4 * X4^2 * Y1 - H4 * X4^2 * Y2 - H4 * X4^2 * Y3 - 3 * H4 * X4^2 * Y4 - X2 * Y1 * Y2 - X2 * Y1 * Y3 + 2 * X2 * Y1 * Y4 - X2 * Y2^2 - X2 * Y2 * Y3 + 2 * X2 * Y2 * Y4 + 2 * X2 * Y3 * Y4 + 2 * X2 * Y4^2 + 2 * X4 * Y1 * Y2 + X4 * Y1 * Y3 - 3 * X4 * Y1 * Y4 + 2 * X4 * Y2^2 + 2 * X4 * Y2 * Y3 - 2 * X4 * Y2 * Y4 - 3 * X4 * Y3 * Y4 - 3 * X4 * Y4^2, E3 * H2 * Y3 - E3 * H2 * Y4 - E3 * H3 * H4 * Y3 + E3 * H3 * H4 * Y4 - E3 * H4^2 * X4 * Y3 + E3 * H4^2 * X4 * Y4 - E3 * H4 * Y3 * Y4 + E3 * H4 * Y4^2 + E4 * H3^2 * Y3 - E4 * H3^2 * Y4 + E4 * H3 * H4 * X4 * Y3 - E4 * H3 * H4 * X4 * Y4 + 4 * E4 * H3 * Y3 * Y4 - 4 * E4 * H3 * Y4^2 + E4 * H4 * X3 * Y2 * Y3 - E4 * H4 * X3 * Y2 * Y4 - E4 * H4 * X3 * Y3^2 + E4 * H4 * X3 * Y3 * Y4 - 2 * E4 * H4 * X4 * Y2 * Y3 + 2 * E4 * H4 * X4 * Y2 * Y4 + E4 * H4 * X4 * Y3^2 + 2 * E4 * H4 * X4 * Y3 * Y4 - 3 * E4 * H4 * X4 * Y4^2 - E4 * Y3^3 + 3 * E4 * Y3^2 * Y4 + E4 * Y3 * Y4^2 - 3 * E4 * Y4^3 + H3^2 * X3 - H3^2 * X4 - H3 * H4 * X3^2 + 5 * H3 * H4 * X3 * X4 - 4 * H3 * H4 * X4^2 - H3 * X3 * Y3 + 5 * H3 * X3 * Y4 + 3 * H3 * X4 * Y3 - 7 * H3 * X4 * Y4 - H4^2 * X1 * X2 * X3 + H4^2 * X1 * X2 * X4 - H4^2 * X1 * X3^2 + 4 * H4^2 * X1 * X3 * X4 - 3 * H4^2 * X1 * X4^2 + H4^2 * X2 * X3 * X4 - H4^2 * X2 * X4^2 - H4 * X1 * X3 * Y2 - H4 * X1 * X3 * Y3 + 2 * H4 * X1 * X3 * Y4 + H4 * X1 * X4 * Y2 + 2 * H4 * X1 * X4 * Y3 - 3 * H4 * X1 * X4 * Y4 - H4 * X2 * X3 * Y1 + H4 * X2 * X3 * Y4 + H4 * X2 * X4 * Y1 - H4 * X2 * X4 * Y4 - H4 * X3^2 * Y1 - H4 * X3^2 * Y3 + 4 * H4 * X3 * X4 * Y1 + H4 * X3 * X4 * Y2 + 3 * H4 * X3 * X4 * Y3 + 2 * H4 * X3 * X4 * Y4 - 3 * H4 * X4^2 * Y1 - H4 * X4^2 * Y2 - H4 * X4^2 * Y3 - 3 * H4 * X4^2 * Y4 - X3 * Y1 * Y2 - X3 * Y1 * Y3 + 2 * X3 * Y1 * Y4 - X3 * Y2 * Y3 + 2 * X3 * Y2 * Y4 - X3 * Y3^2 + 2 * X3 * Y3 * Y4 + 2 * X3 * Y4^2 + X4 * Y1 * Y2 + 2 * X4 * Y1 * Y3 - 3 * X4 * Y1 * Y4 + 2 * X4 * Y2 * Y3 - 3 * X4 * Y2 * Y4 + 2 * X4 * Y3^2 - 2 * X4 * Y3 * Y4 - 3 * X4 * Y4^2, E3 * H4 * X1 * Y1 - E3 * H4 * X1 * Y4 - E3 * H4 * X4 * Y1 + E3 * H4 * X4 * Y4 + E3 * Y1^2 - 2 * E3 * Y1 * Y4 + E3 * Y4^2 - E4 * H3 * X1 * Y1 + E4 * H3 * X1 * Y4 + E4 * H3 * X4 * Y1 - E4 * H3 * X4 * Y4 - 2 * E4 * X1 * Y1 * Y4 - E4 * X1 * Y2 * Y3 + E4 * X1 * Y2 * Y4 + E4 * X1 * Y3 * Y4 + E4 * X1 * Y4^2 + E4 * X4 * Y1^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X1^2 + 2 * H3 * X1 * X4 - H3 * X4^2 - H4 * X1^2 * X4 - H4 * X1 * X2 * X3 + H4 * X1 * X2 * X4 + H4 * X1 * X3 * X4 + H4 * X1 * X4^2 + H4 * X2 * X3 * X4 - H4 * X2 * X4^2 - H4 * X3 * X4^2 - 2 * X1^2 * Y4 - X1 * X2 * Y3 + X1 * X2 * Y4 - X1 * X3 * Y2 + X1 * X3 * Y4 + X1 * X4 * Y2 + X1 * X4 * Y3 + 2 * X1 * X4 * Y4 + X2 * X4 * Y3 - X2 * X4 * Y4 + X3 * X4 * Y2 - X3 * X4 * Y4 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X2 * Y1 - E3 * H4 * X2 * Y4 - E3 * H4 * X4 * Y1 + E3 * H4 * X4 * Y4 + E3 * Y1 * Y2 - E3 * Y1 * Y4 - E3 * Y2 * Y4 + E3 * Y4^2 - E4 * H3 * X2 * Y1 + E4 * H3 * X2 * Y4 + E4 * H3 * X4 * Y1 - E4 * H3 * X4 * Y4 - E4 * X2 * Y1^2 + E4 * X2 * Y4^2 + E4 * X4 * Y1^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X1 * X2 + H3 * X1 * X4 + H3 * X2 * X4 - H3 * X4^2 - H4 * X1 * X2^2 + H4 * X1 * X4^2 + H4 * X2^2 * X4 + H4 * X2 * X3 * X4 - H4 * X2 * X4^2 - H4 * X3 * X4^2 - X1 * X2 * Y1 - X1 * X2 * Y2 + X1 * X4 * Y1 + X1 * X4 * Y4 + X2 * X4 * Y2 + X2 * X4 * Y3 + X3 * X4 * Y2 - X3 * X4 * Y4 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X2 * Y2 - E3 * H4 * X2 * Y4 - E3 * H4 * X4 * Y2 + E3 * H4 * X4 * Y4 + E3 * Y2^2 - 2 * E3 * Y2 * Y4 + E3 * Y4^2 - E4 * H3 * X2 * Y2 + E4 * H3 * X2 * Y4 + E4 * H3 * X4 * Y2 - E4 * H3 * X4 * Y4 - E4 * X2 * Y2 * Y3 - E4 * X2 * Y2 * Y4 + E4 * X2 * Y3 * Y4 + E4 * X2 * Y4^2 + E4 * X4 * Y2^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X2^2 + 2 * H3 * X2 * X4 - H3 * X4^2 - H4 * X2^2 * X3 + 2 * H4 * X2 * X3 * X4 - H4 * X3 * X4^2 - X2^2 * Y3 - X2^2 * Y4 - X2 * X3 * Y2 + X2 * X3 * Y4 + X2 * X4 * Y2 + 2 * X2 * X4 * Y3 + X2 * X4 * Y4 + X3 * X4 * Y2 - X3 * X4 * Y4 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X3 * Y1 - E3 * H4 * X3 * Y4 - E3 * H4 * X4 * Y1 + E3 * H4 * X4 * Y4 + E3 * Y1 * Y3 - E3 * Y1 * Y4 - E3 * Y3 * Y4 + E3 * Y4^2 - E4 * H3 * X3 * Y1 + E4 * H3 * X3 * Y4 + E4 * H3 * X4 * Y1 - E4 * H3 * X4 * Y4 - E4 * X3 * Y1^2 + E4 * X3 * Y4^2 + E4 * X4 * Y1^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X1 * X3 + H3 * X1 * X4 + H3 * X3 * X4 - H3 * X4^2 - H4 * X1 * X3^2 + H4 * X1 * X4^2 + H4 * X2 * X3 * X4 - H4 * X2 * X4^2 + H4 * X3^2 * X4 - H4 * X3 * X4^2 - X1 * X3 * Y1 - X1 * X3 * Y3 + X1 * X4 * Y1 + X1 * X4 * Y4 + X2 * X4 * Y3 - X2 * X4 * Y4 + X3 * X4 * Y2 + X3 * X4 * Y3 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X3 * Y2 - E3 * H4 * X3 * Y4 - E3 * H4 * X4 * Y2 + E3 * H4 * X4 * Y4 + E3 * Y2 * Y3 - E3 * Y2 * Y4 - E3 * Y3 * Y4 + E3 * Y4^2 - E4 * H3 * X3 * Y2 + E4 * H3 * X3 * Y4 + E4 * H3 * X4 * Y2 - E4 * H3 * X4 * Y4 - E4 * X3 * Y2^2 + E4 * X3 * Y4^2 + E4 * X4 * Y2^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X2 * X3 + H3 * X2 * X4 + H3 * X3 * X4 - H3 * X4^2 - H4 * X2 * X3^2 + H4 * X2 * X3 * X4 + H4 * X3^2 * X4 - H4 * X3 * X4^2 - X2 * X3 * Y2 - X2 * X3 * Y3 + X2 * X4 * Y2 + X2 * X4 * Y3 + X3 * X4 * Y2 + X3 * X4 * Y3 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X3 * Y3 - E3 * H4 * X3 * Y4 - E3 * H4 * X4 * Y3 + E3 * H4 * X4 * Y4 + E3 * Y3^2 - 2 * E3 * Y3 * Y4 + E3 * Y4^2 - E4 * H3 * X3 * Y3 + E4 * H3 * X3 * Y4 + E4 * H3 * X4 * Y3 - E4 * H3 * X4 * Y4 - E4 * X3 * Y2 * Y3 + E4 * X3 * Y2 * Y4 - E4 * X3 * Y3 * Y4 + E4 * X3 * Y4^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 + E4 * X4 * Y3^2 - E4 * X4 * Y3 * Y4 - H3 * X3^2 + 2 * H3 * X3 * X4 - H3 * X4^2 - H4 * X2 * X3^2 + 2 * H4 * X2 * X3 * X4 - H4 * X2 * X4^2 - X2 * X3 * Y3 + X2 * X3 * Y4 + X2 * X4 * Y3 - X2 * X4 * Y4 - X3^2 * Y2 - X3^2 * Y4 + 2 * X3 * X4 * Y2 + X3 * X4 * Y3 + X3 * X4 * Y4 - X4^2 * Y2 - X4^2 * Y3, E4 * H2 * Y1 - E4 * H2 * Y4 + E4 * H4 * Y1 * Y4 + E4 * H4 * Y2 * Y3 - E4 * H4 * Y2 * Y4 - E4 * H4 * Y3 * Y4 - H3 * H4 * X1 + H3 * H4 * X4 - 2 * H3 * Y1 + 2 * H3 * Y4 - H4^2 * X1 * X2 - H4^2 * X1 * X3 + H4^2 * X1 * X4 + H4^2 * X2 * X3 - H4 * X1 * Y1 - H4 * X1 * Y2 - H4 * X1 * Y3 + H4 * X1 * Y4 - H4 * X2 * Y1 + H4 * X2 * Y3 - H4 * X3 * Y1 + H4 * X3 * Y2 + H4 * X4 * Y1 + H4 * X4 * Y4 - Y1^2 - Y1 * Y2 - Y1 * Y3 + Y2 * Y4 + Y3 * Y4 + Y4^2, H1 + H2 * X4 + H3 * Y4 + H4 * X4 * Y4 + Y4^2, H2 * X3 - H2 * X4 + H3 * Y3 - H3 * Y4 + H4 * X3 * Y3 - H4 * X4 * Y4 + Y3^2 - Y4^2, H2 * X2 - H2 * X4 + H3 * Y2 - H3 * Y4 + H4 * X2 * Y2 - H4 * X4 * Y4 + Y2^2 - Y4^2, H2 * X1 - H2 * X4 + H3 * Y1 - H3 * Y4 + H4 * X1 * Y1 - H4 * X4 * Y4 + Y1^2 - Y4^2, H3 * X2 * Y3 - H3 * X2 * Y4 - H3 * X3 * Y2 + H3 * X3 * Y4 + H3 * X4 * Y2 - H3 * X4 * Y3 - H4 * X2 * X3 * Y2 + H4 * X2 * X3 * Y3 + H4 * X2 * X4 * Y2 - H4 * X2 * X4 * Y4 - H4 * X3 * X4 * Y3 + H4 * X3 * X4 * Y4 + X2 * Y3^2 - X2 * Y4^2 - X3 * Y2^2 + X3 * Y4^2 + X4 * Y2^2 - X4 * Y3^2, H3 * X1 * Y3 - H3 * X1 * Y4 - H3 * X3 * Y1 + H3 * X3 * Y4 + H3 * X4 * Y1 - H3 * X4 * Y3 - H4 * X1 * X3 * Y1 + H4 * X1 * X3 * Y3 + H4 * X1 * X4 * Y1 - H4 * X1 * X4 * Y4 - H4 * X3 * X4 * Y3 + H4 * X3 * X4 * Y4 + X1 * Y3^2 - X1 * Y4^2 - X3 * Y1^2 + X3 * Y4^2 + X4 * Y1^2 - X4 * Y3^2, H3 * X1 * Y2 - H3 * X1 * Y4 - H3 * X2 * Y1 + H3 * X2 * Y4 + H3 * X4 * Y1 - H3 * X4 * Y2 - H4 * X1 * X2 * Y1 + H4 * X1 * X2 * Y2 + H4 * X1 * X4 * Y1 - H4 * X1 * X4 * Y4 - H4 * X2 * X4 * Y2 + H4 * X2 * X4 * Y4 + X1 * Y2^2 - X1 * Y4^2 - X2 * Y1^2 + X2 * Y4^2 + X4 * Y1^2 - X4 * Y2^2, E3 * X2 * Y3 - E3 * X2 * Y4 - E3 * X3 * Y2 + E3 * X3 * Y4 + E3 * X4 * Y2 - E3 * X4 * Y3 - E4 * X2 * X3 * Y2 + E4 * X2 * X3 * Y3 + E4 * X2 * X4 * Y2 - E4 * X2 * X4 * Y4 - E4 * X3 * X4 * Y3 + E4 * X3 * X4 * Y4 - X2^2 * X3 + X2^2 * X4 + X2 * X3^2 - X2 * X4^2 - X3^2 * X4 + X3 * X4^2, E3 * X1 * Y3 - E3 * X1 * Y4 - E3 * X3 * Y1 + E3 * X3 * Y4 + E3 * X4 * Y1 - E3 * X4 * Y3 - E4 * X1 * X3 * Y1 + E4 * X1 * X3 * Y3 + E4 * X1 * X4 * Y1 - E4 * X1 * X4 * Y4 - E4 * X3 * X4 * Y3 + E4 * X3 * X4 * Y4 - X1^2 * X3 + X1^2 * X4 + X1 * X3^2 - X1 * X4^2 - X3^2 * X4 + X3 * X4^2, E3 * X1 * Y2 - E3 * X1 * Y4 - E3 * X2 * Y1 + E3 * X2 * Y4 + E3 * X4 * Y1 - E3 * X4 * Y2 - E4 * X1 * X2 * Y1 + E4 * X1 * X2 * Y2 + E4 * X1 * X4 * Y1 - E4 * X1 * X4 * Y4 - E4 * X2 * X4 * Y2 + E4 * X2 * X4 * Y4 - X1^2 * X2 + X1^2 * X4 + X1 * X2^2 - X1 * X4^2 - X2^2 * X4 + X2 * X4^2, H4 * X1 * X2 * Y1 * Y3 - H4 * X1 * X2 * Y1 * Y4 - H4 * X1 * X2 * Y2 * Y3 + H4 * X1 * X2 * Y2 * Y4 - H4 * X1 * X3 * Y1 * Y2 + H4 * X1 * X3 * Y1 * Y4 + H4 * X1 * X3 * Y2 * Y3 - H4 * X1 * X3 * Y3 * Y4 + H4 * X1 * X4 * Y1 * Y2 - H4 * X1 * X4 * Y1 * Y3 - H4 * X1 * X4 * Y2 * Y4 + H4 * X1 * X4 * Y3 * Y4 + H4 * X2 * X3 * Y1 * Y2 - H4 * X2 * X3 * Y1 * Y3 - H4 * X2 * X3 * Y2 * Y4 + H4 * X2 * X3 * Y3 * Y4 - H4 * X2 * X4 * Y1 * Y2 + H4 * X2 * X4 * Y1 * Y4 + H4 * X2 * X4 * Y2 * Y3 - H4 * X2 * X4 * Y3 * Y4 + H4 * X3 * X4 * Y1 * Y3 - H4 * X3 * X4 * Y1 * Y4 - H4 * X3 * X4 * Y2 * Y3 + H4 * X3 * X4 * Y2 * Y4 - X1 * Y2^2 * Y3 + X1 * Y2^2 * Y4 + X1 * Y2 * Y3^2 - X1 * Y2 * Y4^2 - X1 * Y3^2 * Y4 + X1 * Y3 * Y4^2 + X2 * Y1^2 * Y3 - X2 * Y1^2 * Y4 - X2 * Y1 * Y3^2 + X2 * Y1 * Y4^2 + X2 * Y3^2 * Y4 - X2 * Y3 * Y4^2 - X3 * Y1^2 * Y2 + X3 * Y1^2 * Y4 + X3 * Y1 * Y2^2 - X3 * Y1 * Y4^2 - X3 * Y2^2 * Y4 + X3 * Y2 * Y4^2 + X4 * Y1^2 * Y2 - X4 * Y1^2 * Y3 - X4 * Y1 * Y2^2 + X4 * Y1 * Y3^2 + X4 * Y2^2 * Y3 - X4 * Y2 * Y3^2, E4 * Y2^2 * Y3 - E4 * Y2^2 * Y4 - E4 * Y2 * Y3^2 + E4 * Y2 * Y4^2 + E4 * Y3^2 * Y4 - E4 * Y3 * Y4^2 + H4 * X1 * X2 * Y3 - H4 * X1 * X2 * Y4 - H4 * X1 * X3 * Y2 + H4 * X1 * X3 * Y4 + H4 * X1 * X4 * Y2 - H4 * X1 * X4 * Y3 + H4 * X2 * X3 * Y2 - H4 * X2 * X3 * Y3 - H4 * X2 * X4 * Y2 + H4 * X2 * X4 * Y4 + H4 * X3 * X4 * Y3 - H4 * X3 * X4 * Y4 + X2 * Y1 * Y3 - X2 * Y1 * Y4 + X2 * Y2 * Y3 - X2 * Y2 * Y4 - X2 * Y3^2 + X2 * Y4^2 - X3 * Y1 * Y2 + X3 * Y1 * Y4 + X3 * Y2^2 - X3 * Y2 * Y3 + X3 * Y3 * Y4 - X3 * Y4^2 + X4 * Y1 * Y2 - X4 * Y1 * Y3 - X4 * Y2^2 + X4 * Y2 * Y4 + X4 * Y3^2 - X4 * Y3 * Y4, E4 * H3 * Y2 * Y3 - E4 * H3 * Y2 * Y4 - E4 * H3 * Y3 * Y4 + E4 * H3 * Y4^2 + E4 * H4 * X4 * Y2 * Y3 - E4 * H4 * X4 * Y2 * Y4 - E4 * H4 * X4 * Y3 * Y4 + E4 * H4 * X4 * Y4^2 + E4 * Y2 * Y3^2 - E4 * Y2 * Y4^2 - E4 * Y3^2 * Y4 + E4 * Y4^3 + H3 * H4 * X2 * X3 - H3 * H4 * X2 * X4 - H3 * H4 * X3 * X4 + H3 * H4 * X4^2 + 2 * H3 * X3 * Y2 - 2 * H3 * X3 * Y4 - 2 * H3 * X4 * Y2 + 2 * H3 * X4 * Y4 + H4^2 * X1 * X2 * X3 - H4^2 * X1 * X2 * X4 - H4^2 * X1 * X3 * X4 + H4^2 * X1 * X4^2 + H4 * X1 * X3 * Y2 - H4 * X1 * X3 * Y4 - H4 * X1 * X4 * Y2 + H4 * X1 * X4 * Y4 + H4 * X2 * X3 * Y1 + H4 * X2 * X3 * Y2 - H4 * X2 * X4 * Y1 - H4 * X2 * X4 * Y2 - H4 * X3 * X4 * Y1 - H4 * X3 * X4 * Y4 + H4 * X4^2 * Y1 + H4 * X4^2 * Y4 + X3 * Y1 * Y2 - X3 * Y1 * Y4 + X3 * Y2^2 + X3 * Y2 * Y3 - X3 * Y3 * Y4 - X3 * Y4^2 - X4 * Y1 * Y2 + X4 * Y1 * Y4 - X4 * Y2^2 - X4 * Y2 * Y3 + X4 * Y3 * Y4 + X4 * Y4^2, E3 * E4 * Y2 * Y3 - E3 * E4 * Y2 * Y4 - E3 * E4 * Y3 * Y4 + E3 * E4 * Y4^2 + E3 * H4 * X2 * X3 - E3 * H4 * X2 * X4 - E3 * H4 * X3 * X4 + E3 * H4 * X4^2 + 2 * E3 * X3 * Y2 - 2 * E3 * X3 * Y4 - 2 * E3 * X4 * Y2 + 2 * E3 * X4 * Y4 + E4^2 * X4 * Y2 * Y3 - E4^2 * X4 * Y2 * Y4 - E4^2 * X4 * Y3 * Y4 + E4^2 * X4 * Y4^2 + E4 * H4 * X1 * X2 * X3 - E4 * H4 * X1 * X2 * X4 - E4 * H4 * X1 * X3 * X4 + E4 * H4 * X1 * X4^2 + E4 * X2 * X3 * Y2 - E4 * X2 * X3 * Y3 - E4 * X2 * X4 * Y2 + E4 * X2 * X4 * Y3 + E4 * X3 * X4 * Y2 + E4 * X3 * X4 * Y3 - 2 * E4 * X3 * X4 * Y4 - E4 * X4^2 * Y2 - E4 * X4^2 * Y3 + 2 * E4 * X4^2 * Y4 - X1 * X2 * X3 + X1 * X2 * X4 + X1 * X3 * X4 - X1 * X4^2 + X2^2 * X3 - X2^2 * X4 - X2 * X3^2 + X2 * X3 * X4 + X3^2 * X4 - 2 * X3 * X4^2 + X4^3, E4 * Y1 * Y3 - E4 * Y1 * Y4 - E4 * Y2 * Y3 + E4 * Y2 * Y4 + H4 * X1 * X3 - H4 * X1 * X4 - H4 * X2 * X3 + H4 * X2 * X4 + X1 * Y3 - X1 * Y4 - X2 * Y3 + X2 * Y4 + X3 * Y1 - X3 * Y2 - X4 * Y1 + X4 * Y2, E4 * H2 * Y3 - E4 * H2 * Y4 + E4 * H4 * Y2 * Y3 - E4 * H4 * Y2 * Y4 - H3 * H4 * X3 + H3 * H4 * X4 - 2 * H3 * Y3 + 2 * H3 * Y4 - H4^2 * X1 * X3 + H4^2 * X1 * X4 - H4 * X1 * Y3 + H4 * X1 * Y4 - H4 * X3 * Y1 - H4 * X3 * Y3 + H4 * X4 * Y1 + H4 * X4 * Y4 - Y1 * Y3 + Y1 * Y4 - Y2 * Y3 + Y2 * Y4 - Y3^2 + Y4^2, E3 * E4 * H4 * Y3 - E3 * E4 * H4 * Y4 - E3 * H4 * X3 + E3 * H4 * X4 - 2 * E3 * Y3 + 2 * E3 * Y4 - E4^2 * H3 * Y3 + E4^2 * H3 * Y4 - E4^2 * Y3^2 + E4^2 * Y4^2 - E4 * H3 * X3 + E4 * H3 * X4 - E4 * H4 * X1 * X3 + E4 * H4 * X1 * X4 - E4 * H4 * X2 * X3 + E4 * H4 * X2 * X4 - 2 * E4 * X3 * Y3 + 2 * E4 * X4 * Y4 + X1 * X3 - X1 * X4 + X2 * X3 - X2 * X4 - X3^2 + X4^2, E3 * H4^2 * X3 - E3 * H4^2 * X4 + E3 * H4 * Y3 - E3 * H4 * Y4 - E4 * H3 * H4 * X3 + E4 * H3 * H4 * X4 + E4 * H3 * Y3 - E4 * H3 * Y4 - E4 * H4 * X3 * Y1 - E4 * H4 * X3 * Y2 + E4 * H4 * X3 * Y3 - E4 * H4 * X3 * Y4 + E4 * H4 * X4 * Y1 + E4 * H4 * X4 * Y2 + E4 * H4 * X4 * Y3 - E4 * H4 * X4 * Y4 + E4 * Y3^2 - E4 * Y4^2 + 2 * H3 * X3 - 2 * H3 * X4 + H4 * X3^2 - H4 * X4^2 + X3 * Y1 + X3 * Y2 + X3 * Y3 + X3 * Y4 - X4 * Y1 - X4 * Y2 - X4 * Y3 - X4 * Y4, E4 * H3 * Y3^2 - 2 * E4 * H3 * Y3 * Y4 + E4 * H3 * Y4^2 - E4 * H4 * X3 * Y2 * Y3 + E4 * H4 * X3 * Y2 * Y4 + E4 * H4 * X3 * Y3^2 - E4 * H4 * X3 * Y3 * Y4 + E4 * H4 * X4 * Y2 * Y3 - E4 * H4 * X4 * Y2 * Y4 - E4 * H4 * X4 * Y3 * Y4 + E4 * H4 * X4 * Y4^2 + E4 * Y3^3 - E4 * Y3^2 * Y4 - E4 * Y3 * Y4^2 + E4 * Y4^3 + H3 * H4 * X3^2 - 2 * H3 * H4 * X3 * X4 + H3 * H4 * X4^2 + 2 * H3 * X3 * Y3 - 2 * H3 * X3 * Y4 - 2 * H3 * X4 * Y3 + 2 * H3 * X4 * Y4 + H4^2 * X1 * X3^2 - 2 * H4^2 * X1 * X3 * X4 + H4^2 * X1 * X4^2 + H4 * X1 * X3 * Y3 - H4 * X1 * X3 * Y4 - H4 * X1 * X4 * Y3 + H4 * X1 * X4 * Y4 + H4 * X3^2 * Y1 + H4 * X3^2 * Y3 - 2 * H4 * X3 * X4 * Y1 - H4 * X3 * X4 * Y3 - H4 * X3 * X4 * Y4 + H4 * X4^2 * Y1 + H4 * X4^2 * Y4 + X3 * Y1 * Y3 - X3 * Y1 * Y4 + X3 * Y2 * Y3 - X3 * Y2 * Y4 + X3 * Y3^2 - X3 * Y4^2 - X4 * Y1 * Y3 + X4 * Y1 * Y4 - X4 * Y2 * Y3 + X4 * Y2 * Y4 - X4 * Y3^2 + X4 * Y4^2, E3 * E4 * Y3^2 - 2 * E3 * E4 * Y3 * Y4 + E3 * E4 * Y4^2 + E3 * H4 * X3^2 - 2 * E3 * H4 * X3 * X4 + E3 * H4 * X4^2 + 2 * E3 * X3 * Y3 - 2 * E3 * X3 * Y4 - 2 * E3 * X4 * Y3 + 2 * E3 * X4 * Y4 - E4^2 * X3 * Y2 * Y3 + E4^2 * X3 * Y2 * Y4 + E4^2 * X3 * Y3^2 - E4^2 * X3 * Y3 * Y4 + E4^2 * X4 * Y2 * Y3 - E4^2 * X4 * Y2 * Y4 - E4^2 * X4 * Y3 * Y4 + E4^2 * X4 * Y4^2 + E4 * H4 * X1 * X3^2 - 2 * E4 * H4 * X1 * X3 * X4 + E4 * H4 * X1 * X4^2 - E4 * X2 * X3 * Y3 + E4 * X2 * X3 * Y4 + E4 * X2 * X4 * Y3 - E4 * X2 * X4 * Y4 - E4 * X3^2 * Y2 + 2 * E4 * X3^2 * Y3 - E4 * X3^2 * Y4 + 2 * E4 * X3 * X4 * Y2 - E4 * X3 * X4 * Y3 - E4 * X3 * X4 * Y4 - E4 * X4^2 * Y2 - E4 * X4^2 * Y3 + 2 * E4 * X4^2 * Y4 - X1 * X3^2 + 2 * X1 * X3 * X4 - X1 * X4^2 - X2 * X3^2 + 2 * X2 * X3 * X4 - X2 * X4^2 + X3^3 - X3^2 * X4 - X3 * X4^2 + X4^3, E4 * Y1 * Y2 - E4 * Y1 * Y4 - E4 * Y2 * Y3 + E4 * Y3 * Y4 + H4 * X1 * X2 - H4 * X1 * X4 - H4 * X2 * X3 + H4 * X3 * X4 + X1 * Y2 - X1 * Y4 + X2 * Y1 - X2 * Y3 - X3 * Y2 + X3 * Y4 - X4 * Y1 + X4 * Y3, E4 * H2 * Y2 - E4 * H2 * Y4 + E4 * H4 * Y2 * Y3 - E4 * H4 * Y3 * Y4 - H3 * H4 * X2 + H3 * H4 * X4 - 2 * H3 * Y2 + 2 * H3 * Y4 - H4^2 * X1 * X2 + H4^2 * X1 * X4 - H4 * X1 * Y2 + H4 * X1 * Y4 - H4 * X2 * Y1 - H4 * X2 * Y2 + H4 * X4 * Y1 + H4 * X4 * Y4 - Y1 * Y2 + Y1 * Y4 - Y2^2 - Y2 * Y3 + Y3 * Y4 + Y4^2, E3 * H4^2 * X2 - E3 * H4^2 * X4 + E3 * H4 * Y2 - E3 * H4 * Y4 - E4 * H3 * H4 * X2 + E4 * H3 * H4 * X4 + E4 * H3 * Y2 - E4 * H3 * Y4 - E4 * H4 * X2 * Y1 + E4 * H4 * X2 * Y2 - E4 * H4 * X2 * Y3 - E4 * H4 * X2 * Y4 + E4 * H4 * X4 * Y1 + E4 * H4 * X4 * Y2 + E4 * H4 * X4 * Y3 - E4 * H4 * X4 * Y4 + E4 * Y2^2 - E4 * Y4^2 + 2 * H3 * X2 - 2 * H3 * X4 + H4 * X2^2 - H4 * X4^2 + X2 * Y1 + X2 * Y2 + X2 * Y3 + X2 * Y4 - X4 * Y1 - X4 * Y2 - X4 * Y3 - X4 * Y4, E3 * H4^2 * X1 - E3 * H4^2 * X4 + E3 * H4 * Y1 - E3 * H4 * Y4 - E4 * H3 * H4 * X1 + E4 * H3 * H4 * X4 + E4 * H3 * Y1 - E4 * H3 * Y4 + E4 * H4 * X1 * Y1 - E4 * H4 * X1 * Y2 - E4 * H4 * X1 * Y3 - E4 * H4 * X1 * Y4 + E4 * H4 * X4 * Y1 + E4 * H4 * X4 * Y2 + E4 * H4 * X4 * Y3 - E4 * H4 * X4 * Y4 + E4 * Y1^2 - E4 * Y4^2 + 2 * H3 * X1 - 2 * H3 * X4 + H4 * X1^2 - H4 * X4^2 + X1 * Y1 + X1 * Y2 + X1 * Y3 + X1 * Y4 - X4 * Y1 - X4 * Y2 - X4 * Y3 - X4 * Y4, E4 * H2^2 + 2 * E4 * H2 * H4 * Y4 - E4 * H4^2 * Y2 * Y3 + E4 * H4^2 * Y2 * Y4 + E4 * H4^2 * Y3 * Y4 - 2 * H2 * H3 - 2 * H2 * H4 * X4 - H2 * Y1 - H2 * Y2 - H2 * Y3 - H2 * Y4 + H3^2 * H4 + H3 * H4^2 * X1 + H3 * H4^2 * X2 + H3 * H4^2 * X3 - H3 * H4^2 * X4 + 2 * H3 * H4 * Y1 + 2 * H3 * H4 * Y2 + 2 * H3 * H4 * Y3 - 4 * H3 * H4 * Y4 + H4^3 * X1 * X2 + H4^3 * X1 * X3 - H4^3 * X1 * X4 + H4^2 * X1 * Y1 + H4^2 * X1 * Y2 + H4^2 * X1 * Y3 - H4^2 * X1 * Y4 + H4^2 * X2 * Y1 + H4^2 * X2 * Y2 + H4^2 * X3 * Y1 + H4^2 * X3 * Y3 - H4^2 * X4 * Y1 - 3 * H4^2 * X4 * Y4 + H4 * Y1^2 + H4 * Y1 * Y2 + H4 * Y1 * Y3 - H4 * Y1 * Y4 + H4 * Y2^2 + H4 * Y2 * Y3 - H4 * Y2 * Y4 + H4 * Y3^2 - H4 * Y3 * Y4 - 3 * H4 * Y4^2, E3 * H2 * H4 - E3 * H3 * H4^2 - E3 * H4^3 * X4 - E3 * H4^2 * Y4 + E4 * H2 * H3 + 2 * E4 * H2 * H4 * X4 + 2 * E4 * H2 * Y4 + E4 * H3^2 * H4 + E4 * H3 * H4^2 * X4 + E4 * H3 * H4 * Y1 + E4 * H3 * H4 * Y2 + E4 * H3 * H4 * Y3 + 2 * E4 * H3 * H4 * Y4 + E4 * H4^2 * X4 * Y1 + E4 * H4^2 * X4 * Y2 + E4 * H4^2 * X4 * Y3 + E4 * H4^2 * X4 * Y4 + 2 * E4 * H4 * Y1 * Y4 + E4 * H4 * Y2 * Y3 + E4 * H4 * Y2 * Y4 + E4 * H4 * Y3 * Y4 + E4 * H4 * Y4^2 - 2 * H3^2 - 4 * H3 * H4 * X4 - H3 * Y1 - H3 * Y2 - H3 * Y3 - 5 * H3 * Y4 + H4^2 * X2 * X3 - H4^2 * X2 * X4 - H4^2 * X3 * X4 - H4^2 * X4^2 + H4 * X2 * Y3 - H4 * X2 * Y4 + H4 * X3 * Y2 - H4 * X3 * Y4 - H4 * X4 * Y1 - 2 * H4 * X4 * Y2 - 2 * H4 * X4 * Y3 - 3 * H4 * X4 * Y4 - 2 * Y1 * Y4 - 2 * Y2 * Y4 - 2 * Y3 * Y4 - 2 * Y4^2, E3 * E4 * H4 * Y2 - E3 * E4 * H4 * Y4 - E3 * H4 * X2 + E3 * H4 * X4 - 2 * E3 * Y2 + 2 * E3 * Y4 - E4^2 * H3 * Y2 + E4^2 * H3 * Y4 - E4^2 * Y2^2 + E4^2 * Y4^2 - E4 * H3 * X2 + E4 * H3 * X4 - E4 * H4 * X1 * X2 + E4 * H4 * X1 * X4 - E4 * H4 * X2 * X3 + E4 * H4 * X3 * X4 - 2 * E4 * X2 * Y2 + 2 * E4 * X4 * Y4 + X1 * X2 - X1 * X4 - X2^2 + X2 * X3 - X3 * X4 + X4^2, E3 * E4 * H4 * Y1 - E3 * E4 * H4 * Y4 - E3 * H4 * X1 + E3 * H4 * X4 - 2 * E3 * Y1 + 2 * E3 * Y4 - E4^2 * H3 * Y1 + E4^2 * H3 * Y4 - E4^2 * Y1^2 + E4^2 * Y4^2 - E4 * H3 * X1 + E4 * H3 * X4 - E4 * H4 * X1 * X2 - E4 * H4 * X1 * X3 + E4 * H4 * X2 * X4 + E4 * H4 * X3 * X4 - 2 * E4 * X1 * Y1 + 2 * E4 * X4 * Y4 - X1^2 + X1 * X2 + X1 * X3 - X2 * X4 - X3 * X4 + X4^2, 2 * E2 - E3 * E4 * H4^2 - E3 * H4 + 2 * E4^2 * H2 + E4^2 * H3 * H4 + E4^2 * H4 * Y1 + E4^2 * H4 * Y2 + E4^2 * H4 * Y3 + E4^2 * H4 * Y4 - 3 * E4 * H3 - E4 * H4 * X1 - E4 * H4 * X2 - E4 * H4 * X3 - E4 * H4 * X4 - E4 * Y1 - E4 * Y2 - E4 * Y3 - E4 * Y4 + X1 + X2 + X3 + X4, E4 * H3 * Y2^2 - 2 * E4 * H3 * Y2 * Y4 + E4 * H3 * Y4^2 + E4 * H4 * X2 * Y2^2 - E4 * H4 * X2 * Y2 * Y3 - E4 * H4 * X2 * Y2 * Y4 + E4 * H4 * X2 * Y3 * Y4 + E4 * H4 * X4 * Y2 * Y3 - E4 * H4 * X4 * Y2 * Y4 - E4 * H4 * X4 * Y3 * Y4 + E4 * H4 * X4 * Y4^2 + E4 * Y2^3 - E4 * Y2^2 * Y4 - E4 * Y2 * Y4^2 + E4 * Y4^3 + H3 * H4 * X2^2 - 2 * H3 * H4 * X2 * X4 + H3 * H4 * X4^2 + 2 * H3 * X2 * Y2 - 2 * H3 * X2 * Y4 - 2 * H3 * X4 * Y2 + 2 * H3 * X4 * Y4 + H4^2 * X1 * X2^2 - 2 * H4^2 * X1 * X2 * X4 + H4^2 * X1 * X4^2 + H4 * X1 * X2 * Y2 - H4 * X1 * X2 * Y4 - H4 * X1 * X4 * Y2 + H4 * X1 * X4 * Y4 + H4 * X2^2 * Y1 + H4 * X2^2 * Y2 - 2 * H4 * X2 * X4 * Y1 - H4 * X2 * X4 * Y2 - H4 * X2 * X4 * Y4 + H4 * X4^2 * Y1 + H4 * X4^2 * Y4 + X2 * Y1 * Y2 - X2 * Y1 * Y4 + X2 * Y2^2 + X2 * Y2 * Y3 - X2 * Y3 * Y4 - X2 * Y4^2 - X4 * Y1 * Y2 + X4 * Y1 * Y4 - X4 * Y2^2 - X4 * Y2 * Y3 + X4 * Y3 * Y4 + X4 * Y4^2, E4 * H3 * Y1^2 - 2 * E4 * H3 * Y1 * Y4 + E4 * H3 * Y4^2 + E4 * H4 * X1 * Y1^2 - 2 * E4 * H4 * X1 * Y1 * Y4 - E4 * H4 * X1 * Y2 * Y3 + E4 * H4 * X1 * Y2 * Y4 + E4 * H4 * X1 * Y3 * Y4 + E4 * H4 * X4 * Y2 * Y3 - E4 * H4 * X4 * Y2 * Y4 - E4 * H4 * X4 * Y3 * Y4 + E4 * H4 * X4 * Y4^2 + E4 * Y1^3 - E4 * Y1^2 * Y4 - E4 * Y1 * Y4^2 + E4 * Y4^3 + H3 * H4 * X1^2 - 2 * H3 * H4 * X1 * X4 + H3 * H4 * X4^2 + 2 * H3 * X1 * Y1 - 2 * H3 * X1 * Y4 - 2 * H3 * X4 * Y1 + 2 * H3 * X4 * Y4 + H4^2 * X1^2 * X2 + H4^2 * X1^2 * X3 - H4^2 * X1^2 * X4 - H4^2 * X1 * X2 * X3 - H4^2 * X1 * X2 * X4 - H4^2 * X1 * X3 * X4 + H4^2 * X1 * X4^2 + H4^2 * X2 * X3 * X4 + H4 * X1^2 * Y1 + H4 * X1^2 * Y2 + H4 * X1^2 * Y3 - H4 * X1^2 * Y4 + H4 * X1 * X2 * Y1 - H4 * X1 * X2 * Y3 + H4 * X1 * X3 * Y1 - H4 * X1 * X3 * Y2 - 2 * H4 * X1 * X4 * Y1 - H4 * X1 * X4 * Y2 - H4 * X1 * X4 * Y3 - H4 * X2 * X4 * Y1 + H4 * X2 * X4 * Y3 - H4 * X3 * X4 * Y1 + H4 * X3 * X4 * Y2 + H4 * X4^2 * Y1 + H4 * X4^2 * Y4 + X1 * Y1^2 + X1 * Y1 * Y2 + X1 * Y1 * Y3 - X1 * Y2 * Y4 - X1 * Y3 * Y4 - X1 * Y4^2 - X4 * Y1^2 - X4 * Y1 * Y2 - X4 * Y1 * Y3 + X4 * Y2 * Y4 + X4 * Y3 * Y4 + X4 * Y4^2, E3 * E4 * H4^3 - E3 * H4^2 - 2 * E4^2 * H2 * H4 - E4^2 * H3 * H4^2 - E4^2 * H4^2 * Y1 - E4^2 * H4^2 * Y2 - E4^2 * H4^2 * Y3 - E4^2 * H4^2 * Y4 + 2 * E4 * H2 + 5 * E4 * H3 * H4 + E4 * H4^2 * X1 + E4 * H4^2 * X2 + E4 * H4^2 * X3 + E4 * H4^2 * X4 + 3 * E4 * H4 * Y1 + 3 * E4 * H4 * Y2 + 3 * E4 * H4 * Y3 + 3 * E4 * H4 * Y4 - 4 * H3 - H4 * X1 - H4 * X2 - H4 * X3 - H4 * X4 - 2 * Y1 - 2 * Y2 - 2 * Y3 - 2 * Y4, E3 * E4 * Y2^2 - 2 * E3 * E4 * Y2 * Y4 + E3 * E4 * Y4^2 + E3 * H4 * X2^2 - 2 * E3 * H4 * X2 * X4 + E3 * H4 * X4^2 + 2 * E3 * X2 * Y2 - 2 * E3 * X2 * Y4 - 2 * E3 * X4 * Y2 + 2 * E3 * X4 * Y4 + E4^2 * X2 * Y2^2 - E4^2 * X2 * Y2 * Y3 - E4^2 * X2 * Y2 * Y4 + E4^2 * X2 * Y3 * Y4 + E4^2 * X4 * Y2 * Y3 - E4^2 * X4 * Y2 * Y4 - E4^2 * X4 * Y3 * Y4 + E4^2 * X4 * Y4^2 + E4 * H4 * X1 * X2^2 - 2 * E4 * H4 * X1 * X2 * X4 + E4 * H4 * X1 * X4^2 + 2 * E4 * X2^2 * Y2 - E4 * X2^2 * Y3 - E4 * X2^2 * Y4 - E4 * X2 * X3 * Y2 + E4 * X2 * X3 * Y4 - E4 * X2 * X4 * Y2 + 2 * E4 * X2 * X4 * Y3 - E4 * X2 * X4 * Y4 + E4 * X3 * X4 * Y2 - E4 * X3 * X4 * Y4 - E4 * X4^2 * Y2 - E4 * X4^2 * Y3 + 2 * E4 * X4^2 * Y4 - X1 * X2^2 + 2 * X1 * X2 * X4 - X1 * X4^2 + X2^3 - X2^2 * X3 - X2^2 * X4 + 2 * X2 * X3 * X4 - X2 * X4^2 - X3 * X4^2 + X4^3, E3 * E4 * Y1^2 - 2 * E3 * E4 * Y1 * Y4 + E3 * E4 * Y4^2 + E3 * H4 * X1^2 - 2 * E3 * H4 * X1 * X4 + E3 * H4 * X4^2 + 2 * E3 * X1 * Y1 - 2 * E3 * X1 * Y4 - 2 * E3 * X4 * Y1 + 2 * E3 * X4 * Y4 + E4^2 * X1 * Y1^2 - 2 * E4^2 * X1 * Y1 * Y4 - E4^2 * X1 * Y2 * Y3 + E4^2 * X1 * Y2 * Y4 + E4^2 * X1 * Y3 * Y4 + E4^2 * X4 * Y2 * Y3 - E4^2 * X4 * Y2 * Y4 - E4^2 * X4 * Y3 * Y4 + E4^2 * X4 * Y4^2 + E4 * H4 * X1^2 * X2 + E4 * H4 * X1^2 * X3 - E4 * H4 * X1^2 * X4 - E4 * H4 * X1 * X2 * X3 - E4 * H4 * X1 * X2 * X4 - E4 * H4 * X1 * X3 * X4 + E4 * H4 * X1 * X4^2 + E4 * H4 * X2 * X3 * X4 + 2 * E4 * X1^2 * Y1 - 2 * E4 * X1^2 * Y4 - E4 * X1 * X2 * Y3 + E4 * X1 * X2 * Y4 - E4 * X1 * X3 * Y2 + E4 * X1 * X3 * Y4 - 2 * E4 * X1 * X4 * Y1 + E4 * X1 * X4 * Y2 + E4 * X1 * X4 * Y3 + E4 * X2 * X4 * Y3 - E4 * X2 * X4 * Y4 + E4 * X3 * X4 * Y2 - E4 * X3 * X4 * Y4 - E4 * X4^2 * Y2 - E4 * X4^2 * Y3 + 2 * E4 * X4^2 * Y4 + X1^3 - X1^2 * X2 - X1^2 * X3 - X1^2 * X4 + 2 * X1 * X2 * X4 + 2 * X1 * X3 * X4 - X1 * X4^2 - X2 * X4^2 - X3 * X4^2 + X4^3 ]
Index: /trunk/examples/shosh.gb
===================================================================
--- /trunk/examples/shosh.gb	(revision 8)
+++ /trunk/examples/shosh.gb	(revision 8)
@@ -0,0 +1,5 @@
+R:List(DMP([u12,u13,u14,u23,u24,u34,v12,v13,v14,v23,v24,v34,e1,e2,e3,e4,h1,h2,h3,h4,x1,x2,x3,x4,y1,y2,y3,y4],INT))
+
+R:=[1-u12*(x1-x2)-v12*(y1-y2),1-u13*(x1-x3)-v13*(y1-y3),1-u14*(x1-x4)-v14*(y1-y4),1-u23*(x2-x3)-v23*(y2-y3),1-u24*(x2-x4)-v24*(y2-y4),1-u34*(x3-x4)-v34*(y3-y4),x1**2+e1+e2*x1+e3*y1+e4*x1*y1,y1**2+h1+h2*x1+h3*y1+h4*x1*y1,x2**2+e1+e2*x2+e3*y2+e4*x2*y2,y2**2+h1+h2*x2+h3*y2+h4*x2*y2,x3**2+e1+e2*x3+e3*y3+e4*x3*y3,y3**2+h1+h2*x3+h3*y3+h4*x3*y3,x4**2+e1+e2*x4+e3*y4+e4*x4*y4,y4**2+h1+h2*x4+h3*y4+h4*x4*y4] 
+
+tgroebner(R)
Index: /trunk/examples/shosh.lisp
===================================================================
--- /trunk/examples/shosh.lisp	(revision 8)
+++ /trunk/examples/shosh.lisp	(revision 8)
@@ -0,0 +1,35 @@
+#|
+Return-Path: shosh@irisplot.math.arizona.edu
+Date: Fri, 7 Feb 1997 14:23:19 -0700 (MST)
+From: Alexander Shoshitaishvili <shosh@math.arizona.edu>
+To: rychlik@math.arizona.edu
+Subject: file for maple
+|#
+
+(setf Vars '(u12 u13 u14 u23 u24 u34 v12 v13 v14 v23 v24 v34 e1 e2 e3 e4 h1 h2 h3 
+	     h4 x1 x2 x3 x4 y1 y2 y3 y4))
+(setf 
+    f12 "1-u12*(x1-x2)-v12*(y1-y2)"
+    f13 "1-u13*(x1-x3)-v13*(y1-y3)"
+    f14 "1-u14*(x1-x4)-v14*(y1-y4)"
+    f23 "1-u23*(x2-x3)-v23*(y2-y3)"
+    f24 "1-u24*(x2-x4)-v24*(y2-y4)"
+    f34 "1-u34*(x3-x4)-v34*(y3-y4)"
+    a1 "x1^2+e1+e2*x1+e3*y1+e4*x1*y1"
+    a2 "y1^2+h1+h2*x1+h3*y1+h4*x1*y1"
+    b1 "x2^2+e1+e2*x2+e3*y2+e4*x2*y2"
+    b2 "y2^2+h1+h2*x2+h3*y2+h4*x2*y2"
+    c1 "x3^2+e1+e2*x3+e3*y3+e4*x3*y3"
+    c2 "y3^2+h1+h2*x3+h3*y3+h4*x3*y3"
+    d1 "x4^2+e1+e2*x4+e3*y4+e4*x4*y4"
+    d2 "y4^2+h1+h2*x4+h3*y4+h4*x4*y4"
+    )
+(setf order #'lex>)
+
+(setf F (mapcar #'(lambda (s) (parse-string-to-sorted-alist s vars order))
+		(list f12 f13 f14 f23 f24 f34 a1 a2 b1 b2 c1 c2 d1 d2)))
+
+(poly-print (cons '[ f) vars)
+;Gb:=gbasis(F,Vars,plex);
+(setf gb (reduced-grobner F order))
+(poly-print (cons '[ gb) vars)
Index: /trunk/examples/shosh.maple
===================================================================
--- /trunk/examples/shosh.maple	(revision 8)
+++ /trunk/examples/shosh.maple	(revision 8)
@@ -0,0 +1,25 @@
+Return-Path: shosh@irisplot.math.arizona.edu
+Date: Fri, 7 Feb 1997 14:23:19 -0700 (MST)
+From: Alexander Shoshitaishvili <shosh@math.arizona.edu>
+To: rychlik@math.arizona.edu
+Subject: file for maple
+
+with(grobner):
+Vars:= [u12,u13,u14,u23,u24,u34,v12,v13,v14,v23,v24,v34,e1,e2,e3,e4,h1,h2,h3,
+h4,x1,x2,x3,x4,y1,y2,y3,y4];
+f12:=1-u12*(x1-x2)-v12*(y1-y2);
+f13:=1-u13*(x1-x3)-v13*(y1-y3);
+f14:=1-u14*(x1-x4)-v14*(y1-y4);
+f23:=1-u23*(x2-x3)-v23*(y2-y3);
+f24:=1-u24*(x2-x4)-v24*(y2-y4);
+f34:=1-u34*(x3-x4)-v34*(y3-y4);
+a1:=x1^2+e1+e2*x1+e3*y1+e4*x1*y1;
+a2:=y1^2+h1+h2*x1+h3*y1+h4*x1*y1;
+b1:=x2^2+e1+e2*x2+e3*y2+e4*x2*y2;
+b2:=y2^2+h1+h2*x2+h3*y2+h4*x2*y2;
+c1:=x3^2+e1+e2*x3+e3*y3+e4*x3*y3;
+c2:=y3^2+h1+h2*x3+h3*y3+h4*x3*y3;
+d1:=x4^2+e1+e2*x4+e3*y4+e4*x4*y4;
+d2:=y4^2+h1+h2*x4+h3*y4+h4*x4*y4;
+F:=[f12,f13,f14,f23,f24,f34,a1,a2,b1,b2,c1,c2,d1,d2];
+Gb:=gbasis(F,Vars,plex);
Index: /trunk/examples/shosh.output
===================================================================
--- /trunk/examples/shosh.output	(revision 8)
+++ /trunk/examples/shosh.output	(revision 8)
@@ -0,0 +1,1 @@
+[ 2 * U12 * E3 * Y1 - 2 * U12 * E3 * Y2 + 2 * U12 * E4 * X2 * Y1 - 2 * U12 * E4 * X2 * Y2 - 2 * V12 * E3 * H4 * Y1 + 2 * V12 * E3 * H4 * Y2 + 2 * V12 * E4 * H3 * Y1 - 2 * V12 * E4 * H3 * Y2 + 4 * V12 * E4 * Y1 * Y4 - 2 * V12 * E4 * Y2^2 + 2 * V12 * E4 * Y2 * Y3 - 2 * V12 * E4 * Y2 * Y4 - 2 * V12 * E4 * Y3 * Y4 + 2 * V12 * H3 * X1 - 2 * V12 * H3 * X2 - 2 * V12 * H4 * X1 * X2 + 4 * V12 * H4 * X1 * X4 + 2 * V12 * H4 * X2 * X3 - 2 * V12 * H4 * X2 * X4 - 2 * V12 * H4 * X3 * X4 + 4 * V12 * X1 * Y4 - 4 * V12 * X2 * Y1 + 2 * V12 * X2 * Y3 - 2 * V12 * X2 * Y4 + 2 * V12 * X3 * Y2 - 2 * V12 * X3 * Y4 + 4 * V12 * X4 * Y1 - 2 * V12 * X4 * Y2 - 2 * V12 * X4 * Y3 + E3 * E4 * H4^2 + E3 * H4 - 2 * E4^2 * H2 - E4^2 * H3 * H4 - E4^2 * H4 * Y1 - E4^2 * H4 * Y2 - E4^2 * H4 * Y3 - E4^2 * H4 * Y4 + 3 * E4 * H3 + E4 * H4 * X1 + E4 * H4 * X2 + E4 * H4 * X3 + E4 * H4 * X4 + 3 * E4 * Y1 + E4 * Y2 + E4 * Y3 + E4 * Y4 + X1 + X2 - X3 - X4, U12 * X1 - U12 * X2 + V12 * Y1 - V12 * Y2 - 1, U13 * U14 * U23 * Y2 - U13 * U14 * U23 * Y3 - U13 * U14 * U24 * V23 * Y2 * Y3 + U13 * U14 * U24 * V23 * Y2 * Y4 + U13 * U14 * U24 * V23 * Y3^2 - U13 * U14 * U24 * V23 * Y3 * Y4 - U13 * U14 * U24 * Y2 + U13 * U14 * U24 * Y3 + U13 * U14 * V23 * V24 * H2 * Y3 - U13 * U14 * V23 * V24 * H2 * Y4 + U13 * U14 * V23 * V24 * H4 * Y2 * Y3 - U13 * U14 * V23 * V24 * H4 * Y2 * Y4 - U13 * U14 * V23 * H2 - U13 * U14 * V23 * H4 * Y2 + U13 * U14 * V24 * H2 + U13 * U14 * V24 * H4 * Y2 + U13 * U23 * U24 * V14 * Y1 * Y2 - U13 * U23 * U24 * V14 * Y1 * Y3 - U13 * U23 * U24 * V14 * Y2 * Y4 + U13 * U23 * U24 * V14 * Y3 * Y4 - U13 * U23 * U24 * Y2 + U13 * U23 * U24 * Y3 + U13 * U23 * U34 * V14 * V24 * Y1 * Y2^2 - U13 * U23 * U34 * V14 * V24 * Y1 * Y2 * Y3 - U13 * U23 * U34 * V14 * V24 * Y1 * Y2 * Y4 + U13 * U23 * U34 * V14 * V24 * Y1 * Y3 * Y4 - U13 * U23 * U34 * V14 * V24 * Y2^2 * Y4 + U13 * U23 * U34 * V14 * V24 * Y2 * Y3 * Y4 + U13 * U23 * U34 * V14 * V24 * Y2 * Y4^2 - U13 * U23 * U34 * V14 * V24 * Y3 * Y4^2 - U13 * U23 * U34 * V24 * Y2^2 + U13 * U23 * U34 * V24 * Y2 * Y3 + U13 * U23 * U34 * V24 * Y2 * Y4 - U13 * U23 * U34 * V24 * Y3 * Y4 + U13 * U23 * V14 * V24 * V34 * H2 * Y1 * Y2 - U13 * U23 * V14 * V24 * V34 * H2 * Y1 * Y3 - U13 * U23 * V14 * V24 * V34 * H2 * Y2 * Y4 + U13 * U23 * V14 * V24 * V34 * H2 * Y3 * Y4 + U13 * U23 * V14 * V24 * V34 * H4 * Y1 * Y2 * Y4 - U13 * U23 * V14 * V24 * V34 * H4 * Y1 * Y3 * Y4 - U13 * U23 * V14 * V24 * V34 * H4 * Y2 * Y4^2 + U13 * U23 * V14 * V24 * V34 * H4 * Y3 * Y4^2 - U13 * U23 * V24 * V34 * H2 * Y2 + U13 * U23 * V24 * V34 * H2 * Y3 - U13 * U23 * V24 * V34 * H4 * Y2 * Y4 + U13 * U23 * V24 * V34 * H4 * Y3 * Y4 - U13 * U24 * U34 * V14 * V23 * Y1 * Y2^2 + U13 * U24 * U34 * V14 * V23 * Y1 * Y2 * Y3 + U13 * U24 * U34 * V14 * V23 * Y1 * Y2 * Y4 - U13 * U24 * U34 * V14 * V23 * Y1 * Y3 * Y4 + U13 * U24 * U34 * V14 * V23 * Y2^2 * Y4 - U13 * U24 * U34 * V14 * V23 * Y2 * Y3 * Y4 - U13 * U24 * U34 * V14 * V23 * Y2 * Y4^2 + U13 * U24 * U34 * V14 * V23 * Y3 * Y4^2 + U13 * U24 * U34 * V23 * Y2^2 - U13 * U24 * U34 * V23 * Y2 * Y3 - U13 * U24 * U34 * V23 * Y2 * Y4 + U13 * U24 * U34 * V23 * Y3 * Y4 - U13 * U24 * V14 * V23 * V34 * H2 * Y1 * Y2 + U13 * U24 * V14 * V23 * V34 * H2 * Y1 * Y4 + U13 * U24 * V14 * V23 * V34 * H2 * Y2 * Y4 - U13 * U24 * V14 * V23 * V34 * H2 * Y4^2 - U13 * U24 * V14 * V23 * V34 * H4 * Y1 * Y2 * Y3 + U13 * U24 * V14 * V23 * V34 * H4 * Y1 * Y3 * Y4 + U13 * U24 * V14 * V23 * V34 * H4 * Y2 * Y3 * Y4 - U13 * U24 * V14 * V23 * V34 * H4 * Y3 * Y4^2 + U13 * U24 * V23 * V34 * H2 * Y2 - U13 * U24 * V23 * V34 * H2 * Y4 + U13 * U24 * V23 * V34 * H4 * Y2 * Y3 - U13 * U24 * V23 * V34 * H4 * Y3 * Y4 + U13 * U34 * V14 * V23 * V24 * H2 * Y1 * Y3 - U13 * U34 * V14 * V23 * V24 * H2 * Y1 * Y4 - U13 * U34 * V14 * V23 * V24 * H2 * Y3 * Y4 + U13 * U34 * V14 * V23 * V24 * H2 * Y4^2 + U13 * U34 * V14 * V23 * V24 * H4 * Y1 * Y2 * Y3 - U13 * U34 * V14 * V23 * V24 * H4 * Y1 * Y2 * Y4 - U13 * U34 * V14 * V23 * V24 * H4 * Y2 * Y3 * Y4 + U13 * U34 * V14 * V23 * V24 * H4 * Y2 * Y4^2 - U13 * U34 * V14 * V23 * H2 * Y1 + U13 * U34 * V14 * V23 * H2 * Y4 - U13 * U34 * V14 * V23 * H4 * Y1 * Y2 + U13 * U34 * V14 * V23 * H4 * Y2 * Y4 + U13 * U34 * V14 * V24 * H2 * Y1 - U13 * U34 * V14 * V24 * H2 * Y4 + U13 * U34 * V14 * V24 * H4 * Y1 * Y2 - U13 * U34 * V14 * V24 * H4 * Y2 * Y4 - U13 * U34 * V23 * V24 * H2 * Y3 + U13 * U34 * V23 * V24 * H2 * Y4 - U13 * U34 * V23 * V24 * H4 * Y2 * Y3 + U13 * U34 * V23 * V24 * H4 * Y2 * Y4 + U13 * U34 * V23 * H2 + U13 * U34 * V23 * H4 * Y2 - U13 * U34 * V24 * H2 - U13 * U34 * V24 * H4 * Y2 - U14 * U23 * U24 * V13 * Y1 * Y2 + U14 * U23 * U24 * V13 * Y1 * Y3 + U14 * U23 * U24 * V13 * Y2 * Y3 - U14 * U23 * U24 * V13 * Y3^2 + U14 * U23 * U24 * Y2 - U14 * U23 * U24 * Y3 - U14 * U23 * U34 * V13 * V24 * Y1 * Y2^2 + U14 * U23 * U34 * V13 * V24 * Y1 * Y2 * Y3 + U14 * U23 * U34 * V13 * V24 * Y1 * Y2 * Y4 - U14 * U23 * U34 * V13 * V24 * Y1 * Y3 * Y4 + U14 * U23 * U34 * V13 * V24 * Y2^2 * Y4 - U14 * U23 * U34 * V13 * V24 * Y2 * Y3 * Y4 - U14 * U23 * U34 * V13 * V24 * Y2 * Y4^2 + U14 * U23 * U34 * V13 * V24 * Y3 * Y4^2 + U14 * U23 * U34 * V24 * Y2^2 - U14 * U23 * U34 * V24 * Y2 * Y3 - U14 * U23 * U34 * V24 * Y2 * Y4 + U14 * U23 * U34 * V24 * Y3 * Y4 - U14 * U23 * V13 * V24 * V34 * H2 * Y1 * Y2 + U14 * U23 * V13 * V24 * V34 * H2 * Y1 * Y3 + U14 * U23 * V13 * V24 * V34 * H2 * Y2 * Y4 - U14 * U23 * V13 * V24 * V34 * H2 * Y3 * Y4 - U14 * U23 * V13 * V24 * V34 * H4 * Y1 * Y2 * Y4 + U14 * U23 * V13 * V24 * V34 * H4 * Y1 * Y3 * Y4 + U14 * U23 * V13 * V24 * V34 * H4 * Y2 * Y4^2 - U14 * U23 * V13 * V24 * V34 * H4 * Y3 * Y4^2 + U14 * U23 * V13 * V24 * H2 * Y2 - U14 * U23 * V13 * V24 * H2 * Y3 + U14 * U23 * V13 * V24 * H4 * Y2 * Y4 - U14 * U23 * V13 * V24 * H4 * Y3 * Y4 + U14 * U23 * V24 * V34 * H2 * Y2 - U14 * U23 * V24 * V34 * H2 * Y3 + U14 * U23 * V24 * V34 * H4 * Y2 * Y4 - U14 * U23 * V24 * V34 * H4 * Y3 * Y4 + U14 * U24 * U34 * V13 * V23 * Y1 * Y2^2 - U14 * U24 * U34 * V13 * V23 * Y1 * Y2 * Y3 - U14 * U24 * U34 * V13 * V23 * Y1 * Y2 * Y4 + U14 * U24 * U34 * V13 * V23 * Y1 * Y3 * Y4 - U14 * U24 * U34 * V13 * V23 * Y2^2 * Y4 + U14 * U24 * U34 * V13 * V23 * Y2 * Y3 * Y4 + U14 * U24 * U34 * V13 * V23 * Y2 * Y4^2 - U14 * U24 * U34 * V13 * V23 * Y3 * Y4^2 - U14 * U24 * U34 * V23 * Y2^2 + U14 * U24 * U34 * V23 * Y2 * Y3 + U14 * U24 * U34 * V23 * Y2 * Y4 - U14 * U24 * U34 * V23 * Y3 * Y4 + U14 * U24 * V13 * V23 * V34 * H2 * Y1 * Y2 - U14 * U24 * V13 * V23 * V34 * H2 * Y1 * Y4 - U14 * U24 * V13 * V23 * V34 * H2 * Y2 * Y4 + U14 * U24 * V13 * V23 * V34 * H2 * Y4^2 + U14 * U24 * V13 * V23 * V34 * H4 * Y1 * Y2 * Y3 - U14 * U24 * V13 * V23 * V34 * H4 * Y1 * Y3 * Y4 - U14 * U24 * V13 * V23 * V34 * H4 * Y2 * Y3 * Y4 + U14 * U24 * V13 * V23 * V34 * H4 * Y3 * Y4^2 - U14 * U24 * V13 * V23 * H2 * Y2 + U14 * U24 * V13 * V23 * H2 * Y4 - U14 * U24 * V13 * V23 * H4 * Y2 * Y3 + U14 * U24 * V13 * V23 * H4 * Y3 * Y4 - U14 * U24 * V23 * V34 * H2 * Y2 + U14 * U24 * V23 * V34 * H2 * Y4 - U14 * U24 * V23 * V34 * H4 * Y2 * Y3 + U14 * U24 * V23 * V34 * H4 * Y3 * Y4 - U14 * U34 * V13 * V23 * V24 * H2 * Y1 * Y3 + U14 * U34 * V13 * V23 * V24 * H2 * Y1 * Y4 + U14 * U34 * V13 * V23 * V24 * H2 * Y3 * Y4 - U14 * U34 * V13 * V23 * V24 * H2 * Y4^2 - U14 * U34 * V13 * V23 * V24 * H4 * Y1 * Y2 * Y3 + U14 * U34 * V13 * V23 * V24 * H4 * Y1 * Y2 * Y4 + U14 * U34 * V13 * V23 * V24 * H4 * Y2 * Y3 * Y4 - U14 * U34 * V13 * V23 * V24 * H4 * Y2 * Y4^2 + U14 * U34 * V13 * V23 * H2 * Y1 - U14 * U34 * V13 * V23 * H2 * Y4 + U14 * U34 * V13 * V23 * H4 * Y1 * Y2 - U14 * U34 * V13 * V23 * H4 * Y2 * Y4 - U14 * U34 * V13 * V24 * H2 * Y1 + U14 * U34 * V13 * V24 * H2 * Y4 - U14 * U34 * V13 * V24 * H4 * Y1 * Y2 + U14 * U34 * V13 * V24 * H4 * Y2 * Y4 + U14 * U34 * V23 * V24 * H2 * Y3 - U14 * U34 * V23 * V24 * H2 * Y4 + U14 * U34 * V23 * V24 * H4 * Y2 * Y3 - U14 * U34 * V23 * V24 * H4 * Y2 * Y4 - U14 * U34 * V23 * H2 - U14 * U34 * V23 * H4 * Y2 + U14 * U34 * V24 * H2 + U14 * U34 * V24 * H4 * Y2, 2 * U13 * E3 * Y1 - 2 * U13 * E3 * Y3 + 2 * U13 * E4 * X3 * Y1 - 2 * U13 * E4 * X3 * Y3 - 2 * V13 * E3 * H4 * Y1 + 2 * V13 * E3 * H4 * Y3 + 2 * V13 * E4 * H3 * Y1 - 2 * V13 * E4 * H3 * Y3 + 4 * V13 * E4 * Y1 * Y4 + 2 * V13 * E4 * Y2 * Y3 - 2 * V13 * E4 * Y2 * Y4 - 2 * V13 * E4 * Y3^2 - 2 * V13 * E4 * Y3 * Y4 + 2 * V13 * H3 * X1 - 2 * V13 * H3 * X3 - 2 * V13 * H4 * X1 * X3 + 4 * V13 * H4 * X1 * X4 + 2 * V13 * H4 * X2 * X3 - 2 * V13 * H4 * X2 * X4 - 2 * V13 * H4 * X3 * X4 + 4 * V13 * X1 * Y4 + 2 * V13 * X2 * Y3 - 2 * V13 * X2 * Y4 - 4 * V13 * X3 * Y1 + 2 * V13 * X3 * Y2 - 2 * V13 * X3 * Y4 + 4 * V13 * X4 * Y1 - 2 * V13 * X4 * Y2 - 2 * V13 * X4 * Y3 + E3 * E4 * H4^2 + E3 * H4 - 2 * E4^2 * H2 - E4^2 * H3 * H4 - E4^2 * H4 * Y1 - E4^2 * H4 * Y2 - E4^2 * H4 * Y3 - E4^2 * H4 * Y4 + 3 * E4 * H3 + E4 * H4 * X1 + E4 * H4 * X2 + E4 * H4 * X3 + E4 * H4 * X4 + 3 * E4 * Y1 + E4 * Y2 + E4 * Y3 + E4 * Y4 + X1 - X2 + X3 - X4, U13 * X1 - U13 * X3 + V13 * Y1 - V13 * Y3 - 1, 2 * U14 * E3 * Y1 - 2 * U14 * E3 * Y4 + 2 * U14 * E4 * X4 * Y1 - 2 * U14 * E4 * X4 * Y4 - 2 * V14 * E3 * H4 * Y1 + 2 * V14 * E3 * H4 * Y4 + 2 * V14 * E4 * H3 * Y1 - 2 * V14 * E4 * H3 * Y4 + 4 * V14 * E4 * Y1 * Y4 + 2 * V14 * E4 * Y2 * Y3 - 2 * V14 * E4 * Y2 * Y4 - 2 * V14 * E4 * Y3 * Y4 - 2 * V14 * E4 * Y4^2 + 2 * V14 * H3 * X1 - 2 * V14 * H3 * X4 + 2 * V14 * H4 * X1 * X4 + 2 * V14 * H4 * X2 * X3 - 2 * V14 * H4 * X2 * X4 - 2 * V14 * H4 * X3 * X4 + 4 * V14 * X1 * Y4 + 2 * V14 * X2 * Y3 - 2 * V14 * X2 * Y4 + 2 * V14 * X3 * Y2 - 2 * V14 * X3 * Y4 - 2 * V14 * X4 * Y2 - 2 * V14 * X4 * Y3 + E3 * E4 * H4^2 + E3 * H4 - 2 * E4^2 * H2 - E4^2 * H3 * H4 - E4^2 * H4 * Y1 - E4^2 * H4 * Y2 - E4^2 * H4 * Y3 - E4^2 * H4 * Y4 + 3 * E4 * H3 + E4 * H4 * X1 + E4 * H4 * X2 + E4 * H4 * X3 + E4 * H4 * X4 + 3 * E4 * Y1 + E4 * Y2 + E4 * Y3 + E4 * Y4 + X1 - X2 - X3 + X4, U14 * X1 - U14 * X4 + V14 * Y1 - V14 * Y4 - 1, 2 * U23 * E3 * Y2 - 2 * U23 * E3 * Y3 + 2 * U23 * E4 * X3 * Y2 - 2 * U23 * E4 * X3 * Y3 - 2 * V23 * E3 * H4 * Y2 + 2 * V23 * E3 * H4 * Y3 + 2 * V23 * E4 * H3 * Y2 - 2 * V23 * E4 * H3 * Y3 + 2 * V23 * E4 * Y2 * Y3 + 2 * V23 * E4 * Y2 * Y4 - 2 * V23 * E4 * Y3^2 - 2 * V23 * E4 * Y3 * Y4 + 2 * V23 * H3 * X2 - 2 * V23 * H3 * X3 + 2 * V23 * H4 * X2 * X4 - 2 * V23 * H4 * X3 * X4 + 2 * V23 * X2 * Y3 + 2 * V23 * X2 * Y4 - 2 * V23 * X3 * Y2 - 2 * V23 * X3 * Y4 + 2 * V23 * X4 * Y2 - 2 * V23 * X4 * Y3 + E3 * E4 * H4^2 + E3 * H4 - 2 * E4^2 * H2 - E4^2 * H3 * H4 - E4^2 * H4 * Y1 - E4^2 * H4 * Y2 - E4^2 * H4 * Y3 - E4^2 * H4 * Y4 + 3 * E4 * H3 + E4 * H4 * X1 + E4 * H4 * X2 + E4 * H4 * X3 + E4 * H4 * X4 + E4 * Y1 + 3 * E4 * Y2 + E4 * Y3 + E4 * Y4 - X1 + X2 + X3 - X4, U23 * X2 - U23 * X3 + V23 * Y2 - V23 * Y3 - 1, 2 * U24 * E3 * Y2 - 2 * U24 * E3 * Y4 + 2 * U24 * E4 * X4 * Y2 - 2 * U24 * E4 * X4 * Y4 - 2 * V24 * E3 * H4 * Y2 + 2 * V24 * E3 * H4 * Y4 + 2 * V24 * E4 * H3 * Y2 - 2 * V24 * E4 * H3 * Y4 + 2 * V24 * E4 * Y2 * Y3 + 2 * V24 * E4 * Y2 * Y4 - 2 * V24 * E4 * Y3 * Y4 - 2 * V24 * E4 * Y4^2 + 2 * V24 * H3 * X2 - 2 * V24 * H3 * X4 + 2 * V24 * H4 * X2 * X3 - 2 * V24 * H4 * X3 * X4 + 2 * V24 * X2 * Y3 + 2 * V24 * X2 * Y4 + 2 * V24 * X3 * Y2 - 2 * V24 * X3 * Y4 - 2 * V24 * X4 * Y2 - 2 * V24 * X4 * Y3 + E3 * E4 * H4^2 + E3 * H4 - 2 * E4^2 * H2 - E4^2 * H3 * H4 - E4^2 * H4 * Y1 - E4^2 * H4 * Y2 - E4^2 * H4 * Y3 - E4^2 * H4 * Y4 + 3 * E4 * H3 + E4 * H4 * X1 + E4 * H4 * X2 + E4 * H4 * X3 + E4 * H4 * X4 + E4 * Y1 + 3 * E4 * Y2 + E4 * Y3 + E4 * Y4 - X1 + X2 - X3 + X4, U24 * X2 - U24 * X4 + V24 * Y2 - V24 * Y4 - 1, 2 * U34 * E3 * Y3 - 2 * U34 * E3 * Y4 + 2 * U34 * E4 * X4 * Y3 - 2 * U34 * E4 * X4 * Y4 - 2 * V34 * E3 * H4 * Y3 + 2 * V34 * E3 * H4 * Y4 + 2 * V34 * E4 * H3 * Y3 - 2 * V34 * E4 * H3 * Y4 + 2 * V34 * E4 * Y2 * Y3 - 2 * V34 * E4 * Y2 * Y4 + 2 * V34 * E4 * Y3 * Y4 - 2 * V34 * E4 * Y4^2 + 2 * V34 * H3 * X3 - 2 * V34 * H3 * X4 + 2 * V34 * H4 * X2 * X3 - 2 * V34 * H4 * X2 * X4 + 2 * V34 * X2 * Y3 - 2 * V34 * X2 * Y4 + 2 * V34 * X3 * Y2 + 2 * V34 * X3 * Y4 - 2 * V34 * X4 * Y2 - 2 * V34 * X4 * Y3 + E3 * E4 * H4^2 + E3 * H4 - 2 * E4^2 * H2 - E4^2 * H3 * H4 - E4^2 * H4 * Y1 - E4^2 * H4 * Y2 - E4^2 * H4 * Y3 - E4^2 * H4 * Y4 + 3 * E4 * H3 + E4 * H4 * X1 + E4 * H4 * X2 + E4 * H4 * X3 + E4 * H4 * X4 + E4 * Y1 + E4 * Y2 + 3 * E4 * Y3 + E4 * Y4 - X1 - X2 + X3 + X4, U34 * X3 - U34 * X4 + V34 * Y3 - V34 * Y4 - 1, 2 * E1 + E3 * E4 * H4^2 * X4 + E3 * H4 * X4 + 2 * E3 * Y4 - 2 * E4^2 * H2 * X4 - E4^2 * H3 * H4 * X4 - E4^2 * H4 * X4 * Y1 - E4^2 * H4 * X4 * Y2 - E4^2 * H4 * X4 * Y3 - E4^2 * H4 * X4 * Y4 + 3 * E4 * H3 * X4 + E4 * H4 * X1 * X4 + E4 * H4 * X2 * X4 + E4 * H4 * X3 * X4 + E4 * H4 * X4^2 + E4 * X4 * Y1 + E4 * X4 * Y2 + E4 * X4 * Y3 + 3 * E4 * X4 * Y4 - X1 * X4 - X2 * X4 - X3 * X4 + X4^2, E3 * E4 * H3 * H4^2 + 2 * E3 * E4 * H4^2 * Y4 - 2 * E3 * H2 + E3 * H3 * H4 + 2 * E3 * H4^2 * X4 - 2 * E4^2 * H2 * H3 - 4 * E4^2 * H2 * Y4 - E4^2 * H3^2 * H4 - E4^2 * H3 * H4 * Y1 - E4^2 * H3 * H4 * Y2 - E4^2 * H3 * H4 * Y3 - 3 * E4^2 * H3 * H4 * Y4 - 2 * E4^2 * H4 * Y1 * Y4 - 2 * E4^2 * H4 * Y2 * Y4 - 2 * E4^2 * H4 * Y3 * Y4 - 2 * E4^2 * H4 * Y4^2 - 4 * E4 * H2 * X4 + 3 * E4 * H3^2 + E4 * H3 * H4 * X1 + E4 * H3 * H4 * X2 + E4 * H3 * H4 * X3 - E4 * H3 * H4 * X4 + E4 * H3 * Y1 + E4 * H3 * Y2 + E4 * H3 * Y3 + 9 * E4 * H3 * Y4 + 2 * E4 * H4 * X1 * Y4 + 2 * E4 * H4 * X2 * Y4 + 2 * E4 * H4 * X3 * Y4 - 2 * E4 * H4 * X4 * Y1 - 2 * E4 * H4 * X4 * Y2 - 2 * E4 * H4 * X4 * Y3 + 2 * E4 * Y1 * Y4 - 2 * E4 * Y2 * Y3 + 4 * E4 * Y2 * Y4 + 4 * E4 * Y3 * Y4 + 4 * E4 * Y4^2 - H3 * X1 - H3 * X2 - H3 * X3 + 7 * H3 * X4 - 2 * H4 * X2 * X3 + 2 * H4 * X2 * X4 + 2 * H4 * X3 * X4 + 2 * H4 * X4^2 - 2 * X1 * Y4 - 2 * X2 * Y3 - 2 * X3 * Y2 + 2 * X4 * Y1 + 4 * X4 * Y2 + 4 * X4 * Y3 + 4 * X4 * Y4, E3 * E4 * H4 * Y1 - E3 * E4 * H4 * Y4 - E3 * H4 * X1 + E3 * H4 * X4 - 2 * E3 * Y1 + 2 * E3 * Y4 - E4^2 * H3 * Y1 + E4^2 * H3 * Y4 - E4^2 * Y1^2 + E4^2 * Y4^2 - E4 * H3 * X1 + E4 * H3 * X4 - E4 * H4 * X1 * X2 - E4 * H4 * X1 * X3 + E4 * H4 * X2 * X4 + E4 * H4 * X3 * X4 - 2 * E4 * X1 * Y1 + 2 * E4 * X4 * Y4 - X1^2 + X1 * X2 + X1 * X3 - X2 * X4 - X3 * X4 + X4^2, E3 * E4 * H4 * Y2 - E3 * E4 * H4 * Y4 - E3 * H4 * X2 + E3 * H4 * X4 - 2 * E3 * Y2 + 2 * E3 * Y4 - E4^2 * H3 * Y2 + E4^2 * H3 * Y4 - E4^2 * Y2^2 + E4^2 * Y4^2 - E4 * H3 * X2 + E4 * H3 * X4 - E4 * H4 * X1 * X2 + E4 * H4 * X1 * X4 - E4 * H4 * X2 * X3 + E4 * H4 * X3 * X4 - 2 * E4 * X2 * Y2 + 2 * E4 * X4 * Y4 + X1 * X2 - X1 * X4 - X2^2 + X2 * X3 - X3 * X4 + X4^2, E3 * H2^2 - E3 * H3^2 * H4^2 - 2 * E3 * H3 * H4^3 * X4 - 2 * E3 * H3 * H4^2 * Y4 - E3 * H4^4 * X4^2 - 2 * E3 * H4^3 * X4 * Y4 - E3 * H4^2 * Y4^2 + 2 * E4 * H2 * H3^2 + 4 * E4 * H2 * H3 * H4 * X4 + 6 * E4 * H2 * H3 * Y4 + 2 * E4 * H2 * H4^2 * X4^2 + 4 * E4 * H2 * H4 * X4 * Y4 + 4 * E4 * H2 * Y4^2 + E4 * H3^3 * H4 + 2 * E4 * H3^2 * H4^2 * X4 + E4 * H3^2 * H4 * Y1 + E4 * H3^2 * H4 * Y2 + E4 * H3^2 * H4 * Y3 + 3 * E4 * H3^2 * H4 * Y4 + E4 * H3 * H4^3 * X4^2 + 2 * E4 * H3 * H4^2 * X4 * Y1 + 2 * E4 * H3 * H4^2 * X4 * Y2 + 2 * E4 * H3 * H4^2 * X4 * Y3 + 4 * E4 * H3 * H4^2 * X4 * Y4 + 2 * E4 * H3 * H4 * Y1 * Y4 + 2 * E4 * H3 * H4 * Y2 * Y4 + 2 * E4 * H3 * H4 * Y3 * Y4 + 4 * E4 * H3 * H4 * Y4^2 + E4 * H4^3 * X4^2 * Y1 + E4 * H4^3 * X4^2 * Y2 + E4 * H4^3 * X4^2 * Y3 + E4 * H4^3 * X4^2 * Y4 + 2 * E4 * H4^2 * X4 * Y1 * Y4 + E4 * H4^2 * X4 * Y2 * Y3 + E4 * H4^2 * X4 * Y2 * Y4 + E4 * H4^2 * X4 * Y3 * Y4 + 3 * E4 * H4^2 * X4 * Y4^2 - 2 * E4 * H4 * Y2 * Y3 * Y4 + 2 * E4 * H4 * Y2 * Y4^2 + 2 * E4 * H4 * Y3 * Y4^2 + 2 * E4 * H4 * Y4^3 + 2 * H2 * H3 * X4 + 2 * H2 * H4 * X4^2 + H2 * X4 * Y1 + H2 * X4 * Y2 + H2 * X4 * Y3 + H2 * X4 * Y4 - 3 * H3^3 - 10 * H3^2 * H4 * X4 - H3^2 * Y1 - H3^2 * Y2 - H3^2 * Y3 - 11 * H3^2 * Y4 + H3 * H4^2 * X1 * X2 + H3 * H4^2 * X1 * X3 - 3 * H3 * H4^2 * X1 * X4 + H3 * H4^2 * X2 * X3 - 3 * H3 * H4^2 * X2 * X4 - 3 * H3 * H4^2 * X3 * X4 - 5 * H3 * H4^2 * X4^2 + 2 * H3 * H4 * X2 * Y1 - 2 * H3 * H4 * X2 * Y4 + 2 * H3 * H4 * X3 * Y1 + 2 * H3 * H4 * X3 * Y2 - 4 * H3 * H4 * X3 * Y4 - 8 * H3 * H4 * X4 * Y1 - 6 * H3 * H4 * X4 * Y2 - 4 * H3 * H4 * X4 * Y3 - 12 * H3 * H4 * X4 * Y4 + H3 * Y1 * Y2 + H3 * Y1 * Y3 - 4 * H3 * Y1 * Y4 + H3 * Y2 * Y3 - 4 * H3 * Y2 * Y4 - 4 * H3 * Y3 * Y4 - 11 * H3 * Y4^2 + H4^3 * X1 * X2 * X3 - H4^3 * X1 * X2 * X4 - H4^3 * X1 * X3 * X4 - H4^3 * X2 * X4^2 - H4^3 * X3 * X4^2 - H4^3 * X4^3 + H4^2 * X1 * X2 * Y1 - H4^2 * X1 * X2 * Y2 + H4^2 * X1 * X2 * Y3 + H4^2 * X1 * X2 * Y4 + H4^2 * X1 * X3 * Y1 + H4^2 * X1 * X3 * Y2 - H4^2 * X1 * X3 * Y3 + H4^2 * X1 * X3 * Y4 - 3 * H4^2 * X1 * X4 * Y1 - H4^2 * X1 * X4 * Y2 - H4^2 * X1 * X4 * Y3 - H4^2 * X1 * X4 * Y4 + H4^2 * X2 * X3 * Y1 + H4^2 * X2 * X3 * Y2 - H4^2 * X2 * X3 * Y3 - H4^2 * X2 * X3 * Y4 - H4^2 * X2 * X4 * Y1 - H4^2 * X2 * X4 * Y2 - 2 * H4^2 * X2 * X4 * Y4 - H4^2 * X3 * X4 * Y1 + H4^2 * X3 * X4 * Y3 - 4 * H4^2 * X3 * X4 * Y4 - H4^2 * X4^2 * Y1 - 2 * H4^2 * X4^2 * Y2 - 2 * H4^2 * X4^2 * Y3 - H4^2 * X4^2 * Y4 - H4 * X1 * Y2^2 + H4 * X1 * Y2 * Y3 + H4 * X1 * Y2 * Y4 - H4 * X1 * Y3^2 + H4 * X1 * Y3 * Y4 - H4 * X1 * Y4^2 + H4 * X2 * Y1^2 + H4 * X2 * Y1 * Y3 + H4 * X2 * Y1 * Y4 - H4 * X2 * Y3^2 - H4 * X2 * Y3 * Y4 - H4 * X2 * Y4^2 + H4 * X3 * Y1^2 + H4 * X3 * Y1 * Y2 + H4 * X3 * Y1 * Y4 + H4 * X3 * Y2^2 - H4 * X3 * Y2 * Y4 - 3 * H4 * X3 * Y4^2 - 3 * H4 * X4 * Y1^2 - H4 * X4 * Y1 * Y2 - H4 * X4 * Y1 * Y3 - 5 * H4 * X4 * Y1 * Y4 - H4 * X4 * Y2^2 - H4 * X4 * Y2 * Y3 - 3 * H4 * X4 * Y2 * Y4 + H4 * X4 * Y3^2 - 3 * H4 * X4 * Y3 * Y4 - 3 * H4 * X4 * Y4^2 + Y1 * Y2 * Y3 + Y1 * Y2 * Y4 + Y1 * Y3 * Y4 - 3 * Y1 * Y4^2 + Y2 * Y3 * Y4 - 3 * Y2 * Y4^2 - 3 * Y3 * Y4^2 - 3 * Y4^3, E3 * H2 * Y1 - E3 * H2 * Y4 - E3 * H3 * H4 * Y1 + E3 * H3 * H4 * Y4 - E3 * H4^2 * X4 * Y1 + E3 * H4^2 * X4 * Y4 - E3 * H4 * Y1 * Y4 + E3 * H4 * Y4^2 + E4 * H3^2 * Y1 - E4 * H3^2 * Y4 + E4 * H3 * H4 * X4 * Y1 - E4 * H3 * H4 * X4 * Y4 + 4 * E4 * H3 * Y1 * Y4 - 4 * E4 * H3 * Y4^2 - E4 * H4 * X1 * Y1^2 + 2 * E4 * H4 * X1 * Y1 * Y4 + E4 * H4 * X1 * Y2 * Y3 - E4 * H4 * X1 * Y2 * Y4 - E4 * H4 * X1 * Y3 * Y4 + E4 * H4 * X4 * Y1^2 - 2 * E4 * H4 * X4 * Y2 * Y3 + 2 * E4 * H4 * X4 * Y2 * Y4 + 2 * E4 * H4 * X4 * Y3 * Y4 - 3 * E4 * H4 * X4 * Y4^2 - E4 * Y1^3 + 3 * E4 * Y1^2 * Y4 + E4 * Y1 * Y4^2 - 3 * E4 * Y4^3 + H3^2 * X1 - H3^2 * X4 - H3 * H4 * X1^2 + 5 * H3 * H4 * X1 * X4 - 4 * H3 * H4 * X4^2 - H3 * X1 * Y1 + 5 * H3 * X1 * Y4 + 3 * H3 * X4 * Y1 - 7 * H3 * X4 * Y4 - H4^2 * X1^2 * X2 - H4^2 * X1^2 * X3 + H4^2 * X1^2 * X4 + 3 * H4^2 * X1 * X2 * X4 + 3 * H4^2 * X1 * X3 * X4 - 2 * H4^2 * X1 * X4^2 - H4^2 * X2 * X3 * X4 - H4^2 * X2 * X4^2 - H4^2 * X3 * X4^2 - H4 * X1^2 * Y1 - H4 * X1^2 * Y2 - H4 * X1^2 * Y3 + H4 * X1^2 * Y4 - H4 * X1 * X2 * Y1 + H4 * X1 * X2 * Y4 - H4 * X1 * X3 * Y1 + H4 * X1 * X3 * Y4 + 4 * H4 * X1 * X4 * Y1 + 3 * H4 * X1 * X4 * Y2 + 3 * H4 * X1 * X4 * Y3 + 2 * H4 * X2 * X4 * Y1 - H4 * X2 * X4 * Y3 - H4 * X2 * X4 * Y4 + 2 * H4 * X3 * X4 * Y1 - H4 * X3 * X4 * Y2 - H4 * X3 * X4 * Y4 - 3 * H4 * X4^2 * Y1 - H4 * X4^2 * Y2 - H4 * X4^2 * Y3 - 3 * H4 * X4^2 * Y4 - X1 * Y1^2 - X1 * Y1 * Y2 - X1 * Y1 * Y3 + 2 * X1 * Y1 * Y4 - X1 * Y2 * Y3 + 2 * X1 * Y2 * Y4 + 2 * X1 * Y3 * Y4 + 2 * X1 * Y4^2 + 2 * X4 * Y1^2 + 2 * X4 * Y1 * Y2 + 2 * X4 * Y1 * Y3 - 2 * X4 * Y1 * Y4 + X4 * Y2 * Y3 - 3 * X4 * Y2 * Y4 - 3 * X4 * Y3 * Y4 - 3 * X4 * Y4^2, E3 * H2 * Y2 - E3 * H2 * Y4 - E3 * H3 * H4 * Y2 + E3 * H3 * H4 * Y4 - E3 * H4^2 * X4 * Y2 + E3 * H4^2 * X4 * Y4 - E3 * H4 * Y2 * Y4 + E3 * H4 * Y4^2 + E4 * H3^2 * Y2 - E4 * H3^2 * Y4 + E4 * H3 * H4 * X4 * Y2 - E4 * H3 * H4 * X4 * Y4 + 4 * E4 * H3 * Y2 * Y4 - 4 * E4 * H3 * Y4^2 - E4 * H4 * X2 * Y2^2 + E4 * H4 * X2 * Y2 * Y3 + E4 * H4 * X2 * Y2 * Y4 - E4 * H4 * X2 * Y3 * Y4 + E4 * H4 * X4 * Y2^2 - 2 * E4 * H4 * X4 * Y2 * Y3 + 2 * E4 * H4 * X4 * Y2 * Y4 + 2 * E4 * H4 * X4 * Y3 * Y4 - 3 * E4 * H4 * X4 * Y4^2 - E4 * Y2^3 + 3 * E4 * Y2^2 * Y4 + E4 * Y2 * Y4^2 - 3 * E4 * Y4^3 + H3^2 * X2 - H3^2 * X4 - H3 * H4 * X2^2 + 5 * H3 * H4 * X2 * X4 - 4 * H3 * H4 * X4^2 - H3 * X2 * Y2 + 5 * H3 * X2 * Y4 + 3 * H3 * X4 * Y2 - 7 * H3 * X4 * Y4 - H4^2 * X1 * X2^2 - H4^2 * X1 * X2 * X3 + 4 * H4^2 * X1 * X2 * X4 + H4^2 * X1 * X3 * X4 - 3 * H4^2 * X1 * X4^2 + H4^2 * X2 * X3 * X4 - H4^2 * X3 * X4^2 - H4 * X1 * X2 * Y2 - H4 * X1 * X2 * Y3 + 2 * H4 * X1 * X2 * Y4 + 2 * H4 * X1 * X4 * Y2 + H4 * X1 * X4 * Y3 - 3 * H4 * X1 * X4 * Y4 - H4 * X2^2 * Y1 - H4 * X2^2 * Y2 - H4 * X2 * X3 * Y1 + H4 * X2 * X3 * Y4 + 4 * H4 * X2 * X4 * Y1 + 3 * H4 * X2 * X4 * Y2 + H4 * X2 * X4 * Y3 + 2 * H4 * X2 * X4 * Y4 + H4 * X3 * X4 * Y1 - H4 * X3 * X4 * Y4 - 3 * H4 * X4^2 * Y1 - H4 * X4^2 * Y2 - H4 * X4^2 * Y3 - 3 * H4 * X4^2 * Y4 - X2 * Y1 * Y2 - X2 * Y1 * Y3 + 2 * X2 * Y1 * Y4 - X2 * Y2^2 - X2 * Y2 * Y3 + 2 * X2 * Y2 * Y4 + 2 * X2 * Y3 * Y4 + 2 * X2 * Y4^2 + 2 * X4 * Y1 * Y2 + X4 * Y1 * Y3 - 3 * X4 * Y1 * Y4 + 2 * X4 * Y2^2 + 2 * X4 * Y2 * Y3 - 2 * X4 * Y2 * Y4 - 3 * X4 * Y3 * Y4 - 3 * X4 * Y4^2, E3 * H2 * Y3 - E3 * H2 * Y4 - E3 * H3 * H4 * Y3 + E3 * H3 * H4 * Y4 - E3 * H4^2 * X4 * Y3 + E3 * H4^2 * X4 * Y4 - E3 * H4 * Y3 * Y4 + E3 * H4 * Y4^2 + E4 * H3^2 * Y3 - E4 * H3^2 * Y4 + E4 * H3 * H4 * X4 * Y3 - E4 * H3 * H4 * X4 * Y4 + 4 * E4 * H3 * Y3 * Y4 - 4 * E4 * H3 * Y4^2 + E4 * H4 * X3 * Y2 * Y3 - E4 * H4 * X3 * Y2 * Y4 - E4 * H4 * X3 * Y3^2 + E4 * H4 * X3 * Y3 * Y4 - 2 * E4 * H4 * X4 * Y2 * Y3 + 2 * E4 * H4 * X4 * Y2 * Y4 + E4 * H4 * X4 * Y3^2 + 2 * E4 * H4 * X4 * Y3 * Y4 - 3 * E4 * H4 * X4 * Y4^2 - E4 * Y3^3 + 3 * E4 * Y3^2 * Y4 + E4 * Y3 * Y4^2 - 3 * E4 * Y4^3 + H3^2 * X3 - H3^2 * X4 - H3 * H4 * X3^2 + 5 * H3 * H4 * X3 * X4 - 4 * H3 * H4 * X4^2 - H3 * X3 * Y3 + 5 * H3 * X3 * Y4 + 3 * H3 * X4 * Y3 - 7 * H3 * X4 * Y4 - H4^2 * X1 * X2 * X3 + H4^2 * X1 * X2 * X4 - H4^2 * X1 * X3^2 + 4 * H4^2 * X1 * X3 * X4 - 3 * H4^2 * X1 * X4^2 + H4^2 * X2 * X3 * X4 - H4^2 * X2 * X4^2 - H4 * X1 * X3 * Y2 - H4 * X1 * X3 * Y3 + 2 * H4 * X1 * X3 * Y4 + H4 * X1 * X4 * Y2 + 2 * H4 * X1 * X4 * Y3 - 3 * H4 * X1 * X4 * Y4 - H4 * X2 * X3 * Y1 + H4 * X2 * X3 * Y4 + H4 * X2 * X4 * Y1 - H4 * X2 * X4 * Y4 - H4 * X3^2 * Y1 - H4 * X3^2 * Y3 + 4 * H4 * X3 * X4 * Y1 + H4 * X3 * X4 * Y2 + 3 * H4 * X3 * X4 * Y3 + 2 * H4 * X3 * X4 * Y4 - 3 * H4 * X4^2 * Y1 - H4 * X4^2 * Y2 - H4 * X4^2 * Y3 - 3 * H4 * X4^2 * Y4 - X3 * Y1 * Y2 - X3 * Y1 * Y3 + 2 * X3 * Y1 * Y4 - X3 * Y2 * Y3 + 2 * X3 * Y2 * Y4 - X3 * Y3^2 + 2 * X3 * Y3 * Y4 + 2 * X3 * Y4^2 + X4 * Y1 * Y2 + 2 * X4 * Y1 * Y3 - 3 * X4 * Y1 * Y4 + 2 * X4 * Y2 * Y3 - 3 * X4 * Y2 * Y4 + 2 * X4 * Y3^2 - 2 * X4 * Y3 * Y4 - 3 * X4 * Y4^2, E3 * H4^2 * X1 - E3 * H4^2 * X4 + E3 * H4 * Y1 - E3 * H4 * Y4 - E4 * H3 * H4 * X1 + E4 * H3 * H4 * X4 + E4 * H3 * Y1 - E4 * H3 * Y4 + E4 * H4 * X1 * Y1 - E4 * H4 * X1 * Y2 - E4 * H4 * X1 * Y3 - E4 * H4 * X1 * Y4 + E4 * H4 * X4 * Y1 + E4 * H4 * X4 * Y2 + E4 * H4 * X4 * Y3 - E4 * H4 * X4 * Y4 + E4 * Y1^2 - E4 * Y4^2 + 2 * H3 * X1 - 2 * H3 * X4 + H4 * X1^2 - H4 * X4^2 + X1 * Y1 + X1 * Y2 + X1 * Y3 + X1 * Y4 - X4 * Y1 - X4 * Y2 - X4 * Y3 - X4 * Y4, E3 * H4^2 * X2 - E3 * H4^2 * X4 + E3 * H4 * Y2 - E3 * H4 * Y4 - E4 * H3 * H4 * X2 + E4 * H3 * H4 * X4 + E4 * H3 * Y2 - E4 * H3 * Y4 - E4 * H4 * X2 * Y1 + E4 * H4 * X2 * Y2 - E4 * H4 * X2 * Y3 - E4 * H4 * X2 * Y4 + E4 * H4 * X4 * Y1 + E4 * H4 * X4 * Y2 + E4 * H4 * X4 * Y3 - E4 * H4 * X4 * Y4 + E4 * Y2^2 - E4 * Y4^2 + 2 * H3 * X2 - 2 * H3 * X4 + H4 * X2^2 - H4 * X4^2 + X2 * Y1 + X2 * Y2 + X2 * Y3 + X2 * Y4 - X4 * Y1 - X4 * Y2 - X4 * Y3 - X4 * Y4, E4 * H2 * Y1 - E4 * H2 * Y4 + E4 * H4 * Y1 * Y4 + E4 * H4 * Y2 * Y3 - E4 * H4 * Y2 * Y4 - E4 * H4 * Y3 * Y4 - H3 * H4 * X1 + H3 * H4 * X4 - 2 * H3 * Y1 + 2 * H3 * Y4 - H4^2 * X1 * X2 - H4^2 * X1 * X3 + H4^2 * X1 * X4 + H4^2 * X2 * X3 - H4 * X1 * Y1 - H4 * X1 * Y2 - H4 * X1 * Y3 + H4 * X1 * Y4 - H4 * X2 * Y1 + H4 * X2 * Y3 - H4 * X3 * Y1 + H4 * X3 * Y2 + H4 * X4 * Y1 + H4 * X4 * Y4 - Y1^2 - Y1 * Y2 - Y1 * Y3 + Y2 * Y4 + Y3 * Y4 + Y4^2, E4 * H2 * Y2 - E4 * H2 * Y4 + E4 * H4 * Y2 * Y3 - E4 * H4 * Y3 * Y4 - H3 * H4 * X2 + H3 * H4 * X4 - 2 * H3 * Y2 + 2 * H3 * Y4 - H4^2 * X1 * X2 + H4^2 * X1 * X4 - H4 * X1 * Y2 + H4 * X1 * Y4 - H4 * X2 * Y1 - H4 * X2 * Y2 + H4 * X4 * Y1 + H4 * X4 * Y4 - Y1 * Y2 + Y1 * Y4 - Y2^2 - Y2 * Y3 + Y3 * Y4 + Y4^2, H1 + H2 * X4 + H3 * Y4 + H4 * X4 * Y4 + Y4^2, H2 * X3 - H2 * X4 + H3 * Y3 - H3 * Y4 + H4 * X3 * Y3 - H4 * X4 * Y4 + Y3^2 - Y4^2, H2 * X2 - H2 * X4 + H3 * Y2 - H3 * Y4 + H4 * X2 * Y2 - H4 * X4 * Y4 + Y2^2 - Y4^2, H2 * X1 - H2 * X4 + H3 * Y1 - H3 * Y4 + H4 * X1 * Y1 - H4 * X4 * Y4 + Y1^2 - Y4^2, U23 * U24 * X3 - U23 * U24 * X4 + U23 * V24 * Y2 - U23 * V24 * Y4 - U23 - U24 * V23 * Y2 + U24 * V23 * Y3 + U24, U13 * U14 * X3 - U13 * U14 * X4 + U13 * V14 * Y1 - U13 * V14 * Y4 - U13 - U14 * V13 * Y1 + U14 * V13 * Y3 + U14, U12 * U14 * X2 - U12 * U14 * X4 + U12 * V14 * Y1 - U12 * V14 * Y4 - U12 - U14 * V12 * Y1 + U14 * V12 * Y2 + U14, U12 * U13 * X2 - U12 * U13 * X3 + U12 * V13 * Y1 - U12 * V13 * Y3 - U12 - U13 * V12 * Y1 + U13 * V12 * Y2 + U13, H3 * X2 * Y3 - H3 * X2 * Y4 - H3 * X3 * Y2 + H3 * X3 * Y4 + H3 * X4 * Y2 - H3 * X4 * Y3 - H4 * X2 * X3 * Y2 + H4 * X2 * X3 * Y3 + H4 * X2 * X4 * Y2 - H4 * X2 * X4 * Y4 - H4 * X3 * X4 * Y3 + H4 * X3 * X4 * Y4 + X2 * Y3^2 - X2 * Y4^2 - X3 * Y2^2 + X3 * Y4^2 + X4 * Y2^2 - X4 * Y3^2, H3 * X1 * Y3 - H3 * X1 * Y4 - H3 * X3 * Y1 + H3 * X3 * Y4 + H3 * X4 * Y1 - H3 * X4 * Y3 - H4 * X1 * X3 * Y1 + H4 * X1 * X3 * Y3 + H4 * X1 * X4 * Y1 - H4 * X1 * X4 * Y4 - H4 * X3 * X4 * Y3 + H4 * X3 * X4 * Y4 + X1 * Y3^2 - X1 * Y4^2 - X3 * Y1^2 + X3 * Y4^2 + X4 * Y1^2 - X4 * Y3^2, H3 * X1 * Y2 - H3 * X1 * Y4 - H3 * X2 * Y1 + H3 * X2 * Y4 + H3 * X4 * Y1 - H3 * X4 * Y2 - H4 * X1 * X2 * Y1 + H4 * X1 * X2 * Y2 + H4 * X1 * X4 * Y1 - H4 * X1 * X4 * Y4 - H4 * X2 * X4 * Y2 + H4 * X2 * X4 * Y4 + X1 * Y2^2 - X1 * Y4^2 - X2 * Y1^2 + X2 * Y4^2 + X4 * Y1^2 - X4 * Y2^2, E3 * X2 * Y3 - E3 * X2 * Y4 - E3 * X3 * Y2 + E3 * X3 * Y4 + E3 * X4 * Y2 - E3 * X4 * Y3 - E4 * X2 * X3 * Y2 + E4 * X2 * X3 * Y3 + E4 * X2 * X4 * Y2 - E4 * X2 * X4 * Y4 - E4 * X3 * X4 * Y3 + E4 * X3 * X4 * Y4 - X2^2 * X3 + X2^2 * X4 + X2 * X3^2 - X2 * X4^2 - X3^2 * X4 + X3 * X4^2, E3 * X1 * Y3 - E3 * X1 * Y4 - E3 * X3 * Y1 + E3 * X3 * Y4 + E3 * X4 * Y1 - E3 * X4 * Y3 - E4 * X1 * X3 * Y1 + E4 * X1 * X3 * Y3 + E4 * X1 * X4 * Y1 - E4 * X1 * X4 * Y4 - E4 * X3 * X4 * Y3 + E4 * X3 * X4 * Y4 - X1^2 * X3 + X1^2 * X4 + X1 * X3^2 - X1 * X4^2 - X3^2 * X4 + X3 * X4^2, E3 * X1 * Y2 - E3 * X1 * Y4 - E3 * X2 * Y1 + E3 * X2 * Y4 + E3 * X4 * Y1 - E3 * X4 * Y2 - E4 * X1 * X2 * Y1 + E4 * X1 * X2 * Y2 + E4 * X1 * X4 * Y1 - E4 * X1 * X4 * Y4 - E4 * X2 * X4 * Y2 + E4 * X2 * X4 * Y4 - X1^2 * X2 + X1^2 * X4 + X1 * X2^2 - X1 * X4^2 - X2^2 * X4 + X2 * X4^2, U34 * H3 * Y3 - U34 * H3 * Y4 + U34 * H4 * X4 * Y3 - U34 * H4 * X4 * Y4 + U34 * Y3^2 - U34 * Y4^2 - V34 * H2 * Y3 + V34 * H2 * Y4 - V34 * H4 * Y3^2 + V34 * H4 * Y3 * Y4 + H2 + H4 * Y3, U24 * H3 * Y2 - U24 * H3 * Y4 + U24 * H4 * X4 * Y2 - U24 * H4 * X4 * Y4 + U24 * Y2^2 - U24 * Y4^2 - V24 * H2 * Y2 + V24 * H2 * Y4 - V24 * H4 * Y2^2 + V24 * H4 * Y2 * Y4 + H2 + H4 * Y2, U23 * H3 * Y2 - U23 * H3 * Y3 + U23 * H4 * X3 * Y2 - U23 * H4 * X3 * Y3 + U23 * Y2^2 - U23 * Y3^2 - V23 * H2 * Y2 + V23 * H2 * Y3 - V23 * H4 * Y2^2 + V23 * H4 * Y2 * Y3 + H2 + H4 * Y2, U23 * U24 * V34 * Y3 - U23 * U24 * V34 * Y4 - U23 * U24 - U23 * U34 * V24 * Y2 + U23 * U34 * V24 * Y4 + U23 * U34 + U24 * U34 * V23 * Y2 - U24 * U34 * V23 * Y3 - U24 * U34, U14 * H3 * Y1 - U14 * H3 * Y4 + U14 * H4 * X4 * Y1 - U14 * H4 * X4 * Y4 + U14 * Y1^2 - U14 * Y4^2 - V14 * H2 * Y1 + V14 * H2 * Y4 - V14 * H4 * Y1^2 + V14 * H4 * Y1 * Y4 + H2 + H4 * Y1, U13 * H3 * Y1 - U13 * H3 * Y3 + U13 * H4 * X3 * Y1 - U13 * H4 * X3 * Y3 + U13 * Y1^2 - U13 * Y3^2 - V13 * H2 * Y1 + V13 * H2 * Y3 - V13 * H4 * Y1^2 + V13 * H4 * Y1 * Y3 + H2 + H4 * Y1, U13 * U14 * V34 * Y3 - U13 * U14 * V34 * Y4 - U13 * U14 - U13 * U34 * V14 * Y1 + U13 * U34 * V14 * Y4 + U13 * U34 + U14 * U34 * V13 * Y1 - U14 * U34 * V13 * Y3 - U14 * U34, U12 * H3 * Y1 - U12 * H3 * Y2 + U12 * H4 * X2 * Y1 - U12 * H4 * X2 * Y2 + U12 * Y1^2 - U12 * Y2^2 - V12 * H2 * Y1 + V12 * H2 * Y2 - V12 * H4 * Y1^2 + V12 * H4 * Y1 * Y2 + H2 + H4 * Y1, U12 * U14 * V24 * Y2 - U12 * U14 * V24 * Y4 - U12 * U14 - U12 * U24 * V14 * Y1 + U12 * U24 * V14 * Y4 + U12 * U24 + U14 * U24 * V12 * Y1 - U14 * U24 * V12 * Y2 - U14 * U24, U12 * U14 * U23 * X3 - U12 * U14 * U23 * X4 - U12 * U14 * V23 * Y2 + U12 * U14 * V23 * Y3 + U12 * U14 + U12 * U23 * V14 * Y1 - U12 * U23 * V14 * Y4 - U12 * U23 - U14 * U23 * V12 * Y1 + U14 * U23 * V12 * Y2 + U14 * U23, U12 * U13 * U24 * X3 - U12 * U13 * U24 * X4 + U12 * U13 * V24 * Y2 - U12 * U13 * V24 * Y4 - U12 * U13 - U12 * U24 * V13 * Y1 + U12 * U24 * V13 * Y3 + U12 * U24 + U13 * U24 * V12 * Y1 - U13 * U24 * V12 * Y2 - U13 * U24, U12 * U13 * V23 * Y2 - U12 * U13 * V23 * Y3 - U12 * U13 - U12 * U23 * V13 * Y1 + U12 * U23 * V13 * Y3 + U12 * U23 + U13 * U23 * V12 * Y1 - U13 * U23 * V12 * Y2 - U13 * U23, H4 * X1 * X2 * Y1 * Y3 - H4 * X1 * X2 * Y1 * Y4 - H4 * X1 * X2 * Y2 * Y3 + H4 * X1 * X2 * Y2 * Y4 - H4 * X1 * X3 * Y1 * Y2 + H4 * X1 * X3 * Y1 * Y4 + H4 * X1 * X3 * Y2 * Y3 - H4 * X1 * X3 * Y3 * Y4 + H4 * X1 * X4 * Y1 * Y2 - H4 * X1 * X4 * Y1 * Y3 - H4 * X1 * X4 * Y2 * Y4 + H4 * X1 * X4 * Y3 * Y4 + H4 * X2 * X3 * Y1 * Y2 - H4 * X2 * X3 * Y1 * Y3 - H4 * X2 * X3 * Y2 * Y4 + H4 * X2 * X3 * Y3 * Y4 - H4 * X2 * X4 * Y1 * Y2 + H4 * X2 * X4 * Y1 * Y4 + H4 * X2 * X4 * Y2 * Y3 - H4 * X2 * X4 * Y3 * Y4 + H4 * X3 * X4 * Y1 * Y3 - H4 * X3 * X4 * Y1 * Y4 - H4 * X3 * X4 * Y2 * Y3 + H4 * X3 * X4 * Y2 * Y4 - X1 * Y2^2 * Y3 + X1 * Y2^2 * Y4 + X1 * Y2 * Y3^2 - X1 * Y2 * Y4^2 - X1 * Y3^2 * Y4 + X1 * Y3 * Y4^2 + X2 * Y1^2 * Y3 - X2 * Y1^2 * Y4 - X2 * Y1 * Y3^2 + X2 * Y1 * Y4^2 + X2 * Y3^2 * Y4 - X2 * Y3 * Y4^2 - X3 * Y1^2 * Y2 + X3 * Y1^2 * Y4 + X3 * Y1 * Y2^2 - X3 * Y1 * Y4^2 - X3 * Y2^2 * Y4 + X3 * Y2 * Y4^2 + X4 * Y1^2 * Y2 - X4 * Y1^2 * Y3 - X4 * Y1 * Y2^2 + X4 * Y1 * Y3^2 + X4 * Y2^2 * Y3 - X4 * Y2 * Y3^2, E4 * Y1 * Y3 - E4 * Y1 * Y4 - E4 * Y2 * Y3 + E4 * Y2 * Y4 + H4 * X1 * X3 - H4 * X1 * X4 - H4 * X2 * X3 + H4 * X2 * X4 + X1 * Y3 - X1 * Y4 - X2 * Y3 + X2 * Y4 + X3 * Y1 - X3 * Y2 - X4 * Y1 + X4 * Y2, E4 * Y1 * Y2 - E4 * Y1 * Y4 - E4 * Y2 * Y3 + E4 * Y3 * Y4 + H4 * X1 * X2 - H4 * X1 * X4 - H4 * X2 * X3 + H4 * X3 * X4 + X1 * Y2 - X1 * Y4 + X2 * Y1 - X2 * Y3 - X3 * Y2 + X3 * Y4 - X4 * Y1 + X4 * Y3, U12 * U14 * U23 * V34 * Y3 - U12 * U14 * U23 * V34 * Y4 - U12 * U14 * U23 + U12 * U14 * U34 * V23 * Y2 - U12 * U14 * U34 * V23 * Y3 - U12 * U14 * U34 - U12 * U23 * U34 * V14 * Y1 + U12 * U23 * U34 * V14 * Y4 + U12 * U23 * U34 + U14 * U23 * U34 * V12 * Y1 - U14 * U23 * U34 * V12 * Y2 - U14 * U23 * U34, U12 * U13 * U24 * V34 * Y3 - U12 * U13 * U24 * V34 * Y4 - U12 * U13 * U24 - U12 * U13 * U34 * V24 * Y2 + U12 * U13 * U34 * V24 * Y4 + U12 * U13 * U34 + U12 * U24 * U34 * V13 * Y1 - U12 * U24 * U34 * V13 * Y3 - U12 * U24 * U34 - U13 * U24 * U34 * V12 * Y1 + U13 * U24 * U34 * V12 * Y2 + U13 * U24 * U34, U24 * H4 * X1 * X3 * Y1 * Y2 - U24 * H4 * X1 * X3 * Y1 * Y4 - U24 * H4 * X1 * X3 * Y2 * Y3 + U24 * H4 * X1 * X3 * Y3 * Y4 - U24 * H4 * X1 * X4 * Y1 * Y2 + U24 * H4 * X1 * X4 * Y1 * Y4 + U24 * H4 * X1 * X4 * Y2 * Y3 - U24 * H4 * X1 * X4 * Y3 * Y4 - U24 * H4 * X3 * X4 * Y1 * Y2 + U24 * H4 * X3 * X4 * Y1 * Y4 + U24 * H4 * X3 * X4 * Y2 * Y3 - U24 * H4 * X3 * X4 * Y3 * Y4 + U24 * H4 * X4^2 * Y1 * Y2 - U24 * H4 * X4^2 * Y1 * Y4 - U24 * H4 * X4^2 * Y2 * Y3 + U24 * H4 * X4^2 * Y3 * Y4 + U24 * X1 * Y2^2 * Y3 - U24 * X1 * Y2^2 * Y4 - U24 * X1 * Y2 * Y3^2 + U24 * X1 * Y2 * Y4^2 + U24 * X1 * Y3^2 * Y4 - U24 * X1 * Y3 * Y4^2 + U24 * X3 * Y1^2 * Y2 - U24 * X3 * Y1^2 * Y4 - U24 * X3 * Y1 * Y2^2 + U24 * X3 * Y1 * Y4^2 + U24 * X3 * Y2^2 * Y4 - U24 * X3 * Y2 * Y4^2 - U24 * X4 * Y1^2 * Y2 + U24 * X4 * Y1^2 * Y4 + U24 * X4 * Y1 * Y2^2 - U24 * X4 * Y1 * Y4^2 - U24 * X4 * Y2^2 * Y3 + U24 * X4 * Y2 * Y3^2 - U24 * X4 * Y3^2 * Y4 + U24 * X4 * Y3 * Y4^2 + V24 * H4 * X1 * Y1 * Y2 * Y3 - V24 * H4 * X1 * Y1 * Y2 * Y4 - V24 * H4 * X1 * Y1 * Y3 * Y4 + V24 * H4 * X1 * Y1 * Y4^2 - V24 * H4 * X1 * Y2^2 * Y3 + V24 * H4 * X1 * Y2^2 * Y4 + V24 * H4 * X1 * Y2 * Y3 * Y4 - V24 * H4 * X1 * Y2 * Y4^2 + V24 * H4 * X3 * Y1 * Y2^2 - V24 * H4 * X3 * Y1 * Y2 * Y3 - V24 * H4 * X3 * Y1 * Y2 * Y4 + V24 * H4 * X3 * Y1 * Y3 * Y4 - V24 * H4 * X3 * Y2^2 * Y4 + V24 * H4 * X3 * Y2 * Y3 * Y4 + V24 * H4 * X3 * Y2 * Y4^2 - V24 * H4 * X3 * Y3 * Y4^2 - V24 * H4 * X4 * Y1 * Y2^2 + 2 * V24 * H4 * X4 * Y1 * Y2 * Y4 - V24 * H4 * X4 * Y1 * Y4^2 + V24 * H4 * X4 * Y2^2 * Y3 - 2 * V24 * H4 * X4 * Y2 * Y3 * Y4 + V24 * H4 * X4 * Y3 * Y4^2 + V24 * Y1^2 * Y2 * Y3 - V24 * Y1^2 * Y2 * Y4 - V24 * Y1^2 * Y3 * Y4 + V24 * Y1^2 * Y4^2 - V24 * Y1 * Y2 * Y3^2 + V24 * Y1 * Y2 * Y4^2 + V24 * Y1 * Y3^2 * Y4 - V24 * Y1 * Y4^3 + V24 * Y2 * Y3^2 * Y4 - V24 * Y2 * Y3 * Y4^2 - V24 * Y3^2 * Y4^2 + V24 * Y3 * Y4^3 - H4 * X1 * Y1 * Y3 + H4 * X1 * Y1 * Y4 + H4 * X1 * Y2 * Y3 - H4 * X1 * Y2 * Y4 - H4 * X3 * Y1 * Y2 + H4 * X3 * Y1 * Y3 + H4 * X3 * Y2 * Y4 - H4 * X3 * Y3 * Y4 + H4 * X4 * Y1 * Y2 - H4 * X4 * Y1 * Y4 - H4 * X4 * Y2 * Y3 + H4 * X4 * Y3 * Y4 - Y1^2 * Y3 + Y1^2 * Y4 + Y1 * Y3^2 - Y1 * Y4^2 - Y3^2 * Y4 + Y3 * Y4^2, U24 * U34 * Y2^2 * Y3 - U24 * U34 * Y2^2 * Y4 - U24 * U34 * Y2 * Y3^2 + U24 * U34 * Y2 * Y4^2 + U24 * U34 * Y3^2 * Y4 - U24 * U34 * Y3 * Y4^2 + U24 * V34 * H2 * Y2 * Y3 - U24 * V34 * H2 * Y2 * Y4 - U24 * V34 * H2 * Y3 * Y4 + U24 * V34 * H2 * Y4^2 + U24 * V34 * H4 * Y2 * Y3^2 - U24 * V34 * H4 * Y2 * Y3 * Y4 - U24 * V34 * H4 * Y3^2 * Y4 + U24 * V34 * H4 * Y3 * Y4^2 - U24 * H2 * Y2 + U24 * H2 * Y4 - U24 * H4 * Y2 * Y3 + U24 * H4 * Y3 * Y4 - U34 * V24 * H2 * Y2 * Y3 + U34 * V24 * H2 * Y2 * Y4 + U34 * V24 * H2 * Y3 * Y4 - U34 * V24 * H2 * Y4^2 - U34 * V24 * H4 * Y2^2 * Y3 + U34 * V24 * H4 * Y2^2 * Y4 + U34 * V24 * H4 * Y2 * Y3 * Y4 - U34 * V24 * H4 * Y2 * Y4^2 + U34 * H2 * Y3 - U34 * H2 * Y4 + U34 * H4 * Y2 * Y3 - U34 * H4 * Y2 * Y4, U23 * H4 * X1 * X3 * Y1 * Y2 - U23 * H4 * X1 * X3 * Y1 * Y3 - U23 * H4 * X1 * X3 * Y2 * Y4 + U23 * H4 * X1 * X3 * Y3 * Y4 - U23 * H4 * X1 * X4 * Y1 * Y2 + U23 * H4 * X1 * X4 * Y1 * Y3 + U23 * H4 * X1 * X4 * Y2 * Y4 - U23 * H4 * X1 * X4 * Y3 * Y4 - U23 * H4 * X3^2 * Y1 * Y2 + U23 * H4 * X3^2 * Y1 * Y3 + U23 * H4 * X3^2 * Y2 * Y4 - U23 * H4 * X3^2 * Y3 * Y4 + U23 * H4 * X3 * X4 * Y1 * Y2 - U23 * H4 * X3 * X4 * Y1 * Y3 - U23 * H4 * X3 * X4 * Y2 * Y4 + U23 * H4 * X3 * X4 * Y3 * Y4 + U23 * X1 * Y2^2 * Y3 - U23 * X1 * Y2^2 * Y4 - U23 * X1 * Y2 * Y3^2 + U23 * X1 * Y2 * Y4^2 + U23 * X1 * Y3^2 * Y4 - U23 * X1 * Y3 * Y4^2 + U23 * X3 * Y1^2 * Y2 - U23 * X3 * Y1^2 * Y3 - U23 * X3 * Y1 * Y2^2 + U23 * X3 * Y1 * Y3^2 + U23 * X3 * Y2^2 * Y4 - U23 * X3 * Y2 * Y4^2 - U23 * X3 * Y3^2 * Y4 + U23 * X3 * Y3 * Y4^2 - U23 * X4 * Y1^2 * Y2 + U23 * X4 * Y1^2 * Y3 + U23 * X4 * Y1 * Y2^2 - U23 * X4 * Y1 * Y3^2 - U23 * X4 * Y2^2 * Y3 + U23 * X4 * Y2 * Y3^2 + V23 * H4 * X1 * Y1 * Y2 * Y3 - V23 * H4 * X1 * Y1 * Y2 * Y4 - V23 * H4 * X1 * Y1 * Y3^2 + V23 * H4 * X1 * Y1 * Y3 * Y4 - V23 * H4 * X1 * Y2^2 * Y3 + V23 * H4 * X1 * Y2^2 * Y4 + V23 * H4 * X1 * Y2 * Y3^2 - V23 * H4 * X1 * Y2 * Y3 * Y4 + V23 * H4 * X3 * Y1 * Y2^2 - 2 * V23 * H4 * X3 * Y1 * Y2 * Y3 + V23 * H4 * X3 * Y1 * Y3^2 - V23 * H4 * X3 * Y2^2 * Y4 + 2 * V23 * H4 * X3 * Y2 * Y3 * Y4 - V23 * H4 * X3 * Y3^2 * Y4 - V23 * H4 * X4 * Y1 * Y2^2 + V23 * H4 * X4 * Y1 * Y2 * Y3 + V23 * H4 * X4 * Y1 * Y2 * Y4 - V23 * H4 * X4 * Y1 * Y3 * Y4 + V23 * H4 * X4 * Y2^2 * Y3 - V23 * H4 * X4 * Y2 * Y3^2 - V23 * H4 * X4 * Y2 * Y3 * Y4 + V23 * H4 * X4 * Y3^2 * Y4 + V23 * Y1^2 * Y2 * Y3 - V23 * Y1^2 * Y2 * Y4 - V23 * Y1^2 * Y3^2 + V23 * Y1^2 * Y3 * Y4 - V23 * Y1 * Y2 * Y3^2 + V23 * Y1 * Y2 * Y4^2 + V23 * Y1 * Y3^3 - V23 * Y1 * Y3 * Y4^2 + V23 * Y2 * Y3^2 * Y4 - V23 * Y2 * Y3 * Y4^2 - V23 * Y3^3 * Y4 + V23 * Y3^2 * Y4^2 - H4 * X1 * Y1 * Y3 + H4 * X1 * Y1 * Y4 + H4 * X1 * Y2 * Y3 - H4 * X1 * Y2 * Y4 - H4 * X3 * Y1 * Y2 + H4 * X3 * Y1 * Y3 + H4 * X3 * Y2 * Y4 - H4 * X3 * Y3 * Y4 + H4 * X4 * Y1 * Y2 - H4 * X4 * Y1 * Y4 - H4 * X4 * Y2 * Y3 + H4 * X4 * Y3 * Y4 - Y1^2 * Y3 + Y1^2 * Y4 + Y1 * Y3^2 - Y1 * Y4^2 - Y3^2 * Y4 + Y3 * Y4^2, U23 * U34 * Y2^2 * Y3 - U23 * U34 * Y2^2 * Y4 - U23 * U34 * Y2 * Y3^2 + U23 * U34 * Y2 * Y4^2 + U23 * U34 * Y3^2 * Y4 - U23 * U34 * Y3 * Y4^2 + U23 * V34 * H2 * Y2 * Y3 - U23 * V34 * H2 * Y2 * Y4 - U23 * V34 * H2 * Y3^2 + U23 * V34 * H2 * Y3 * Y4 + U23 * V34 * H4 * Y2 * Y3 * Y4 - U23 * V34 * H4 * Y2 * Y4^2 - U23 * V34 * H4 * Y3^2 * Y4 + U23 * V34 * H4 * Y3 * Y4^2 - U23 * H2 * Y2 + U23 * H2 * Y3 - U23 * H4 * Y2 * Y4 + U23 * H4 * Y3 * Y4 - U34 * V23 * H2 * Y2 * Y3 + U34 * V23 * H2 * Y2 * Y4 + U34 * V23 * H2 * Y3^2 - U34 * V23 * H2 * Y3 * Y4 - U34 * V23 * H4 * Y2^2 * Y3 + U34 * V23 * H4 * Y2^2 * Y4 + U34 * V23 * H4 * Y2 * Y3^2 - U34 * V23 * H4 * Y2 * Y3 * Y4 + U34 * H2 * Y3 - U34 * H2 * Y4 + U34 * H4 * Y2 * Y3 - U34 * H4 * Y2 * Y4, U23 * U24 * H3 + U23 * U24 * H4 * X4 + U23 * U24 * Y3 + U23 * U24 * Y4 - U23 * U34 * V24 * Y2^2 + U23 * U34 * V24 * Y2 * Y3 + U23 * U34 * V24 * Y2 * Y4 - U23 * U34 * V24 * Y3 * Y4 - U23 * U34 * H3 - U23 * U34 * H4 * X4 - U23 * U34 * Y3 - U23 * U34 * Y4 - U23 * V24 * V34 * H2 * Y2 + U23 * V24 * V34 * H2 * Y3 - U23 * V24 * V34 * H4 * Y2 * Y4 + U23 * V24 * V34 * H4 * Y3 * Y4 - U23 * V24 * H2 - U23 * V24 * H4 * Y2 + U23 * V34 * H2 + U23 * V34 * H4 * Y3 + U24 * U34 * V23 * Y2^2 - U24 * U34 * V23 * Y2 * Y3 - U24 * U34 * V23 * Y2 * Y4 + U24 * U34 * V23 * Y3 * Y4 + U24 * U34 * H3 + U24 * U34 * H4 * X4 + U24 * U34 * Y3 + U24 * U34 * Y4 + U24 * V23 * V34 * H2 * Y2 - U24 * V23 * V34 * H2 * Y4 + U24 * V23 * V34 * H4 * Y2 * Y3 - U24 * V23 * V34 * H4 * Y3 * Y4 - U24 * V23 * H2 - U24 * V23 * H4 * Y3 - U24 * V34 * H2 - U24 * V34 * H4 * Y3 - U34 * V23 * V24 * H2 * Y3 + U34 * V23 * V24 * H2 * Y4 - U34 * V23 * V24 * H4 * Y2 * Y3 + U34 * V23 * V24 * H4 * Y2 * Y4 + U34 * V23 * H2 + U34 * V23 * H4 * Y2 - U34 * V24 * H2 - U34 * V24 * H4 * Y2, U14 * H4 * X2 * X3 * Y1 * Y2 - U14 * H4 * X2 * X3 * Y1 * Y3 - U14 * H4 * X2 * X3 * Y2 * Y4 + U14 * H4 * X2 * X3 * Y3 * Y4 - U14 * H4 * X2 * X4 * Y1 * Y2 + U14 * H4 * X2 * X4 * Y1 * Y3 + U14 * H4 * X2 * X4 * Y2 * Y4 - U14 * H4 * X2 * X4 * Y3 * Y4 - U14 * H4 * X3 * X4 * Y1 * Y2 + U14 * H4 * X3 * X4 * Y1 * Y3 + U14 * H4 * X3 * X4 * Y2 * Y4 - U14 * H4 * X3 * X4 * Y3 * Y4 + U14 * H4 * X4^2 * Y1 * Y2 - U14 * H4 * X4^2 * Y1 * Y3 - U14 * H4 * X4^2 * Y2 * Y4 + U14 * H4 * X4^2 * Y3 * Y4 + U14 * X2 * Y1^2 * Y3 - U14 * X2 * Y1^2 * Y4 - U14 * X2 * Y1 * Y3^2 + U14 * X2 * Y1 * Y4^2 + U14 * X2 * Y3^2 * Y4 - U14 * X2 * Y3 * Y4^2 - U14 * X3 * Y1^2 * Y2 + U14 * X3 * Y1^2 * Y4 + U14 * X3 * Y1 * Y2^2 - U14 * X3 * Y1 * Y4^2 - U14 * X3 * Y2^2 * Y4 + U14 * X3 * Y2 * Y4^2 + U14 * X4 * Y1^2 * Y2 - U14 * X4 * Y1^2 * Y3 - U14 * X4 * Y1 * Y2^2 + U14 * X4 * Y1 * Y3^2 + U14 * X4 * Y2^2 * Y4 - U14 * X4 * Y2 * Y4^2 - U14 * X4 * Y3^2 * Y4 + U14 * X4 * Y3 * Y4^2 - V14 * H4 * X2 * Y1^2 * Y3 + V14 * H4 * X2 * Y1^2 * Y4 + V14 * H4 * X2 * Y1 * Y2 * Y3 - V14 * H4 * X2 * Y1 * Y2 * Y4 + V14 * H4 * X2 * Y1 * Y3 * Y4 - V14 * H4 * X2 * Y1 * Y4^2 - V14 * H4 * X2 * Y2 * Y3 * Y4 + V14 * H4 * X2 * Y2 * Y4^2 + V14 * H4 * X3 * Y1^2 * Y2 - V14 * H4 * X3 * Y1^2 * Y4 - V14 * H4 * X3 * Y1 * Y2 * Y3 - V14 * H4 * X3 * Y1 * Y2 * Y4 + V14 * H4 * X3 * Y1 * Y3 * Y4 + V14 * H4 * X3 * Y1 * Y4^2 + V14 * H4 * X3 * Y2 * Y3 * Y4 - V14 * H4 * X3 * Y3 * Y4^2 - V14 * H4 * X4 * Y1^2 * Y2 + V14 * H4 * X4 * Y1^2 * Y3 + 2 * V14 * H4 * X4 * Y1 * Y2 * Y4 - 2 * V14 * H4 * X4 * Y1 * Y3 * Y4 - V14 * H4 * X4 * Y2 * Y4^2 + V14 * H4 * X4 * Y3 * Y4^2 + V14 * Y1 * Y2^2 * Y3 - V14 * Y1 * Y2^2 * Y4 - V14 * Y1 * Y2 * Y3^2 + V14 * Y1 * Y2 * Y4^2 + V14 * Y1 * Y3^2 * Y4 - V14 * Y1 * Y3 * Y4^2 - V14 * Y2^2 * Y3 * Y4 + V14 * Y2^2 * Y4^2 + V14 * Y2 * Y3^2 * Y4 - V14 * Y2 * Y4^3 - V14 * Y3^2 * Y4^2 + V14 * Y3 * Y4^3 + H4 * X2 * Y1 * Y3 - H4 * X2 * Y1 * Y4 - H4 * X2 * Y2 * Y3 + H4 * X2 * Y2 * Y4 - H4 * X3 * Y1 * Y2 + H4 * X3 * Y1 * Y4 + H4 * X3 * Y2 * Y3 - H4 * X3 * Y3 * Y4 + H4 * X4 * Y1 * Y2 - H4 * X4 * Y1 * Y3 - H4 * X4 * Y2 * Y4 + H4 * X4 * Y3 * Y4 - Y2^2 * Y3 + Y2^2 * Y4 + Y2 * Y3^2 - Y2 * Y4^2 - Y3^2 * Y4 + Y3 * Y4^2, U14 * U34 * Y1^2 * Y3 - U14 * U34 * Y1^2 * Y4 - U14 * U34 * Y1 * Y3^2 + U14 * U34 * Y1 * Y4^2 + U14 * U34 * Y3^2 * Y4 - U14 * U34 * Y3 * Y4^2 + U14 * V34 * H2 * Y1 * Y3 - U14 * V34 * H2 * Y1 * Y4 - U14 * V34 * H2 * Y3 * Y4 + U14 * V34 * H2 * Y4^2 + U14 * V34 * H4 * Y1 * Y3^2 - U14 * V34 * H4 * Y1 * Y3 * Y4 - U14 * V34 * H4 * Y3^2 * Y4 + U14 * V34 * H4 * Y3 * Y4^2 - U14 * H2 * Y1 + U14 * H2 * Y4 - U14 * H4 * Y1 * Y3 + U14 * H4 * Y3 * Y4 - U34 * V14 * H2 * Y1 * Y3 + U34 * V14 * H2 * Y1 * Y4 + U34 * V14 * H2 * Y3 * Y4 - U34 * V14 * H2 * Y4^2 - U34 * V14 * H4 * Y1^2 * Y3 + U34 * V14 * H4 * Y1^2 * Y4 + U34 * V14 * H4 * Y1 * Y3 * Y4 - U34 * V14 * H4 * Y1 * Y4^2 + U34 * H2 * Y3 - U34 * H2 * Y4 + U34 * H4 * Y1 * Y3 - U34 * H4 * Y1 * Y4, U14 * U24 * Y1^2 * Y2 - U14 * U24 * Y1^2 * Y4 - U14 * U24 * Y1 * Y2^2 + U14 * U24 * Y1 * Y4^2 + U14 * U24 * Y2^2 * Y4 - U14 * U24 * Y2 * Y4^2 + U14 * V24 * H2 * Y1 * Y2 - U14 * V24 * H2 * Y1 * Y4 - U14 * V24 * H2 * Y2 * Y4 + U14 * V24 * H2 * Y4^2 + U14 * V24 * H4 * Y1 * Y2^2 - U14 * V24 * H4 * Y1 * Y2 * Y4 - U14 * V24 * H4 * Y2^2 * Y4 + U14 * V24 * H4 * Y2 * Y4^2 - U14 * H2 * Y1 + U14 * H2 * Y4 - U14 * H4 * Y1 * Y2 + U14 * H4 * Y2 * Y4 - U24 * V14 * H2 * Y1 * Y2 + U24 * V14 * H2 * Y1 * Y4 + U24 * V14 * H2 * Y2 * Y4 - U24 * V14 * H2 * Y4^2 - U24 * V14 * H4 * Y1^2 * Y2 + U24 * V14 * H4 * Y1^2 * Y4 + U24 * V14 * H4 * Y1 * Y2 * Y4 - U24 * V14 * H4 * Y1 * Y4^2 + U24 * H2 * Y2 - U24 * H2 * Y4 + U24 * H4 * Y1 * Y2 - U24 * H4 * Y1 * Y4, U14 * U23 * H4 * X3 * Y1 * Y2 - U14 * U23 * H4 * X3 * Y1 * Y3 - U14 * U23 * H4 * X3 * Y2 * Y4 + U14 * U23 * H4 * X3 * Y3 * Y4 - U14 * U23 * H4 * X4 * Y1 * Y2 + U14 * U23 * H4 * X4 * Y1 * Y3 + U14 * U23 * H4 * X4 * Y2 * Y4 - U14 * U23 * H4 * X4 * Y3 * Y4 - U14 * U23 * Y1^2 * Y2 + U14 * U23 * Y1^2 * Y3 + U14 * U23 * Y1 * Y2^2 - U14 * U23 * Y1 * Y3^2 - U14 * U23 * Y2^2 * Y4 + U14 * U23 * Y2 * Y4^2 + U14 * U23 * Y3^2 * Y4 - U14 * U23 * Y3 * Y4^2 - U14 * V23 * H2 * Y1 * Y2 + U14 * V23 * H2 * Y1 * Y3 + U14 * V23 * H2 * Y2 * Y4 - U14 * V23 * H2 * Y3 * Y4 - U14 * V23 * H4 * Y1 * Y2^2 + U14 * V23 * H4 * Y1 * Y2 * Y3 + U14 * V23 * H4 * Y2^2 * Y4 - U14 * V23 * H4 * Y2 * Y3 * Y4 + U14 * H2 * Y1 - U14 * H2 * Y4 + U14 * H4 * Y1 * Y2 - U14 * H4 * Y2 * Y4 + U23 * V14 * H2 * Y1 * Y2 - U23 * V14 * H2 * Y1 * Y3 - U23 * V14 * H2 * Y2 * Y4 + U23 * V14 * H2 * Y3 * Y4 + U23 * V14 * H4 * Y1^2 * Y2 - U23 * V14 * H4 * Y1^2 * Y3 - U23 * V14 * H4 * Y1 * Y2 * Y4 + U23 * V14 * H4 * Y1 * Y3 * Y4 - U23 * H2 * Y2 + U23 * H2 * Y3 - U23 * H4 * Y1 * Y2 + U23 * H4 * Y1 * Y3, U13 * H4 * X2 * X3 * Y1 * Y2 - U13 * H4 * X2 * X3 * Y1 * Y4 - U13 * H4 * X2 * X3 * Y2 * Y3 + U13 * H4 * X2 * X3 * Y3 * Y4 - U13 * H4 * X2 * X4 * Y1 * Y2 + U13 * H4 * X2 * X4 * Y1 * Y4 + U13 * H4 * X2 * X4 * Y2 * Y3 - U13 * H4 * X2 * X4 * Y3 * Y4 - U13 * H4 * X3^2 * Y1 * Y2 + U13 * H4 * X3^2 * Y1 * Y4 + U13 * H4 * X3^2 * Y2 * Y3 - U13 * H4 * X3^2 * Y3 * Y4 + U13 * H4 * X3 * X4 * Y1 * Y2 - U13 * H4 * X3 * X4 * Y1 * Y4 - U13 * H4 * X3 * X4 * Y2 * Y3 + U13 * H4 * X3 * X4 * Y3 * Y4 + U13 * X2 * Y1^2 * Y3 - U13 * X2 * Y1^2 * Y4 - U13 * X2 * Y1 * Y3^2 + U13 * X2 * Y1 * Y4^2 + U13 * X2 * Y3^2 * Y4 - U13 * X2 * Y3 * Y4^2 - U13 * X3 * Y1^2 * Y2 + U13 * X3 * Y1^2 * Y4 + U13 * X3 * Y1 * Y2^2 - U13 * X3 * Y1 * Y4^2 - U13 * X3 * Y2^2 * Y3 + U13 * X3 * Y2 * Y3^2 - U13 * X3 * Y3^2 * Y4 + U13 * X3 * Y3 * Y4^2 + U13 * X4 * Y1^2 * Y2 - U13 * X4 * Y1^2 * Y3 - U13 * X4 * Y1 * Y2^2 + U13 * X4 * Y1 * Y3^2 + U13 * X4 * Y2^2 * Y3 - U13 * X4 * Y2 * Y3^2 - V13 * H4 * X2 * Y1^2 * Y3 + V13 * H4 * X2 * Y1^2 * Y4 + V13 * H4 * X2 * Y1 * Y2 * Y3 - V13 * H4 * X2 * Y1 * Y2 * Y4 + V13 * H4 * X2 * Y1 * Y3^2 - V13 * H4 * X2 * Y1 * Y3 * Y4 - V13 * H4 * X2 * Y2 * Y3^2 + V13 * H4 * X2 * Y2 * Y3 * Y4 + V13 * H4 * X3 * Y1^2 * Y2 - V13 * H4 * X3 * Y1^2 * Y4 - 2 * V13 * H4 * X3 * Y1 * Y2 * Y3 + 2 * V13 * H4 * X3 * Y1 * Y3 * Y4 + V13 * H4 * X3 * Y2 * Y3^2 - V13 * H4 * X3 * Y3^2 * Y4 - V13 * H4 * X4 * Y1^2 * Y2 + V13 * H4 * X4 * Y1^2 * Y3 + V13 * H4 * X4 * Y1 * Y2 * Y3 + V13 * H4 * X4 * Y1 * Y2 * Y4 - V13 * H4 * X4 * Y1 * Y3^2 - V13 * H4 * X4 * Y1 * Y3 * Y4 - V13 * H4 * X4 * Y2 * Y3 * Y4 + V13 * H4 * X4 * Y3^2 * Y4 + V13 * Y1 * Y2^2 * Y3 - V13 * Y1 * Y2^2 * Y4 - V13 * Y1 * Y2 * Y3^2 + V13 * Y1 * Y2 * Y4^2 + V13 * Y1 * Y3^2 * Y4 - V13 * Y1 * Y3 * Y4^2 - V13 * Y2^2 * Y3^2 + V13 * Y2^2 * Y3 * Y4 + V13 * Y2 * Y3^3 - V13 * Y2 * Y3 * Y4^2 - V13 * Y3^3 * Y4 + V13 * Y3^2 * Y4^2 + H4 * X2 * Y1 * Y3 - H4 * X2 * Y1 * Y4 - H4 * X2 * Y2 * Y3 + H4 * X2 * Y2 * Y4 - H4 * X3 * Y1 * Y2 + H4 * X3 * Y1 * Y4 + H4 * X3 * Y2 * Y3 - H4 * X3 * Y3 * Y4 + H4 * X4 * Y1 * Y2 - H4 * X4 * Y1 * Y3 - H4 * X4 * Y2 * Y4 + H4 * X4 * Y3 * Y4 - Y2^2 * Y3 + Y2^2 * Y4 + Y2 * Y3^2 - Y2 * Y4^2 - Y3^2 * Y4 + Y3 * Y4^2, U13 * U34 * Y1^2 * Y3 - U13 * U34 * Y1^2 * Y4 - U13 * U34 * Y1 * Y3^2 + U13 * U34 * Y1 * Y4^2 + U13 * U34 * Y3^2 * Y4 - U13 * U34 * Y3 * Y4^2 + U13 * V34 * H2 * Y1 * Y3 - U13 * V34 * H2 * Y1 * Y4 - U13 * V34 * H2 * Y3^2 + U13 * V34 * H2 * Y3 * Y4 + U13 * V34 * H4 * Y1 * Y3 * Y4 - U13 * V34 * H4 * Y1 * Y4^2 - U13 * V34 * H4 * Y3^2 * Y4 + U13 * V34 * H4 * Y3 * Y4^2 - U13 * H2 * Y1 + U13 * H2 * Y3 - U13 * H4 * Y1 * Y4 + U13 * H4 * Y3 * Y4 - U34 * V13 * H2 * Y1 * Y3 + U34 * V13 * H2 * Y1 * Y4 + U34 * V13 * H2 * Y3^2 - U34 * V13 * H2 * Y3 * Y4 - U34 * V13 * H4 * Y1^2 * Y3 + U34 * V13 * H4 * Y1^2 * Y4 + U34 * V13 * H4 * Y1 * Y3^2 - U34 * V13 * H4 * Y1 * Y3 * Y4 + U34 * H2 * Y3 - U34 * H2 * Y4 + U34 * H4 * Y1 * Y3 - U34 * H4 * Y1 * Y4, U13 * U24 * H4 * X3 * Y1 * Y2 - U13 * U24 * H4 * X3 * Y1 * Y4 - U13 * U24 * H4 * X3 * Y2 * Y3 + U13 * U24 * H4 * X3 * Y3 * Y4 - U13 * U24 * H4 * X4 * Y1 * Y2 + U13 * U24 * H4 * X4 * Y1 * Y4 + U13 * U24 * H4 * X4 * Y2 * Y3 - U13 * U24 * H4 * X4 * Y3 * Y4 + U13 * U24 * Y1^2 * Y2 - U13 * U24 * Y1^2 * Y4 - U13 * U24 * Y1 * Y2^2 + U13 * U24 * Y1 * Y4^2 + U13 * U24 * Y2^2 * Y3 - U13 * U24 * Y2 * Y3^2 + U13 * U24 * Y3^2 * Y4 - U13 * U24 * Y3 * Y4^2 + U13 * V24 * H2 * Y1 * Y2 - U13 * V24 * H2 * Y1 * Y4 - U13 * V24 * H2 * Y2 * Y3 + U13 * V24 * H2 * Y3 * Y4 + U13 * V24 * H4 * Y1 * Y2^2 - U13 * V24 * H4 * Y1 * Y2 * Y4 - U13 * V24 * H4 * Y2^2 * Y3 + U13 * V24 * H4 * Y2 * Y3 * Y4 - U13 * H2 * Y1 + U13 * H2 * Y3 - U13 * H4 * Y1 * Y2 + U13 * H4 * Y2 * Y3 - U24 * V13 * H2 * Y1 * Y2 + U24 * V13 * H2 * Y1 * Y4 + U24 * V13 * H2 * Y2 * Y3 - U24 * V13 * H2 * Y3 * Y4 - U24 * V13 * H4 * Y1^2 * Y2 + U24 * V13 * H4 * Y1^2 * Y4 + U24 * V13 * H4 * Y1 * Y2 * Y3 - U24 * V13 * H4 * Y1 * Y3 * Y4 + U24 * H2 * Y2 - U24 * H2 * Y4 + U24 * H4 * Y1 * Y2 - U24 * H4 * Y1 * Y4, U13 * U23 * Y1^2 * Y2 - U13 * U23 * Y1^2 * Y3 - U13 * U23 * Y1 * Y2^2 + U13 * U23 * Y1 * Y3^2 + U13 * U23 * Y2^2 * Y3 - U13 * U23 * Y2 * Y3^2 + U13 * V23 * H2 * Y1 * Y2 - U13 * V23 * H2 * Y1 * Y3 - U13 * V23 * H2 * Y2 * Y3 + U13 * V23 * H2 * Y3^2 + U13 * V23 * H4 * Y1 * Y2^2 - U13 * V23 * H4 * Y1 * Y2 * Y3 - U13 * V23 * H4 * Y2^2 * Y3 + U13 * V23 * H4 * Y2 * Y3^2 - U13 * H2 * Y1 + U13 * H2 * Y3 - U13 * H4 * Y1 * Y2 + U13 * H4 * Y2 * Y3 - U23 * V13 * H2 * Y1 * Y2 + U23 * V13 * H2 * Y1 * Y3 + U23 * V13 * H2 * Y2 * Y3 - U23 * V13 * H2 * Y3^2 - U23 * V13 * H4 * Y1^2 * Y2 + U23 * V13 * H4 * Y1^2 * Y3 + U23 * V13 * H4 * Y1 * Y2 * Y3 - U23 * V13 * H4 * Y1 * Y3^2 + U23 * H2 * Y2 - U23 * H2 * Y3 + U23 * H4 * Y1 * Y2 - U23 * H4 * Y1 * Y3, U13 * U14 * H3 + U13 * U14 * H4 * X4 + U13 * U14 * Y3 + U13 * U14 * Y4 - U13 * U34 * V14 * Y1^2 + U13 * U34 * V14 * Y1 * Y3 + U13 * U34 * V14 * Y1 * Y4 - U13 * U34 * V14 * Y3 * Y4 - U13 * U34 * H3 - U13 * U34 * H4 * X4 - U13 * U34 * Y3 - U13 * U34 * Y4 - U13 * V14 * V34 * H2 * Y1 + U13 * V14 * V34 * H2 * Y3 - U13 * V14 * V34 * H4 * Y1 * Y4 + U13 * V14 * V34 * H4 * Y3 * Y4 - U13 * V14 * H2 - U13 * V14 * H4 * Y1 + U13 * V34 * H2 + U13 * V34 * H4 * Y3 + U14 * U34 * V13 * Y1^2 - U14 * U34 * V13 * Y1 * Y3 - U14 * U34 * V13 * Y1 * Y4 + U14 * U34 * V13 * Y3 * Y4 + U14 * U34 * H3 + U14 * U34 * H4 * X4 + U14 * U34 * Y3 + U14 * U34 * Y4 + U14 * V13 * V34 * H2 * Y1 - U14 * V13 * V34 * H2 * Y4 + U14 * V13 * V34 * H4 * Y1 * Y3 - U14 * V13 * V34 * H4 * Y3 * Y4 - U14 * V13 * H2 - U14 * V13 * H4 * Y3 - U14 * V34 * H2 - U14 * V34 * H4 * Y3 - U34 * V13 * V14 * H2 * Y3 + U34 * V13 * V14 * H2 * Y4 - U34 * V13 * V14 * H4 * Y1 * Y3 + U34 * V13 * V14 * H4 * Y1 * Y4 + U34 * V13 * H2 + U34 * V13 * H4 * Y1 - U34 * V14 * H2 - U34 * V14 * H4 * Y1, U12 * H4 * X2^2 * Y1 * Y3 - U12 * H4 * X2^2 * Y1 * Y4 - U12 * H4 * X2^2 * Y2 * Y3 + U12 * H4 * X2^2 * Y2 * Y4 - U12 * H4 * X2 * X3 * Y1 * Y3 + U12 * H4 * X2 * X3 * Y1 * Y4 + U12 * H4 * X2 * X3 * Y2 * Y3 - U12 * H4 * X2 * X3 * Y2 * Y4 - U12 * H4 * X2 * X4 * Y1 * Y3 + U12 * H4 * X2 * X4 * Y1 * Y4 + U12 * H4 * X2 * X4 * Y2 * Y3 - U12 * H4 * X2 * X4 * Y2 * Y4 + U12 * H4 * X3 * X4 * Y1 * Y3 - U12 * H4 * X3 * X4 * Y1 * Y4 - U12 * H4 * X3 * X4 * Y2 * Y3 + U12 * H4 * X3 * X4 * Y2 * Y4 + U12 * X2 * Y1^2 * Y3 - U12 * X2 * Y1^2 * Y4 - U12 * X2 * Y1 * Y3^2 + U12 * X2 * Y1 * Y4^2 - U12 * X2 * Y2^2 * Y3 + U12 * X2 * Y2^2 * Y4 + U12 * X2 * Y2 * Y3^2 - U12 * X2 * Y2 * Y4^2 - U12 * X3 * Y1^2 * Y2 + U12 * X3 * Y1^2 * Y4 + U12 * X3 * Y1 * Y2^2 - U12 * X3 * Y1 * Y4^2 - U12 * X3 * Y2^2 * Y4 + U12 * X3 * Y2 * Y4^2 + U12 * X4 * Y1^2 * Y2 - U12 * X4 * Y1^2 * Y3 - U12 * X4 * Y1 * Y2^2 + U12 * X4 * Y1 * Y3^2 + U12 * X4 * Y2^2 * Y3 - U12 * X4 * Y2 * Y3^2 - V12 * H4 * X2 * Y1^2 * Y3 + V12 * H4 * X2 * Y1^2 * Y4 + 2 * V12 * H4 * X2 * Y1 * Y2 * Y3 - 2 * V12 * H4 * X2 * Y1 * Y2 * Y4 - V12 * H4 * X2 * Y2^2 * Y3 + V12 * H4 * X2 * Y2^2 * Y4 + V12 * H4 * X3 * Y1^2 * Y2 - V12 * H4 * X3 * Y1^2 * Y4 - V12 * H4 * X3 * Y1 * Y2^2 - V12 * H4 * X3 * Y1 * Y2 * Y3 + V12 * H4 * X3 * Y1 * Y2 * Y4 + V12 * H4 * X3 * Y1 * Y3 * Y4 + V12 * H4 * X3 * Y2^2 * Y3 - V12 * H4 * X3 * Y2 * Y3 * Y4 - V12 * H4 * X4 * Y1^2 * Y2 + V12 * H4 * X4 * Y1^2 * Y3 + V12 * H4 * X4 * Y1 * Y2^2 - V12 * H4 * X4 * Y1 * Y2 * Y3 + V12 * H4 * X4 * Y1 * Y2 * Y4 - V12 * H4 * X4 * Y1 * Y3 * Y4 - V12 * H4 * X4 * Y2^2 * Y4 + V12 * H4 * X4 * Y2 * Y3 * Y4 + V12 * Y1 * Y2^2 * Y3 - V12 * Y1 * Y2^2 * Y4 - V12 * Y1 * Y2 * Y3^2 + V12 * Y1 * Y2 * Y4^2 + V12 * Y1 * Y3^2 * Y4 - V12 * Y1 * Y3 * Y4^2 - V12 * Y2^3 * Y3 + V12 * Y2^3 * Y4 + V12 * Y2^2 * Y3^2 - V12 * Y2^2 * Y4^2 - V12 * Y2 * Y3^2 * Y4 + V12 * Y2 * Y3 * Y4^2 + H4 * X2 * Y1 * Y3 - H4 * X2 * Y1 * Y4 - H4 * X2 * Y2 * Y3 + H4 * X2 * Y2 * Y4 - H4 * X3 * Y1 * Y2 + H4 * X3 * Y1 * Y4 + H4 * X3 * Y2 * Y3 - H4 * X3 * Y3 * Y4 + H4 * X4 * Y1 * Y2 - H4 * X4 * Y1 * Y3 - H4 * X4 * Y2 * Y4 + H4 * X4 * Y3 * Y4 - Y2^2 * Y3 + Y2^2 * Y4 + Y2 * Y3^2 - Y2 * Y4^2 - Y3^2 * Y4 + Y3 * Y4^2, U12 * U34 * H4 * X2 * Y1 * Y3 - U12 * U34 * H4 * X2 * Y1 * Y4 - U12 * U34 * H4 * X2 * Y2 * Y3 + U12 * U34 * H4 * X2 * Y2 * Y4 - U12 * U34 * H4 * X4 * Y1 * Y3 + U12 * U34 * H4 * X4 * Y1 * Y4 + U12 * U34 * H4 * X4 * Y2 * Y3 - U12 * U34 * H4 * X4 * Y2 * Y4 + U12 * U34 * Y1^2 * Y3 - U12 * U34 * Y1^2 * Y4 - U12 * U34 * Y1 * Y3^2 + U12 * U34 * Y1 * Y4^2 - U12 * U34 * Y2^2 * Y3 + U12 * U34 * Y2^2 * Y4 + U12 * U34 * Y2 * Y3^2 - U12 * U34 * Y2 * Y4^2 + U12 * V34 * H2 * Y1 * Y3 - U12 * V34 * H2 * Y1 * Y4 - U12 * V34 * H2 * Y2 * Y3 + U12 * V34 * H2 * Y2 * Y4 + U12 * V34 * H4 * Y1 * Y3^2 - U12 * V34 * H4 * Y1 * Y3 * Y4 - U12 * V34 * H4 * Y2 * Y3^2 + U12 * V34 * H4 * Y2 * Y3 * Y4 - U12 * H2 * Y1 + U12 * H2 * Y2 - U12 * H4 * Y1 * Y3 + U12 * H4 * Y2 * Y3 - U34 * V12 * H2 * Y1 * Y3 + U34 * V12 * H2 * Y1 * Y4 + U34 * V12 * H2 * Y2 * Y3 - U34 * V12 * H2 * Y2 * Y4 - U34 * V12 * H4 * Y1^2 * Y3 + U34 * V12 * H4 * Y1^2 * Y4 + U34 * V12 * H4 * Y1 * Y2 * Y3 - U34 * V12 * H4 * Y1 * Y2 * Y4 + U34 * H2 * Y3 - U34 * H2 * Y4 + U34 * H4 * Y1 * Y3 - U34 * H4 * Y1 * Y4, U12 * U24 * Y1^2 * Y2 - U12 * U24 * Y1^2 * Y4 - U12 * U24 * Y1 * Y2^2 + U12 * U24 * Y1 * Y4^2 + U12 * U24 * Y2^2 * Y4 - U12 * U24 * Y2 * Y4^2 + U12 * V24 * H2 * Y1 * Y2 - U12 * V24 * H2 * Y1 * Y4 - U12 * V24 * H2 * Y2^2 + U12 * V24 * H2 * Y2 * Y4 + U12 * V24 * H4 * Y1 * Y2 * Y4 - U12 * V24 * H4 * Y1 * Y4^2 - U12 * V24 * H4 * Y2^2 * Y4 + U12 * V24 * H4 * Y2 * Y4^2 - U12 * H2 * Y1 + U12 * H2 * Y2 - U12 * H4 * Y1 * Y4 + U12 * H4 * Y2 * Y4 - U24 * V12 * H2 * Y1 * Y2 + U24 * V12 * H2 * Y1 * Y4 + U24 * V12 * H2 * Y2^2 - U24 * V12 * H2 * Y2 * Y4 - U24 * V12 * H4 * Y1^2 * Y2 + U24 * V12 * H4 * Y1^2 * Y4 + U24 * V12 * H4 * Y1 * Y2^2 - U24 * V12 * H4 * Y1 * Y2 * Y4 + U24 * H2 * Y2 - U24 * H2 * Y4 + U24 * H4 * Y1 * Y2 - U24 * H4 * Y1 * Y4, U12 * U23 * Y1^2 * Y2 - U12 * U23 * Y1^2 * Y3 - U12 * U23 * Y1 * Y2^2 + U12 * U23 * Y1 * Y3^2 + U12 * U23 * Y2^2 * Y3 - U12 * U23 * Y2 * Y3^2 + U12 * V23 * H2 * Y1 * Y2 - U12 * V23 * H2 * Y1 * Y3 - U12 * V23 * H2 * Y2^2 + U12 * V23 * H2 * Y2 * Y3 + U12 * V23 * H4 * Y1 * Y2 * Y3 - U12 * V23 * H4 * Y1 * Y3^2 - U12 * V23 * H4 * Y2^2 * Y3 + U12 * V23 * H4 * Y2 * Y3^2 - U12 * H2 * Y1 + U12 * H2 * Y2 - U12 * H4 * Y1 * Y3 + U12 * H4 * Y2 * Y3 - U23 * V12 * H2 * Y1 * Y2 + U23 * V12 * H2 * Y1 * Y3 + U23 * V12 * H2 * Y2^2 - U23 * V12 * H2 * Y2 * Y3 - U23 * V12 * H4 * Y1^2 * Y2 + U23 * V12 * H4 * Y1^2 * Y3 + U23 * V12 * H4 * Y1 * Y2^2 - U23 * V12 * H4 * Y1 * Y2 * Y3 + U23 * H2 * Y2 - U23 * H2 * Y3 + U23 * H4 * Y1 * Y2 - U23 * H4 * Y1 * Y3, U12 * U14 * H3 + U12 * U14 * H4 * X4 + U12 * U14 * Y2 + U12 * U14 * Y4 - U12 * U24 * V14 * Y1^2 + U12 * U24 * V14 * Y1 * Y2 + U12 * U24 * V14 * Y1 * Y4 - U12 * U24 * V14 * Y2 * Y4 - U12 * U24 * H3 - U12 * U24 * H4 * X4 - U12 * U24 * Y2 - U12 * U24 * Y4 - U12 * V14 * V24 * H2 * Y1 + U12 * V14 * V24 * H2 * Y2 - U12 * V14 * V24 * H4 * Y1 * Y4 + U12 * V14 * V24 * H4 * Y2 * Y4 - U12 * V14 * H2 - U12 * V14 * H4 * Y1 + U12 * V24 * H2 + U12 * V24 * H4 * Y2 + U14 * U24 * V12 * Y1^2 - U14 * U24 * V12 * Y1 * Y2 - U14 * U24 * V12 * Y1 * Y4 + U14 * U24 * V12 * Y2 * Y4 + U14 * U24 * H3 + U14 * U24 * H4 * X4 + U14 * U24 * Y2 + U14 * U24 * Y4 + U14 * V12 * V24 * H2 * Y1 - U14 * V12 * V24 * H2 * Y4 + U14 * V12 * V24 * H4 * Y1 * Y2 - U14 * V12 * V24 * H4 * Y2 * Y4 - U14 * V12 * H2 - U14 * V12 * H4 * Y2 - U14 * V24 * H2 - U14 * V24 * H4 * Y2 - U24 * V12 * V14 * H2 * Y2 + U24 * V12 * V14 * H2 * Y4 - U24 * V12 * V14 * H4 * Y1 * Y2 + U24 * V12 * V14 * H4 * Y1 * Y4 + U24 * V12 * H2 + U24 * V12 * H4 * Y1 - U24 * V14 * H2 - U24 * V14 * H4 * Y1, U12 * U13 * H3 + U12 * U13 * H4 * X3 + U12 * U13 * Y2 + U12 * U13 * Y3 - U12 * U23 * V13 * Y1^2 + U12 * U23 * V13 * Y1 * Y2 + U12 * U23 * V13 * Y1 * Y3 - U12 * U23 * V13 * Y2 * Y3 - U12 * U23 * H3 - U12 * U23 * H4 * X3 - U12 * U23 * Y2 - U12 * U23 * Y3 - U12 * V13 * V23 * H2 * Y1 + U12 * V13 * V23 * H2 * Y2 - U12 * V13 * V23 * H4 * Y1 * Y3 + U12 * V13 * V23 * H4 * Y2 * Y3 - U12 * V13 * H2 - U12 * V13 * H4 * Y1 + U12 * V23 * H2 + U12 * V23 * H4 * Y2 + U13 * U23 * V12 * Y1^2 - U13 * U23 * V12 * Y1 * Y2 - U13 * U23 * V12 * Y1 * Y3 + U13 * U23 * V12 * Y2 * Y3 + U13 * U23 * H3 + U13 * U23 * H4 * X3 + U13 * U23 * Y2 + U13 * U23 * Y3 + U13 * V12 * V23 * H2 * Y1 - U13 * V12 * V23 * H2 * Y3 + U13 * V12 * V23 * H4 * Y1 * Y2 - U13 * V12 * V23 * H4 * Y2 * Y3 - U13 * V12 * H2 - U13 * V12 * H4 * Y2 - U13 * V23 * H2 - U13 * V23 * H4 * Y2 - U23 * V12 * V13 * H2 * Y2 + U23 * V12 * V13 * H2 * Y3 - U23 * V12 * V13 * H4 * Y1 * Y2 + U23 * V12 * V13 * H4 * Y1 * Y3 + U23 * V12 * H2 + U23 * V12 * H4 * Y1 - U23 * V13 * H2 - U23 * V13 * H4 * Y1, E4 * Y2^2 * Y3 - E4 * Y2^2 * Y4 - E4 * Y2 * Y3^2 + E4 * Y2 * Y4^2 + E4 * Y3^2 * Y4 - E4 * Y3 * Y4^2 + H4 * X1 * X2 * Y3 - H4 * X1 * X2 * Y4 - H4 * X1 * X3 * Y2 + H4 * X1 * X3 * Y4 + H4 * X1 * X4 * Y2 - H4 * X1 * X4 * Y3 + H4 * X2 * X3 * Y2 - H4 * X2 * X3 * Y3 - H4 * X2 * X4 * Y2 + H4 * X2 * X4 * Y4 + H4 * X3 * X4 * Y3 - H4 * X3 * X4 * Y4 + X2 * Y1 * Y3 - X2 * Y1 * Y4 + X2 * Y2 * Y3 - X2 * Y2 * Y4 - X2 * Y3^2 + X2 * Y4^2 - X3 * Y1 * Y2 + X3 * Y1 * Y4 + X3 * Y2^2 - X3 * Y2 * Y3 + X3 * Y3 * Y4 - X3 * Y4^2 + X4 * Y1 * Y2 - X4 * Y1 * Y3 - X4 * Y2^2 + X4 * Y2 * Y4 + X4 * Y3^2 - X4 * Y3 * Y4, E3 * H4 * X3 * Y3 - E3 * H4 * X3 * Y4 - E3 * H4 * X4 * Y3 + E3 * H4 * X4 * Y4 + E3 * Y3^2 - 2 * E3 * Y3 * Y4 + E3 * Y4^2 - E4 * H3 * X3 * Y3 + E4 * H3 * X3 * Y4 + E4 * H3 * X4 * Y3 - E4 * H3 * X4 * Y4 - E4 * X3 * Y2 * Y3 + E4 * X3 * Y2 * Y4 - E4 * X3 * Y3 * Y4 + E4 * X3 * Y4^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 + E4 * X4 * Y3^2 - E4 * X4 * Y3 * Y4 - H3 * X3^2 + 2 * H3 * X3 * X4 - H3 * X4^2 - H4 * X2 * X3^2 + 2 * H4 * X2 * X3 * X4 - H4 * X2 * X4^2 - X2 * X3 * Y3 + X2 * X3 * Y4 + X2 * X4 * Y3 - X2 * X4 * Y4 - X3^2 * Y2 - X3^2 * Y4 + 2 * X3 * X4 * Y2 + X3 * X4 * Y3 + X3 * X4 * Y4 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X3 * Y1 - E3 * H4 * X3 * Y4 - E3 * H4 * X4 * Y1 + E3 * H4 * X4 * Y4 + E3 * Y1 * Y3 - E3 * Y1 * Y4 - E3 * Y3 * Y4 + E3 * Y4^2 - E4 * H3 * X3 * Y1 + E4 * H3 * X3 * Y4 + E4 * H3 * X4 * Y1 - E4 * H3 * X4 * Y4 - E4 * X3 * Y1^2 + E4 * X3 * Y4^2 + E4 * X4 * Y1^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X1 * X3 + H3 * X1 * X4 + H3 * X3 * X4 - H3 * X4^2 - H4 * X1 * X3^2 + H4 * X1 * X4^2 + H4 * X2 * X3 * X4 - H4 * X2 * X4^2 + H4 * X3^2 * X4 - H4 * X3 * X4^2 - X1 * X3 * Y1 - X1 * X3 * Y3 + X1 * X4 * Y1 + X1 * X4 * Y4 + X2 * X4 * Y3 - X2 * X4 * Y4 + X3 * X4 * Y2 + X3 * X4 * Y3 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X3 * Y2 - E3 * H4 * X3 * Y4 - E3 * H4 * X4 * Y2 + E3 * H4 * X4 * Y4 + E3 * Y2 * Y3 - E3 * Y2 * Y4 - E3 * Y3 * Y4 + E3 * Y4^2 - E4 * H3 * X3 * Y2 + E4 * H3 * X3 * Y4 + E4 * H3 * X4 * Y2 - E4 * H3 * X4 * Y4 - E4 * X3 * Y2^2 + E4 * X3 * Y4^2 + E4 * X4 * Y2^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X2 * X3 + H3 * X2 * X4 + H3 * X3 * X4 - H3 * X4^2 - H4 * X2 * X3^2 + H4 * X2 * X3 * X4 + H4 * X3^2 * X4 - H4 * X3 * X4^2 - X2 * X3 * Y2 - X2 * X3 * Y3 + X2 * X4 * Y2 + X2 * X4 * Y3 + X3 * X4 * Y2 + X3 * X4 * Y3 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X2 * Y1 - E3 * H4 * X2 * Y4 - E3 * H4 * X4 * Y1 + E3 * H4 * X4 * Y4 + E3 * Y1 * Y2 - E3 * Y1 * Y4 - E3 * Y2 * Y4 + E3 * Y4^2 - E4 * H3 * X2 * Y1 + E4 * H3 * X2 * Y4 + E4 * H3 * X4 * Y1 - E4 * H3 * X4 * Y4 - E4 * X2 * Y1^2 + E4 * X2 * Y4^2 + E4 * X4 * Y1^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X1 * X2 + H3 * X1 * X4 + H3 * X2 * X4 - H3 * X4^2 - H4 * X1 * X2^2 + H4 * X1 * X4^2 + H4 * X2^2 * X4 + H4 * X2 * X3 * X4 - H4 * X2 * X4^2 - H4 * X3 * X4^2 - X1 * X2 * Y1 - X1 * X2 * Y2 + X1 * X4 * Y1 + X1 * X4 * Y4 + X2 * X4 * Y2 + X2 * X4 * Y3 + X3 * X4 * Y2 - X3 * X4 * Y4 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X2 * Y2 - E3 * H4 * X2 * Y4 - E3 * H4 * X4 * Y2 + E3 * H4 * X4 * Y4 + E3 * Y2^2 - 2 * E3 * Y2 * Y4 + E3 * Y4^2 - E4 * H3 * X2 * Y2 + E4 * H3 * X2 * Y4 + E4 * H3 * X4 * Y2 - E4 * H3 * X4 * Y4 - E4 * X2 * Y2 * Y3 - E4 * X2 * Y2 * Y4 + E4 * X2 * Y3 * Y4 + E4 * X2 * Y4^2 + E4 * X4 * Y2^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X2^2 + 2 * H3 * X2 * X4 - H3 * X4^2 - H4 * X2^2 * X3 + 2 * H4 * X2 * X3 * X4 - H4 * X3 * X4^2 - X2^2 * Y3 - X2^2 * Y4 - X2 * X3 * Y2 + X2 * X3 * Y4 + X2 * X4 * Y2 + 2 * X2 * X4 * Y3 + X2 * X4 * Y4 + X3 * X4 * Y2 - X3 * X4 * Y4 - X4^2 * Y2 - X4^2 * Y3, E3 * H4 * X1 * Y1 - E3 * H4 * X1 * Y4 - E3 * H4 * X4 * Y1 + E3 * H4 * X4 * Y4 + E3 * Y1^2 - 2 * E3 * Y1 * Y4 + E3 * Y4^2 - E4 * H3 * X1 * Y1 + E4 * H3 * X1 * Y4 + E4 * H3 * X4 * Y1 - E4 * H3 * X4 * Y4 - 2 * E4 * X1 * Y1 * Y4 - E4 * X1 * Y2 * Y3 + E4 * X1 * Y2 * Y4 + E4 * X1 * Y3 * Y4 + E4 * X1 * Y4^2 + E4 * X4 * Y1^2 + E4 * X4 * Y2 * Y3 - E4 * X4 * Y2 * Y4 - E4 * X4 * Y3 * Y4 - H3 * X1^2 + 2 * H3 * X1 * X4 - H3 * X4^2 - H4 * X1^2 * X4 - H4 * X1 * X2 * X3 + H4 * X1 * X2 * X4 + H4 * X1 * X3 * X4 + H4 * X1 * X4^2 + H4 * X2 * X3 * X4 - H4 * X2 * X4^2 - H4 * X3 * X4^2 - 2 * X1^2 * Y4 - X1 * X2 * Y3 + X1 * X2 * Y4 - X1 * X3 * Y2 + X1 * X3 * Y4 + X1 * X4 * Y2 + X1 * X4 * Y3 + 2 * X1 * X4 * Y4 + X2 * X4 * Y3 - X2 * X4 * Y4 + X3 * X4 * Y2 - X3 * X4 * Y4 - X4^2 * Y2 - X4^2 * Y3, U23 * U24 * Y2^2 - U23 * U24 * Y2 * Y3 - U23 * U24 * Y2 * Y4 + U23 * U24 * Y3 * Y4 + U23 * U34 * V24 * Y2^3 - 3 * U23 * U34 * V24 * Y2^2 * Y4 - U23 * U34 * V24 * Y2 * Y3^2 + 2 * U23 * U34 * V24 * Y2 * Y3 * Y4 + 2 * U23 * U34 * V24 * Y2 * Y4^2 + U23 * U34 * V24 * Y3^2 * Y4 - 2 * U23 * U34 * V24 * Y3 * Y4^2 - U23 * U34 * Y2^2 + U23 * U34 * Y2 * Y3 + U23 * U34 * Y2 * Y4 - U23 * U34 * Y3 * Y4 + U23 * V24 * V34 * H2 * Y2^2 - 2 * U23 * V24 * V34 * H2 * Y2 * Y4 - U23 * V24 * V34 * H2 * Y3^2 + 2 * U23 * V24 * V34 * H2 * Y3 * Y4 + U23 * V24 * V34 * H4 * Y2^2 * Y4 - 2 * U23 * V24 * V34 * H4 * Y2 * Y4^2 - U23 * V24 * V34 * H4 * Y3^2 * Y4 + 2 * U23 * V24 * V34 * H4 * Y3 * Y4^2 - U23 * V24 * H2 * Y2 + U23 * V24 * H2 * Y3 - U23 * V24 * H4 * Y2 * Y4 + U23 * V24 * H4 * Y3 * Y4 - U23 * V34 * H2 * Y2 + U23 * V34 * H2 * Y3 - U23 * V34 * H4 * Y2 * Y4 + U23 * V34 * H4 * Y3 * Y4 - U24 * U34 * V23 * Y2^3 + 3 * U24 * U34 * V23 * Y2^2 * Y4 + U24 * U34 * V23 * Y2 * Y3^2 - 2 * U24 * U34 * V23 * Y2 * Y3 * Y4 - 2 * U24 * U34 * V23 * Y2 * Y4^2 - U24 * U34 * V23 * Y3^2 * Y4 + 2 * U24 * U34 * V23 * Y3 * Y4^2 + U24 * U34 * Y2^2 - U24 * U34 * Y2 * Y3 - U24 * U34 * Y2 * Y4 + U24 * U34 * Y3 * Y4 - U24 * V23 * V34 * H2 * Y2^2 - U24 * V23 * V34 * H2 * Y2 * Y3 + 3 * U24 * V23 * V34 * H2 * Y2 * Y4 + U24 * V23 * V34 * H2 * Y3 * Y4 - 2 * U24 * V23 * V34 * H2 * Y4^2 - U24 * V23 * V34 * H4 * Y2^2 * Y3 - U24 * V23 * V34 * H4 * Y2 * Y3^2 + 3 * U24 * V23 * V34 * H4 * Y2 * Y3 * Y4 + U24 * V23 * V34 * H4 * Y3^2 * Y4 - 2 * U24 * V23 * V34 * H4 * Y3 * Y4^2 + 2 * U24 * V23 * H2 * Y2 - 2 * U24 * V23 * H2 * Y4 + 2 * U24 * V23 * H4 * Y2 * Y3 - 2 * U24 * V23 * H4 * Y3 * Y4 + U24 * V34 * H2 * Y2 - U24 * V34 * H2 * Y4 + U24 * V34 * H4 * Y2 * Y3 - U24 * V34 * H4 * Y3 * Y4 + U34 * V23 * V24 * H2 * Y2 * Y3 - U34 * V23 * V24 * H2 * Y2 * Y4 + U34 * V23 * V24 * H2 * Y3^2 - 3 * U34 * V23 * V24 * H2 * Y3 * Y4 + 2 * U34 * V23 * V24 * H2 * Y4^2 + U34 * V23 * V24 * H4 * Y2^2 * Y3 - U34 * V23 * V24 * H4 * Y2^2 * Y4 + U34 * V23 * V24 * H4 * Y2 * Y3^2 - 3 * U34 * V23 * V24 * H4 * Y2 * Y3 * Y4 + 2 * U34 * V23 * V24 * H4 * Y2 * Y4^2 - 2 * U34 * V23 * H2 * Y3 + 2 * U34 * V23 * H2 * Y4 - 2 * U34 * V23 * H4 * Y2 * Y3 + 2 * U34 * V23 * H4 * Y2 * Y4 + U34 * V24 * H2 * Y3 - U34 * V24 * H2 * Y4 + U34 * V24 * H4 * Y2 * Y3 - U34 * V24 * H4 * Y2 * Y4, U14 * U23 * U34 * Y1^2 * Y2 - U14 * U23 * U34 * Y1^2 * Y4 - U14 * U23 * U34 * Y1 * Y2^2 + U14 * U23 * U34 * Y1 * Y4^2 + U14 * U23 * U34 * Y2^2 * Y4 - U14 * U23 * U34 * Y2 * Y4^2 + U14 * U23 * V34 * H2 * Y1 * Y3 - U14 * U23 * V34 * H2 * Y1 * Y4 - U14 * U23 * V34 * H2 * Y3 * Y4 + U14 * U23 * V34 * H2 * Y4^2 + U14 * U23 * V34 * H4 * Y1 * Y2 * Y3 - U14 * U23 * V34 * H4 * Y1 * Y2 * Y4 - U14 * U23 * V34 * H4 * Y2 * Y3 * Y4 + U14 * U23 * V34 * H4 * Y2 * Y4^2 - U14 * U23 * H2 * Y1 + U14 * U23 * H2 * Y4 - U14 * U23 * H4 * Y1 * Y2 + U14 * U23 * H4 * Y2 * Y4 + U14 * U34 * V23 * H2 * Y1 * Y2 - U14 * U34 * V23 * H2 * Y1 * Y3 - U14 * U34 * V23 * H2 * Y2 * Y4 + U14 * U34 * V23 * H2 * Y3 * Y4 + U14 * U34 * V23 * H4 * Y1 * Y2^2 - U14 * U34 * V23 * H4 * Y1 * Y2 * Y3 - U14 * U34 * V23 * H4 * Y2^2 * Y4 + U14 * U34 * V23 * H4 * Y2 * Y3 * Y4 - U14 * U34 * H2 * Y1 + U14 * U34 * H2 * Y4 - U14 * U34 * H4 * Y1 * Y2 + U14 * U34 * H4 * Y2 * Y4 - U23 * U34 * V14 * H2 * Y1 * Y2 + U23 * U34 * V14 * H2 * Y1 * Y4 + U23 * U34 * V14 * H2 * Y2 * Y4 - U23 * U34 * V14 * H2 * Y4^2 - U23 * U34 * V14 * H4 * Y1^2 * Y2 + U23 * U34 * V14 * H4 * Y1^2 * Y4 + U23 * U34 * V14 * H4 * Y1 * Y2 * Y4 - U23 * U34 * V14 * H4 * Y1 * Y4^2 + U23 * U34 * H2 * Y2 - U23 * U34 * H2 * Y4 + U23 * U34 * H4 * Y1 * Y2 - U23 * U34 * H4 * Y1 * Y4, U13 * U24 * U34 * Y1^2 * Y2 - U13 * U24 * U34 * Y1^2 * Y4 - U13 * U24 * U34 * Y1 * Y2^2 + U13 * U24 * U34 * Y1 * Y4^2 + U13 * U24 * U34 * Y2^2 * Y4 - U13 * U24 * U34 * Y2 * Y4^2 - U13 * U24 * V34 * H2 * Y2 * Y3 + U13 * U24 * V34 * H2 * Y2 * Y4 + U13 * U24 * V34 * H2 * Y3 * Y4 - U13 * U24 * V34 * H2 * Y4^2 - U13 * U24 * V34 * H4 * Y1 * Y2 * Y3 + U13 * U24 * V34 * H4 * Y1 * Y2 * Y4 + U13 * U24 * V34 * H4 * Y1 * Y3 * Y4 - U13 * U24 * V34 * H4 * Y1 * Y4^2 + U13 * U24 * H2 * Y2 - U13 * U24 * H2 * Y4 + U13 * U24 * H4 * Y1 * Y2 - U13 * U24 * H4 * Y1 * Y4 + U13 * U34 * V24 * H2 * Y1 * Y2 - U13 * U34 * V24 * H2 * Y1 * Y4 - U13 * U34 * V24 * H2 * Y2 * Y4 + U13 * U34 * V24 * H2 * Y4^2 + U13 * U34 * V24 * H4 * Y1 * Y2^2 - U13 * U34 * V24 * H4 * Y1 * Y2 * Y4 - U13 * U34 * V24 * H4 * Y2^2 * Y4 + U13 * U34 * V24 * H4 * Y2 * Y4^2 - U13 * U34 * H2 * Y1 + U13 * U34 * H2 * Y4 - U13 * U34 * H4 * Y1 * Y2 + U13 * U34 * H4 * Y2 * Y4 - U24 * U34 * V13 * H2 * Y1 * Y2 + U24 * U34 * V13 * H2 * Y1 * Y4 + U24 * U34 * V13 * H2 * Y2 * Y3 - U24 * U34 * V13 * H2 * Y3 * Y4 - U24 * U34 * V13 * H4 * Y1^2 * Y2 + U24 * U34 * V13 * H4 * Y1^2 * Y4 + U24 * U34 * V13 * H4 * Y1 * Y2 * Y3 - U24 * U34 * V13 * H4 * Y1 * Y3 * Y4 + U24 * U34 * H2 * Y2 - U24 * U34 * H2 * Y4 + U24 * U34 * H4 * Y1 * Y2 - U24 * U34 * H4 * Y1 * Y4, U13 * U14 * Y1^2 - U13 * U14 * Y1 * Y3 - U13 * U14 * Y1 * Y4 + U13 * U14 * Y3 * Y4 + U13 * U34 * V14 * Y1^3 - 3 * U13 * U34 * V14 * Y1^2 * Y4 - U13 * U34 * V14 * Y1 * Y3^2 + 2 * U13 * U34 * V14 * Y1 * Y3 * Y4 + 2 * U13 * U34 * V14 * Y1 * Y4^2 + U13 * U34 * V14 * Y3^2 * Y4 - 2 * U13 * U34 * V14 * Y3 * Y4^2 - U13 * U34 * Y1^2 + U13 * U34 * Y1 * Y3 + U13 * U34 * Y1 * Y4 - U13 * U34 * Y3 * Y4 + U13 * V14 * V34 * H2 * Y1^2 - 2 * U13 * V14 * V34 * H2 * Y1 * Y4 - U13 * V14 * V34 * H2 * Y3^2 + 2 * U13 * V14 * V34 * H2 * Y3 * Y4 + U13 * V14 * V34 * H4 * Y1^2 * Y4 - 2 * U13 * V14 * V34 * H4 * Y1 * Y4^2 - U13 * V14 * V34 * H4 * Y3^2 * Y4 + 2 * U13 * V14 * V34 * H4 * Y3 * Y4^2 - U13 * V14 * H2 * Y1 + U13 * V14 * H2 * Y3 - U13 * V14 * H4 * Y1 * Y4 + U13 * V14 * H4 * Y3 * Y4 - U13 * V34 * H2 * Y1 + U13 * V34 * H2 * Y3 - U13 * V34 * H4 * Y1 * Y4 + U13 * V34 * H4 * Y3 * Y4 - U14 * U34 * V13 * Y1^3 + 3 * U14 * U34 * V13 * Y1^2 * Y4 + U14 * U34 * V13 * Y1 * Y3^2 - 2 * U14 * U34 * V13 * Y1 * Y3 * Y4 - 2 * U14 * U34 * V13 * Y1 * Y4^2 - U14 * U34 * V13 * Y3^2 * Y4 + 2 * U14 * U34 * V13 * Y3 * Y4^2 + U14 * U34 * Y1^2 - U14 * U34 * Y1 * Y3 - U14 * U34 * Y1 * Y4 + U14 * U34 * Y3 * Y4 - U14 * V13 * V34 * H2 * Y1^2 - U14 * V13 * V34 * H2 * Y1 * Y3 + 3 * U14 * V13 * V34 * H2 * Y1 * Y4 + U14 * V13 * V34 * H2 * Y3 * Y4 - 2 * U14 * V13 * V34 * H2 * Y4^2 - U14 * V13 * V34 * H4 * Y1^2 * Y3 - U14 * V13 * V34 * H4 * Y1 * Y3^2 + 3 * U14 * V13 * V34 * H4 * Y1 * Y3 * Y4 + U14 * V13 * V34 * H4 * Y3^2 * Y4 - 2 * U14 * V13 * V34 * H4 * Y3 * Y4^2 + 2 * U14 * V13 * H2 * Y1 - 2 * U14 * V13 * H2 * Y4 + 2 * U14 * V13 * H4 * Y1 * Y3 - 2 * U14 * V13 * H4 * Y3 * Y4 + U14 * V34 * H2 * Y1 - U14 * V34 * H2 * Y4 + U14 * V34 * H4 * Y1 * Y3 - U14 * V34 * H4 * Y3 * Y4 + U34 * V13 * V14 * H2 * Y1 * Y3 - U34 * V13 * V14 * H2 * Y1 * Y4 + U34 * V13 * V14 * H2 * Y3^2 - 3 * U34 * V13 * V14 * H2 * Y3 * Y4 + 2 * U34 * V13 * V14 * H2 * Y4^2 + U34 * V13 * V14 * H4 * Y1^2 * Y3 - U34 * V13 * V14 * H4 * Y1^2 * Y4 + U34 * V13 * V14 * H4 * Y1 * Y3^2 - 3 * U34 * V13 * V14 * H4 * Y1 * Y3 * Y4 + 2 * U34 * V13 * V14 * H4 * Y1 * Y4^2 - 2 * U34 * V13 * H2 * Y3 + 2 * U34 * V13 * H2 * Y4 - 2 * U34 * V13 * H4 * Y1 * Y3 + 2 * U34 * V13 * H4 * Y1 * Y4 + U34 * V14 * H2 * Y3 - U34 * V14 * H2 * Y4 + U34 * V14 * H4 * Y1 * Y3 - U34 * V14 * H4 * Y1 * Y4, U12 * U24 * U34 * Y1^2 * Y3 - U12 * U24 * U34 * Y1^2 * Y4 - U12 * U24 * U34 * Y1 * Y3^2 + U12 * U24 * U34 * Y1 * Y4^2 + U12 * U24 * U34 * Y3^2 * Y4 - U12 * U24 * U34 * Y3 * Y4^2 + U12 * U24 * V34 * H2 * Y1 * Y3 - U12 * U24 * V34 * H2 * Y1 * Y4 - U12 * U24 * V34 * H2 * Y3 * Y4 + U12 * U24 * V34 * H2 * Y4^2 + U12 * U24 * V34 * H4 * Y1 * Y3^2 - U12 * U24 * V34 * H4 * Y1 * Y3 * Y4 - U12 * U24 * V34 * H4 * Y3^2 * Y4 + U12 * U24 * V34 * H4 * Y3 * Y4^2 - U12 * U24 * H2 * Y1 + U12 * U24 * H2 * Y4 - U12 * U24 * H4 * Y1 * Y3 + U12 * U24 * H4 * Y3 * Y4 - U12 * U34 * V24 * H2 * Y2 * Y3 + U12 * U34 * V24 * H2 * Y2 * Y4 + U12 * U34 * V24 * H2 * Y3 * Y4 - U12 * U34 * V24 * H2 * Y4^2 - U12 * U34 * V24 * H4 * Y1 * Y2 * Y3 + U12 * U34 * V24 * H4 * Y1 * Y2 * Y4 + U12 * U34 * V24 * H4 * Y1 * Y3 * Y4 - U12 * U34 * V24 * H4 * Y1 * Y4^2 + U12 * U34 * H2 * Y3 - U12 * U34 * H2 * Y4 + U12 * U34 * H4 * Y1 * Y3 - U12 * U34 * H4 * Y1 * Y4 - U24 * U34 * V12 * H2 * Y1 * Y3 + U24 * U34 * V12 * H2 * Y1 * Y4 + U24 * U34 * V12 * H2 * Y2 * Y3 - U24 * U34 * V12 * H2 * Y2 * Y4 - U24 * U34 * V12 * H4 * Y1^2 * Y3 + U24 * U34 * V12 * H4 * Y1^2 * Y4 + U24 * U34 * V12 * H4 * Y1 * Y2 * Y3 - U24 * U34 * V12 * H4 * Y1 * Y2 * Y4 + U24 * U34 * H2 * Y3 - U24 * U34 * H2 * Y4 + U24 * U34 * H4 * Y1 * Y3 - U24 * U34 * H4 * Y1 * Y4, U12 * U23 * U34 * Y1^2 * Y3 - U12 * U23 * U34 * Y1^2 * Y4 - U12 * U23 * U34 * Y1 * Y3^2 + U12 * U23 * U34 * Y1 * Y4^2 + U12 * U23 * U34 * Y3^2 * Y4 - U12 * U23 * U34 * Y3 * Y4^2 + U12 * U23 * V34 * H2 * Y1 * Y3 - U12 * U23 * V34 * H2 * Y1 * Y4 - U12 * U23 * V34 * H2 * Y3^2 + U12 * U23 * V34 * H2 * Y3 * Y4 + U12 * U23 * V34 * H4 * Y1 * Y3 * Y4 - U12 * U23 * V34 * H4 * Y1 * Y4^2 - U12 * U23 * V34 * H4 * Y3^2 * Y4 + U12 * U23 * V34 * H4 * Y3 * Y4^2 - U12 * U23 * H2 * Y1 + U12 * U23 * H2 * Y3 - U12 * U23 * H4 * Y1 * Y4 + U12 * U23 * H4 * Y3 * Y4 - U12 * U34 * V23 * H2 * Y2 * Y3 + U12 * U34 * V23 * H2 * Y2 * Y4 + U12 * U34 * V23 * H2 * Y3^2 - U12 * U34 * V23 * H2 * Y3 * Y4 - U12 * U34 * V23 * H4 * Y1 * Y2 * Y3 + U12 * U34 * V23 * H4 * Y1 * Y2 * Y4 + U12 * U34 * V23 * H4 * Y1 * Y3^2 - U12 * U34 * V23 * H4 * Y1 * Y3 * Y4 + U12 * U34 * H2 * Y3 - U12 * U34 * H2 * Y4 + U12 * U34 * H4 * Y1 * Y3 - U12 * U34 * H4 * Y1 * Y4 - U23 * U34 * V12 * H2 * Y1 * Y3 + U23 * U34 * V12 * H2 * Y1 * Y4 + U23 * U34 * V12 * H2 * Y2 * Y3 - U23 * U34 * V12 * H2 * Y2 * Y4 - U23 * U34 * V12 * H4 * Y1^2 * Y3 + U23 * U34 * V12 * H4 * Y1^2 * Y4 + U23 * U34 * V12 * H4 * Y1 * Y2 * Y3 - U23 * U34 * V12 * H4 * Y1 * Y2 * Y4 + U23 * U34 * H2 * Y3 - U23 * U34 * H2 * Y4 + U23 * U34 * H4 * Y1 * Y3 - U23 * U34 * H4 * Y1 * Y4, U12 * U14 * Y1^2 - U12 * U14 * Y1 * Y2 - U12 * U14 * Y1 * Y4 + U12 * U14 * Y2 * Y4 + U12 * U24 * V14 * Y1^3 - 3 * U12 * U24 * V14 * Y1^2 * Y4 - U12 * U24 * V14 * Y1 * Y2^2 + 2 * U12 * U24 * V14 * Y1 * Y2 * Y4 + 2 * U12 * U24 * V14 * Y1 * Y4^2 + U12 * U24 * V14 * Y2^2 * Y4 - 2 * U12 * U24 * V14 * Y2 * Y4^2 - U12 * U24 * Y1^2 + U12 * U24 * Y1 * Y2 + U12 * U24 * Y1 * Y4 - U12 * U24 * Y2 * Y4 + U12 * V14 * V24 * H2 * Y1^2 - 2 * U12 * V14 * V24 * H2 * Y1 * Y4 - U12 * V14 * V24 * H2 * Y2^2 + 2 * U12 * V14 * V24 * H2 * Y2 * Y4 + U12 * V14 * V24 * H4 * Y1^2 * Y4 - 2 * U12 * V14 * V24 * H4 * Y1 * Y4^2 - U12 * V14 * V24 * H4 * Y2^2 * Y4 + 2 * U12 * V14 * V24 * H4 * Y2 * Y4^2 - U12 * V14 * H2 * Y1 + U12 * V14 * H2 * Y2 - U12 * V14 * H4 * Y1 * Y4 + U12 * V14 * H4 * Y2 * Y4 - U12 * V24 * H2 * Y1 + U12 * V24 * H2 * Y2 - U12 * V24 * H4 * Y1 * Y4 + U12 * V24 * H4 * Y2 * Y4 - U14 * U24 * V12 * Y1^3 + 3 * U14 * U24 * V12 * Y1^2 * Y4 + U14 * U24 * V12 * Y1 * Y2^2 - 2 * U14 * U24 * V12 * Y1 * Y2 * Y4 - 2 * U14 * U24 * V12 * Y1 * Y4^2 - U14 * U24 * V12 * Y2^2 * Y4 + 2 * U14 * U24 * V12 * Y2 * Y4^2 + U14 * U24 * Y1^2 - U14 * U24 * Y1 * Y2 - U14 * U24 * Y1 * Y4 + U14 * U24 * Y2 * Y4 - U14 * V12 * V24 * H2 * Y1^2 - U14 * V12 * V24 * H2 * Y1 * Y2 + 3 * U14 * V12 * V24 * H2 * Y1 * Y4 + U14 * V12 * V24 * H2 * Y2 * Y4 - 2 * U14 * V12 * V24 * H2 * Y4^2 - U14 * V12 * V24 * H4 * Y1^2 * Y2 - U14 * V12 * V24 * H4 * Y1 * Y2^2 + 3 * U14 * V12 * V24 * H4 * Y1 * Y2 * Y4 + U14 * V12 * V24 * H4 * Y2^2 * Y4 - 2 * U14 * V12 * V24 * H4 * Y2 * Y4^2 + 2 * U14 * V12 * H2 * Y1 - 2 * U14 * V12 * H2 * Y4 + 2 * U14 * V12 * H4 * Y1 * Y2 - 2 * U14 * V12 * H4 * Y2 * Y4 + U14 * V24 * H2 * Y1 - U14 * V24 * H2 * Y4 + U14 * V24 * H4 * Y1 * Y2 - U14 * V24 * H4 * Y2 * Y4 + U24 * V12 * V14 * H2 * Y1 * Y2 - U24 * V12 * V14 * H2 * Y1 * Y4 + U24 * V12 * V14 * H2 * Y2^2 - 3 * U24 * V12 * V14 * H2 * Y2 * Y4 + 2 * U24 * V12 * V14 * H2 * Y4^2 + U24 * V12 * V14 * H4 * Y1^2 * Y2 - U24 * V12 * V14 * H4 * Y1^2 * Y4 + U24 * V12 * V14 * H4 * Y1 * Y2^2 - 3 * U24 * V12 * V14 * H4 * Y1 * Y2 * Y4 + 2 * U24 * V12 * V14 * H4 * Y1 * Y4^2 - 2 * U24 * V12 * H2 * Y2 + 2 * U24 * V12 * H2 * Y4 - 2 * U24 * V12 * H4 * Y1 * Y2 + 2 * U24 * V12 * H4 * Y1 * Y4 + U24 * V14 * H2 * Y2 - U24 * V14 * H2 * Y4 + U24 * V14 * H4 * Y1 * Y2 - U24 * V14 * H4 * Y1 * Y4, U12 * U13 * Y1^2 - U12 * U13 * Y1 * Y2 - U12 * U13 * Y1 * Y3 + U12 * U13 * Y2 * Y3 + U12 * U23 * V13 * Y1^3 - 3 * U12 * U23 * V13 * Y1^2 * Y3 - U12 * U23 * V13 * Y1 * Y2^2 + 2 * U12 * U23 * V13 * Y1 * Y2 * Y3 + 2 * U12 * U23 * V13 * Y1 * Y3^2 + U12 * U23 * V13 * Y2^2 * Y3 - 2 * U12 * U23 * V13 * Y2 * Y3^2 - U12 * U23 * Y1^2 + U12 * U23 * Y1 * Y2 + U12 * U23 * Y1 * Y3 - U12 * U23 * Y2 * Y3 + U12 * V13 * V23 * H2 * Y1^2 - 2 * U12 * V13 * V23 * H2 * Y1 * Y3 - U12 * V13 * V23 * H2 * Y2^2 + 2 * U12 * V13 * V23 * H2 * Y2 * Y3 + U12 * V13 * V23 * H4 * Y1^2 * Y3 - 2 * U12 * V13 * V23 * H4 * Y1 * Y3^2 - U12 * V13 * V23 * H4 * Y2^2 * Y3 + 2 * U12 * V13 * V23 * H4 * Y2 * Y3^2 - U12 * V13 * H2 * Y1 + U12 * V13 * H2 * Y2 - U12 * V13 * H4 * Y1 * Y3 + U12 * V13 * H4 * Y2 * Y3 - U12 * V23 * H2 * Y1 + U12 * V23 * H2 * Y2 - U12 * V23 * H4 * Y1 * Y3 + U12 * V23 * H4 * Y2 * Y3 - U13 * U23 * V12 * Y1^3 + 3 * U13 * U23 * V12 * Y1^2 * Y3 + U13 * U23 * V12 * Y1 * Y2^2 - 2 * U13 * U23 * V12 * Y1 * Y2 * Y3 - 2 * U13 * U23 * V12 * Y1 * Y3^2 - U13 * U23 * V12 * Y2^2 * Y3 + 2 * U13 * U23 * V12 * Y2 * Y3^2 + U13 * U23 * Y1^2 - U13 * U23 * Y1 * Y2 - U13 * U23 * Y1 * Y3 + U13 * U23 * Y2 * Y3 - U13 * V12 * V23 * H2 * Y1^2 - U13 * V12 * V23 * H2 * Y1 * Y2 + 3 * U13 * V12 * V23 * H2 * Y1 * Y3 + U13 * V12 * V23 * H2 * Y2 * Y3 - 2 * U13 * V12 * V23 * H2 * Y3^2 - U13 * V12 * V23 * H4 * Y1^2 * Y2 - U13 * V12 * V23 * H4 * Y1 * Y2^2 + 3 * U13 * V12 * V23 * H4 * Y1 * Y2 * Y3 + U13 * V12 * V23 * H4 * Y2^2 * Y3 - 2 * U13 * V12 * V23 * H4 * Y2 * Y3^2 + 2 * U13 * V12 * H2 * Y1 - 2 * U13 * V12 * H2 * Y3 + 2 * U13 * V12 * H4 * Y1 * Y2 - 2 * U13 * V12 * H4 * Y2 * Y3 + U13 * V23 * H2 * Y1 - U13 * V23 * H2 * Y3 + U13 * V23 * H4 * Y1 * Y2 - U13 * V23 * H4 * Y2 * Y3 + U23 * V12 * V13 * H2 * Y1 * Y2 - U23 * V12 * V13 * H2 * Y1 * Y3 + U23 * V12 * V13 * H2 * Y2^2 - 3 * U23 * V12 * V13 * H2 * Y2 * Y3 + 2 * U23 * V12 * V13 * H2 * Y3^2 + U23 * V12 * V13 * H4 * Y1^2 * Y2 - U23 * V12 * V13 * H4 * Y1^2 * Y3 + U23 * V12 * V13 * H4 * Y1 * Y2^2 - 3 * U23 * V12 * V13 * H4 * Y1 * Y2 * Y3 + 2 * U23 * V12 * V13 * H4 * Y1 * Y3^2 - 2 * U23 * V12 * H2 * Y2 + 2 * U23 * V12 * H2 * Y3 - 2 * U23 * V12 * H4 * Y1 * Y2 + 2 * U23 * V12 * H4 * Y1 * Y3 + U23 * V13 * H2 * Y2 - U23 * V13 * H2 * Y3 + U23 * V13 * H4 * Y1 * Y2 - U23 * V13 * H4 * Y1 * Y3, E4 * H2 * Y3 - E4 * H2 * Y4 + E4 * H4 * Y2 * Y3 - E4 * H4 * Y2 * Y4 - H3 * H4 * X3 + H3 * H4 * X4 - 2 * H3 * Y3 + 2 * H3 * Y4 - H4^2 * X1 * X3 + H4^2 * X1 * X4 - H4 * X1 * Y3 + H4 * X1 * Y4 - H4 * X3 * Y1 - H4 * X3 * Y3 + H4 * X4 * Y1 + H4 * X4 * Y4 - Y1 * Y3 + Y1 * Y4 - Y2 * Y3 + Y2 * Y4 - Y3^2 + Y4^2, E3 * E4 * H4 * Y3 - E3 * E4 * H4 * Y4 - E3 * H4 * X3 + E3 * H4 * X4 - 2 * E3 * Y3 + 2 * E3 * Y4 - E4^2 * H3 * Y3 + E4^2 * H3 * Y4 - E4^2 * Y3^2 + E4^2 * Y4^2 - E4 * H3 * X3 + E4 * H3 * X4 - E4 * H4 * X1 * X3 + E4 * H4 * X1 * X4 - E4 * H4 * X2 * X3 + E4 * H4 * X2 * X4 - 2 * E4 * X3 * Y3 + 2 * E4 * X4 * Y4 + X1 * X3 - X1 * X4 + X2 * X3 - X2 * X4 - X3^2 + X4^2, U14 * U23 * H2 * Y1^2 * Y2 - U14 * U23 * H2 * Y1^2 * Y3 - U14 * U23 * H2 * Y1 * Y2^2 + U14 * U23 * H2 * Y1 * Y3^2 + U14 * U23 * H2 * Y2^2 * Y4 - U14 * U23 * H2 * Y2 * Y4^2 - U14 * U23 * H2 * Y3^2 * Y4 + U14 * U23 * H2 * Y3 * Y4^2 + U14 * U23 * H4 * Y1^2 * Y2 * Y4 - U14 * U23 * H4 * Y1^2 * Y3 * Y4 - U14 * U23 * H4 * Y1 * Y2^2 * Y3 + U14 * U23 * H4 * Y1 * Y2 * Y3^2 - U14 * U23 * H4 * Y1 * Y2 * Y4^2 + U14 * U23 * H4 * Y1 * Y3 * Y4^2 + U14 * U23 * H4 * Y2^2 * Y3 * Y4 - U14 * U23 * H4 * Y2 * Y3^2 * Y4 + U14 * V23 * H2^2 * Y1 * Y2 - U14 * V23 * H2^2 * Y1 * Y3 - U14 * V23 * H2^2 * Y2 * Y4 + U14 * V23 * H2^2 * Y3 * Y4 + U14 * V23 * H2 * H4 * Y1 * Y2^2 - U14 * V23 * H2 * H4 * Y1 * Y3^2 - U14 * V23 * H2 * H4 * Y2^2 * Y4 + U14 * V23 * H2 * H4 * Y3^2 * Y4 + U14 * V23 * H4^2 * Y1 * Y2^2 * Y3 - U14 * V23 * H4^2 * Y1 * Y2 * Y3^2 - U14 * V23 * H4^2 * Y2^2 * Y3 * Y4 + U14 * V23 * H4^2 * Y2 * Y3^2 * Y4 - U14 * H2^2 * Y1 + U14 * H2^2 * Y4 - U14 * H2 * H4 * Y1 * Y2 - U14 * H2 * H4 * Y1 * Y3 + U14 * H2 * H4 * Y2 * Y4 + U14 * H2 * H4 * Y3 * Y4 - U14 * H4^2 * Y1 * Y2 * Y3 + U14 * H4^2 * Y2 * Y3 * Y4 - U23 * V14 * H2^2 * Y1 * Y2 + U23 * V14 * H2^2 * Y1 * Y3 + U23 * V14 * H2^2 * Y2 * Y4 - U23 * V14 * H2^2 * Y3 * Y4 - U23 * V14 * H2 * H4 * Y1^2 * Y2 + U23 * V14 * H2 * H4 * Y1^2 * Y3 + U23 * V14 * H2 * H4 * Y2 * Y4^2 - U23 * V14 * H2 * H4 * Y3 * Y4^2 - U23 * V14 * H4^2 * Y1^2 * Y2 * Y4 + U23 * V14 * H4^2 * Y1^2 * Y3 * Y4 + U23 * V14 * H4^2 * Y1 * Y2 * Y4^2 - U23 * V14 * H4^2 * Y1 * Y3 * Y4^2 + U23 * H2^2 * Y2 - U23 * H2^2 * Y3 + U23 * H2 * H4 * Y1 * Y2 - U23 * H2 * H4 * Y1 * Y3 + U23 * H2 * H4 * Y2 * Y4 - U23 * H2 * H4 * Y3 * Y4 + U23 * H4^2 * Y1 * Y2 * Y4 - U23 * H4^2 * Y1 * Y3 * Y4, U14 * U23 * U24 * Y1^2 - U14 * U23 * U24 * Y1 * Y3 - U14 * U23 * U24 * Y1 * Y4 + U14 * U23 * U24 * Y3 * Y4 + U14 * U23 * U34 * V24 * Y1 * Y2^2 - U14 * U23 * U34 * V24 * Y1 * Y2 * Y3 - U14 * U23 * U34 * V24 * Y1 * Y2 * Y4 + U14 * U23 * U34 * V24 * Y1 * Y3 * Y4 - U14 * U23 * U34 * V24 * Y2^2 * Y4 + U14 * U23 * U34 * V24 * Y2 * Y3 * Y4 + U14 * U23 * U34 * V24 * Y2 * Y4^2 - U14 * U23 * U34 * V24 * Y3 * Y4^2 - U14 * U23 * U34 * Y1^2 + U14 * U23 * U34 * Y1 * Y3 + U14 * U23 * U34 * Y1 * Y4 - U14 * U23 * U34 * Y3 * Y4 + U14 * U23 * V24 * V34 * H2 * Y1 * Y2 - U14 * U23 * V24 * V34 * H2 * Y1 * Y3 - U14 * U23 * V24 * V34 * H2 * Y2 * Y4 + U14 * U23 * V24 * V34 * H2 * Y3 * Y4 + U14 * U23 * V24 * V34 * H4 * Y1 * Y2 * Y4 - U14 * U23 * V24 * V34 * H4 * Y1 * Y3 * Y4 - U14 * U23 * V24 * V34 * H4 * Y2 * Y4^2 + U14 * U23 * V24 * V34 * H4 * Y3 * Y4^2 + U14 * U23 * V24 * H2 * Y1 - U14 * U23 * V24 * H2 * Y4 + U14 * U23 * V24 * H4 * Y1 * Y2 - U14 * U23 * V24 * H4 * Y2 * Y4 - U14 * U23 * V34 * H2 * Y1 + U14 * U23 * V34 * H2 * Y4 - U14 * U23 * V34 * H4 * Y1 * Y3 + U14 * U23 * V34 * H4 * Y3 * Y4 - U14 * U24 * U34 * V23 * Y1 * Y2^2 + U14 * U24 * U34 * V23 * Y1 * Y2 * Y3 + U14 * U24 * U34 * V23 * Y1 * Y2 * Y4 - U14 * U24 * U34 * V23 * Y1 * Y3 * Y4 + U14 * U24 * U34 * V23 * Y2^2 * Y4 - U14 * U24 * U34 * V23 * Y2 * Y3 * Y4 - U14 * U24 * U34 * V23 * Y2 * Y4^2 + U14 * U24 * U34 * V23 * Y3 * Y4^2 + U14 * U24 * U34 * Y1^2 - U14 * U24 * U34 * Y1 * Y3 - U14 * U24 * U34 * Y1 * Y4 + U14 * U24 * U34 * Y3 * Y4 - U14 * U24 * V23 * V34 * H2 * Y1 * Y2 + U14 * U24 * V23 * V34 * H2 * Y1 * Y4 + U14 * U24 * V23 * V34 * H2 * Y2 * Y4 - U14 * U24 * V23 * V34 * H2 * Y4^2 - U14 * U24 * V23 * V34 * H4 * Y1 * Y2 * Y3 + U14 * U24 * V23 * V34 * H4 * Y1 * Y3 * Y4 + U14 * U24 * V23 * V34 * H4 * Y2 * Y3 * Y4 - U14 * U24 * V23 * V34 * H4 * Y3 * Y4^2 + U14 * U24 * V23 * H2 * Y1 - U14 * U24 * V23 * H2 * Y4 + U14 * U24 * V23 * H4 * Y1 * Y3 - U14 * U24 * V23 * H4 * Y3 * Y4 + U14 * U24 * V34 * H2 * Y1 - U14 * U24 * V34 * H2 * Y4 + U14 * U24 * V34 * H4 * Y1 * Y3 - U14 * U24 * V34 * H4 * Y3 * Y4 + U14 * U34 * V23 * V24 * H2 * Y1 * Y3 - U14 * U34 * V23 * V24 * H2 * Y1 * Y4 - U14 * U34 * V23 * V24 * H2 * Y3 * Y4 + U14 * U34 * V23 * V24 * H2 * Y4^2 + U14 * U34 * V23 * V24 * H4 * Y1 * Y2 * Y3 - U14 * U34 * V23 * V24 * H4 * Y1 * Y2 * Y4 - U14 * U34 * V23 * V24 * H4 * Y2 * Y3 * Y4 + U14 * U34 * V23 * V24 * H4 * Y2 * Y4^2 - U14 * U34 * V23 * H2 * Y1 + U14 * U34 * V23 * H2 * Y4 - U14 * U34 * V23 * H4 * Y1 * Y2 + U14 * U34 * V23 * H4 * Y2 * Y4 + U14 * U34 * V24 * H2 * Y1 - U14 * U34 * V24 * H2 * Y4 + U14 * U34 * V24 * H4 * Y1 * Y2 - U14 * U34 * V24 * H4 * Y2 * Y4 - U23 * U24 * V14 * H2 * Y1 + U23 * U24 * V14 * H2 * Y4 - U23 * U24 * V14 * H4 * Y1^2 + U23 * U24 * V14 * H4 * Y1 * Y4 + U23 * U24 * H2 + U23 * U24 * H4 * Y1 + U23 * U34 * V14 * H2 * Y1 - U23 * U34 * V14 * H2 * Y4 + U23 * U34 * V14 * H4 * Y1^2 - U23 * U34 * V14 * H4 * Y1 * Y4 - U23 * U34 * H2 - U23 * U34 * H4 * Y1 - U24 * U34 * V14 * H2 * Y1 + U24 * U34 * V14 * H2 * Y4 - U24 * U34 * V14 * H4 * Y1^2 + U24 * U34 * V14 * H4 * Y1 * Y4 + U24 * U34 * H2 + U24 * U34 * H4 * Y1, U13 * U24 * H2 * Y1^2 * Y2 - U13 * U24 * H2 * Y1^2 * Y4 - U13 * U24 * H2 * Y1 * Y2^2 + U13 * U24 * H2 * Y1 * Y4^2 + U13 * U24 * H2 * Y2^2 * Y3 - U13 * U24 * H2 * Y2 * Y3^2 + U13 * U24 * H2 * Y3^2 * Y4 - U13 * U24 * H2 * Y3 * Y4^2 + U13 * U24 * H4 * Y1^2 * Y2 * Y3 - U13 * U24 * H4 * Y1^2 * Y3 * Y4 - U13 * U24 * H4 * Y1 * Y2^2 * Y4 - U13 * U24 * H4 * Y1 * Y2 * Y3^2 + U13 * U24 * H4 * Y1 * Y2 * Y4^2 + U13 * U24 * H4 * Y1 * Y3^2 * Y4 + U13 * U24 * H4 * Y2^2 * Y3 * Y4 - U13 * U24 * H4 * Y2 * Y3 * Y4^2 + U13 * V24 * H2^2 * Y1 * Y2 - U13 * V24 * H2^2 * Y1 * Y4 - U13 * V24 * H2^2 * Y2 * Y3 + U13 * V24 * H2^2 * Y3 * Y4 + U13 * V24 * H2 * H4 * Y1 * Y2^2 - U13 * V24 * H2 * H4 * Y1 * Y4^2 - U13 * V24 * H2 * H4 * Y2^2 * Y3 + U13 * V24 * H2 * H4 * Y3 * Y4^2 + U13 * V24 * H4^2 * Y1 * Y2^2 * Y4 - U13 * V24 * H4^2 * Y1 * Y2 * Y4^2 - U13 * V24 * H4^2 * Y2^2 * Y3 * Y4 + U13 * V24 * H4^2 * Y2 * Y3 * Y4^2 - U13 * H2^2 * Y1 + U13 * H2^2 * Y3 - U13 * H2 * H4 * Y1 * Y2 - U13 * H2 * H4 * Y1 * Y4 + U13 * H2 * H4 * Y2 * Y3 + U13 * H2 * H4 * Y3 * Y4 - U13 * H4^2 * Y1 * Y2 * Y4 + U13 * H4^2 * Y2 * Y3 * Y4 - U24 * V13 * H2^2 * Y1 * Y2 + U24 * V13 * H2^2 * Y1 * Y4 + U24 * V13 * H2^2 * Y2 * Y3 - U24 * V13 * H2^2 * Y3 * Y4 - U24 * V13 * H2 * H4 * Y1^2 * Y2 + U24 * V13 * H2 * H4 * Y1^2 * Y4 + U24 * V13 * H2 * H4 * Y2 * Y3^2 - U24 * V13 * H2 * H4 * Y3^2 * Y4 - U24 * V13 * H4^2 * Y1^2 * Y2 * Y3 + U24 * V13 * H4^2 * Y1^2 * Y3 * Y4 + U24 * V13 * H4^2 * Y1 * Y2 * Y3^2 - U24 * V13 * H4^2 * Y1 * Y3^2 * Y4 + U24 * H2^2 * Y2 - U24 * H2^2 * Y4 + U24 * H2 * H4 * Y1 * Y2 - U24 * H2 * H4 * Y1 * Y4 + U24 * H2 * H4 * Y2 * Y3 - U24 * H2 * H4 * Y3 * Y4 + U24 * H4^2 * Y1 * Y2 * Y3 - U24 * H4^2 * Y1 * Y3 * Y4, U13 * U23 * U24 * Y1^2 - U13 * U23 * U24 * Y1 * Y3 - U13 * U23 * U24 * Y1 * Y4 + U13 * U23 * U24 * Y3 * Y4 + U13 * U23 * U34 * V24 * Y1 * Y2^2 - U13 * U23 * U34 * V24 * Y1 * Y2 * Y3 - U13 * U23 * U34 * V24 * Y1 * Y2 * Y4 + U13 * U23 * U34 * V24 * Y1 * Y3 * Y4 - U13 * U23 * U34 * V24 * Y2^2 * Y4 + U13 * U23 * U34 * V24 * Y2 * Y3 * Y4 + U13 * U23 * U34 * V24 * Y2 * Y4^2 - U13 * U23 * U34 * V24 * Y3 * Y4^2 - U13 * U23 * U34 * Y1^2 + U13 * U23 * U34 * Y1 * Y3 + U13 * U23 * U34 * Y1 * Y4 - U13 * U23 * U34 * Y3 * Y4 + U13 * U23 * V24 * V34 * H2 * Y1 * Y2 - U13 * U23 * V24 * V34 * H2 * Y1 * Y3 - U13 * U23 * V24 * V34 * H2 * Y2 * Y4 + U13 * U23 * V24 * V34 * H2 * Y3 * Y4 + U13 * U23 * V24 * V34 * H4 * Y1 * Y2 * Y4 - U13 * U23 * V24 * V34 * H4 * Y1 * Y3 * Y4 - U13 * U23 * V24 * V34 * H4 * Y2 * Y4^2 + U13 * U23 * V24 * V34 * H4 * Y3 * Y4^2 + U13 * U23 * V24 * H2 * Y1 - U13 * U23 * V24 * H2 * Y2 + U13 * U23 * V24 * H4 * Y1 * Y4 - U13 * U23 * V24 * H4 * Y2 * Y4 - U13 * U23 * V34 * H2 * Y1 + U13 * U23 * V34 * H2 * Y3 - U13 * U23 * V34 * H4 * Y1 * Y4 + U13 * U23 * V34 * H4 * Y3 * Y4 - U13 * U24 * U34 * V23 * Y1 * Y2^2 + U13 * U24 * U34 * V23 * Y1 * Y2 * Y3 + U13 * U24 * U34 * V23 * Y1 * Y2 * Y4 - U13 * U24 * U34 * V23 * Y1 * Y3 * Y4 + U13 * U24 * U34 * V23 * Y2^2 * Y4 - U13 * U24 * U34 * V23 * Y2 * Y3 * Y4 - U13 * U24 * U34 * V23 * Y2 * Y4^2 + U13 * U24 * U34 * V23 * Y3 * Y4^2 + U13 * U24 * U34 * Y1^2 - U13 * U24 * U34 * Y1 * Y3 - U13 * U24 * U34 * Y1 * Y4 + U13 * U24 * U34 * Y3 * Y4 - U13 * U24 * V23 * V34 * H2 * Y1 * Y2 + U13 * U24 * V23 * V34 * H2 * Y1 * Y4 + U13 * U24 * V23 * V34 * H2 * Y2 * Y4 - U13 * U24 * V23 * V34 * H2 * Y4^2 - U13 * U24 * V23 * V34 * H4 * Y1 * Y2 * Y3 + U13 * U24 * V23 * V34 * H4 * Y1 * Y3 * Y4 + U13 * U24 * V23 * V34 * H4 * Y2 * Y3 * Y4 - U13 * U24 * V23 * V34 * H4 * Y3 * Y4^2 + U13 * U24 * V23 * H2 * Y1 + U13 * U24 * V23 * H2 * Y2 - U13 * U24 * V23 * H2 * Y3 - U13 * U24 * V23 * H2 * Y4 + U13 * U24 * V23 * H4 * Y1 * Y2 - U13 * U24 * V23 * H4 * Y3 * Y4 + U13 * U24 * V34 * H2 * Y1 - U13 * U24 * V34 * H2 * Y3 + U13 * U24 * V34 * H4 * Y1 * Y4 - U13 * U24 * V34 * H4 * Y3 * Y4 + U13 * U34 * V23 * V24 * H2 * Y1 * Y3 - U13 * U34 * V23 * V24 * H2 * Y1 * Y4 - U13 * U34 * V23 * V24 * H2 * Y3 * Y4 + U13 * U34 * V23 * V24 * H2 * Y4^2 + U13 * U34 * V23 * V24 * H4 * Y1 * Y2 * Y3 - U13 * U34 * V23 * V24 * H4 * Y1 * Y2 * Y4 - U13 * U34 * V23 * V24 * H4 * Y2 * Y3 * Y4 + U13 * U34 * V23 * V24 * H4 * Y2 * Y4^2 - U13 * U34 * V23 * H2 * Y1 + U13 * U34 * V23 * H2 * Y4 - U13 * U34 * V23 * H4 * Y1 * Y2 + U13 * U34 * V23 * H4 * Y2 * Y4 + U13 * U34 * V24 * H2 * Y1 - U13 * U34 * V24 * H2 * Y4 + U13 * U34 * V24 * H4 * Y1 * Y2 - U13 * U34 * V24 * H4 * Y2 * Y4 - U23 * U24 * V13 * H2 * Y1 + U23 * U24 * V13 * H2 * Y3 - U23 * U24 * V13 * H4 * Y1^2 + U23 * U24 * V13 * H4 * Y1 * Y3 + U23 * U24 * H2 + U23 * U24 * H4 * Y1 + U23 * U34 * V13 * H2 * Y1 - U23 * U34 * V13 * H2 * Y3 + U23 * U34 * V13 * H4 * Y1^2 - U23 * U34 * V13 * H4 * Y1 * Y3 - U23 * U34 * H2 - U23 * U34 * H4 * Y1 - U24 * U34 * V13 * H2 * Y1 + U24 * U34 * V13 * H2 * Y3 - U24 * U34 * V13 * H4 * Y1^2 + U24 * U34 * V13 * H4 * Y1 * Y3 + U24 * U34 * H2 + U24 * U34 * H4 * Y1, U13 * U14 * U24 * Y2^2 - U13 * U14 * U24 * Y2 * Y3 - U13 * U14 * U24 * Y2 * Y4 + U13 * U14 * U24 * Y3 * Y4 - U13 * U14 * V24 * H2 * Y2 + U13 * U14 * V24 * H2 * Y4 - U13 * U14 * V24 * H4 * Y2^2 + U13 * U14 * V24 * H4 * Y2 * Y4 + U13 * U14 * H2 + U13 * U14 * H4 * Y2 + U13 * U24 * U34 * V14 * Y1 * Y2^2 - U13 * U24 * U34 * V14 * Y1 * Y2 * Y3 - U13 * U24 * U34 * V14 * Y1 * Y2 * Y4 + U13 * U24 * U34 * V14 * Y1 * Y3 * Y4 - U13 * U24 * U34 * V14 * Y2^2 * Y4 + U13 * U24 * U34 * V14 * Y2 * Y3 * Y4 + U13 * U24 * U34 * V14 * Y2 * Y4^2 - U13 * U24 * U34 * V14 * Y3 * Y4^2 - U13 * U24 * U34 * Y2^2 + U13 * U24 * U34 * Y2 * Y3 + U13 * U24 * U34 * Y2 * Y4 - U13 * U24 * U34 * Y3 * Y4 + U13 * U24 * V14 * V34 * H2 * Y1 * Y2 - U13 * U24 * V14 * V34 * H2 * Y1 * Y4 - U13 * U24 * V14 * V34 * H2 * Y2 * Y4 + U13 * U24 * V14 * V34 * H2 * Y4^2 + U13 * U24 * V14 * V34 * H4 * Y1 * Y2 * Y3 - U13 * U24 * V14 * V34 * H4 * Y1 * Y3 * Y4 - U13 * U24 * V14 * V34 * H4 * Y2 * Y3 * Y4 + U13 * U24 * V14 * V34 * H4 * Y3 * Y4^2 - U13 * U24 * V34 * H2 * Y2 + U13 * U24 * V34 * H2 * Y4 - U13 * U24 * V34 * H4 * Y2 * Y3 + U13 * U24 * V34 * H4 * Y3 * Y4 - U13 * U34 * V14 * V24 * H2 * Y1 * Y2 + U13 * U34 * V14 * V24 * H2 * Y1 * Y4 + U13 * U34 * V14 * V24 * H2 * Y2 * Y4 - U13 * U34 * V14 * V24 * H2 * Y4^2 - U13 * U34 * V14 * V24 * H4 * Y1 * Y2^2 + U13 * U34 * V14 * V24 * H4 * Y1 * Y2 * Y4 + U13 * U34 * V14 * V24 * H4 * Y2^2 * Y4 - U13 * U34 * V14 * V24 * H4 * Y2 * Y4^2 + U13 * U34 * V14 * H2 * Y1 - U13 * U34 * V14 * H2 * Y4 + U13 * U34 * V14 * H4 * Y1 * Y2 - U13 * U34 * V14 * H4 * Y2 * Y4 + U13 * U34 * V24 * H2 * Y2 - U13 * U34 * V24 * H2 * Y4 + U13 * U34 * V24 * H4 * Y2^2 - U13 * U34 * V24 * H4 * Y2 * Y4 - U13 * U34 * H2 - U13 * U34 * H4 * Y2 - U14 * U24 * U34 * V13 * Y1 * Y2^2 + U14 * U24 * U34 * V13 * Y1 * Y2 * Y3 + U14 * U24 * U34 * V13 * Y1 * Y2 * Y4 - U14 * U24 * U34 * V13 * Y1 * Y3 * Y4 + U14 * U24 * U34 * V13 * Y2^2 * Y4 - U14 * U24 * U34 * V13 * Y2 * Y3 * Y4 - U14 * U24 * U34 * V13 * Y2 * Y4^2 + U14 * U24 * U34 * V13 * Y3 * Y4^2 + U14 * U24 * U34 * Y2^2 - U14 * U24 * U34 * Y2 * Y3 - U14 * U24 * U34 * Y2 * Y4 + U14 * U24 * U34 * Y3 * Y4 - U14 * U24 * V13 * V34 * H2 * Y1 * Y2 + U14 * U24 * V13 * V34 * H2 * Y1 * Y4 + U14 * U24 * V13 * V34 * H2 * Y2 * Y4 - U14 * U24 * V13 * V34 * H2 * Y4^2 - U14 * U24 * V13 * V34 * H4 * Y1 * Y2 * Y3 + U14 * U24 * V13 * V34 * H4 * Y1 * Y3 * Y4 + U14 * U24 * V13 * V34 * H4 * Y2 * Y3 * Y4 - U14 * U24 * V13 * V34 * H4 * Y3 * Y4^2 + U14 * U24 * V13 * H2 * Y2 - U14 * U24 * V13 * H2 * Y4 + U14 * U24 * V13 * H4 * Y2 * Y3 - U14 * U24 * V13 * H4 * Y3 * Y4 + U14 * U24 * V34 * H2 * Y2 - U14 * U24 * V34 * H2 * Y4 + U14 * U24 * V34 * H4 * Y2 * Y3 - U14 * U24 * V34 * H4 * Y3 * Y4 + U14 * U34 * V13 * V24 * H2 * Y1 * Y2 - U14 * U34 * V13 * V24 * H2 * Y1 * Y4 - U14 * U34 * V13 * V24 * H2 * Y2 * Y4 + U14 * U34 * V13 * V24 * H2 * Y4^2 + U14 * U34 * V13 * V24 * H4 * Y1 * Y2^2 - U14 * U34 * V13 * V24 * H4 * Y1 * Y2 * Y4 - U14 * U34 * V13 * V24 * H4 * Y2^2 * Y4 + U14 * U34 * V13 * V24 * H4 * Y2 * Y4^2 - U14 * U34 * V13 * H2 * Y1 + U14 * U34 * V13 * H2 * Y4 - U14 * U34 * V13 * H4 * Y1 * Y2 + U14 * U34 * V13 * H4 * Y2 * Y4 - U14 * U34 * V24 * H2 * Y2 + U14 * U34 * V24 * H2 * Y4 - U14 * U34 * V24 * H4 * Y2^2 + U14 * U34 * V24 * H4 * Y2 * Y4 + U14 * U34 * H2 + U14 * U34 * H4 * Y2, U12 * U34 * H2 * Y1^2 * Y3 - U12 * U34 * H2 * Y1^2 * Y4 - U12 * U34 * H2 * Y1 * Y3^2 + U12 * U34 * H2 * Y1 * Y4^2 - U12 * U34 * H2 * Y2^2 * Y3 + U12 * U34 * H2 * Y2^2 * Y4 + U12 * U34 * H2 * Y2 * Y3^2 - U12 * U34 * H2 * Y2 * Y4^2 + U12 * U34 * H4 * Y1^2 * Y2 * Y3 - U12 * U34 * H4 * Y1^2 * Y2 * Y4 - U12 * U34 * H4 * Y1 * Y2^2 * Y3 + U12 * U34 * H4 * Y1 * Y2^2 * Y4 - U12 * U34 * H4 * Y1 * Y3^2 * Y4 + U12 * U34 * H4 * Y1 * Y3 * Y4^2 + U12 * U34 * H4 * Y2 * Y3^2 * Y4 - U12 * U34 * H4 * Y2 * Y3 * Y4^2 + U12 * V34 * H2^2 * Y1 * Y3 - U12 * V34 * H2^2 * Y1 * Y4 - U12 * V34 * H2^2 * Y2 * Y3 + U12 * V34 * H2^2 * Y2 * Y4 + U12 * V34 * H2 * H4 * Y1 * Y3^2 - U12 * V34 * H2 * H4 * Y1 * Y4^2 - U12 * V34 * H2 * H4 * Y2 * Y3^2 + U12 * V34 * H2 * H4 * Y2 * Y4^2 + U12 * V34 * H4^2 * Y1 * Y3^2 * Y4 - U12 * V34 * H4^2 * Y1 * Y3 * Y4^2 - U12 * V34 * H4^2 * Y2 * Y3^2 * Y4 + U12 * V34 * H4^2 * Y2 * Y3 * Y4^2 - U12 * H2^2 * Y1 + U12 * H2^2 * Y2 - U12 * H2 * H4 * Y1 * Y3 - U12 * H2 * H4 * Y1 * Y4 + U12 * H2 * H4 * Y2 * Y3 + U12 * H2 * H4 * Y2 * Y4 - U12 * H4^2 * Y1 * Y3 * Y4 + U12 * H4^2 * Y2 * Y3 * Y4 - U34 * V12 * H2^2 * Y1 * Y3 + U34 * V12 * H2^2 * Y1 * Y4 + U34 * V12 * H2^2 * Y2 * Y3 - U34 * V12 * H2^2 * Y2 * Y4 - U34 * V12 * H2 * H4 * Y1^2 * Y3 + U34 * V12 * H2 * H4 * Y1^2 * Y4 + U34 * V12 * H2 * H4 * Y2^2 * Y3 - U34 * V12 * H2 * H4 * Y2^2 * Y4 - U34 * V12 * H4^2 * Y1^2 * Y2 * Y3 + U34 * V12 * H4^2 * Y1^2 * Y2 * Y4 + U34 * V12 * H4^2 * Y1 * Y2^2 * Y3 - U34 * V12 * H4^2 * Y1 * Y2^2 * Y4 + U34 * H2^2 * Y3 - U34 * H2^2 * Y4 + U34 * H2 * H4 * Y1 * Y3 - U34 * H2 * H4 * Y1 * Y4 + U34 * H2 * H4 * Y2 * Y3 - U34 * H2 * H4 * Y2 * Y4 + U34 * H4^2 * Y1 * Y2 * Y3 - U34 * H4^2 * Y1 * Y2 * Y4, U12 * U23 * U24 * Y1^2 - U12 * U23 * U24 * Y1 * Y3 - U12 * U23 * U24 * Y1 * Y4 + U12 * U23 * U24 * Y3 * Y4 + U12 * U23 * U34 * V24 * Y1 * Y2^2 - U12 * U23 * U34 * V24 * Y1 * Y2 * Y3 - U12 * U23 * U34 * V24 * Y1 * Y2 * Y4 + U12 * U23 * U34 * V24 * Y1 * Y3 * Y4 - U12 * U23 * U34 * V24 * Y2^2 * Y4 + U12 * U23 * U34 * V24 * Y2 * Y3 * Y4 + U12 * U23 * U34 * V24 * Y2 * Y4^2 - U12 * U23 * U34 * V24 * Y3 * Y4^2 - U12 * U23 * U34 * Y1^2 + U12 * U23 * U34 * Y1 * Y3 + U12 * U23 * U34 * Y1 * Y4 - U12 * U23 * U34 * Y3 * Y4 + U12 * U23 * V24 * V34 * H2 * Y1 * Y2 - U12 * U23 * V24 * V34 * H2 * Y1 * Y3 - U12 * U23 * V24 * V34 * H2 * Y2 * Y4 + U12 * U23 * V24 * V34 * H2 * Y3 * Y4 + U12 * U23 * V24 * V34 * H4 * Y1 * Y2 * Y4 - U12 * U23 * V24 * V34 * H4 * Y1 * Y3 * Y4 - U12 * U23 * V24 * V34 * H4 * Y2 * Y4^2 + U12 * U23 * V24 * V34 * H4 * Y3 * Y4^2 + U12 * U23 * V24 * H2 * Y1 - U12 * U23 * V24 * H2 * Y2 + U12 * U23 * V24 * H4 * Y1 * Y4 - U12 * U23 * V24 * H4 * Y2 * Y4 - U12 * U23 * V34 * H2 * Y1 + U12 * U23 * V34 * H2 * Y3 - U12 * U23 * V34 * H4 * Y1 * Y4 + U12 * U23 * V34 * H4 * Y3 * Y4 - U12 * U24 * U34 * V23 * Y1 * Y2^2 + U12 * U24 * U34 * V23 * Y1 * Y2 * Y3 + U12 * U24 * U34 * V23 * Y1 * Y2 * Y4 - U12 * U24 * U34 * V23 * Y1 * Y3 * Y4 + U12 * U24 * U34 * V23 * Y2^2 * Y4 - U12 * U24 * U34 * V23 * Y2 * Y3 * Y4 - U12 * U24 * U34 * V23 * Y2 * Y4^2 + U12 * U24 * U34 * V23 * Y3 * Y4^2 + U12 * U24 * U34 * Y1^2 - U12 * U24 * U34 * Y1 * Y3 - U12 * U24 * U34 * Y1 * Y4 + U12 * U24 * U34 * Y3 * Y4 - U12 * U24 * V23 * V34 * H2 * Y1 * Y2 + U12 * U24 * V23 * V34 * H2 * Y1 * Y4 + U12 * U24 * V23 * V34 * H2 * Y2 * Y4 - U12 * U24 * V23 * V34 * H2 * Y4^2 - U12 * U24 * V23 * V34 * H4 * Y1 * Y2 * Y3 + U12 * U24 * V23 * V34 * H4 * Y1 * Y3 * Y4 + U12 * U24 * V23 * V34 * H4 * Y2 * Y3 * Y4 - U12 * U24 * V23 * V34 * H4 * Y3 * Y4^2 + U12 * U24 * V23 * H2 * Y1 - U12 * U24 * V23 * H2 * Y4 + U12 * U24 * V23 * H4 * Y1 * Y3 - U12 * U24 * V23 * H4 * Y3 * Y4 + U12 * U24 * V34 * H2 * Y1 - U12 * U24 * V34 * H2 * Y4 + U12 * U24 * V34 * H4 * Y1 * Y3 - U12 * U24 * V34 * H4 * Y3 * Y4 + U12 * U34 * V23 * V24 * H2 * Y1 * Y3 - U12 * U34 * V23 * V24 * H2 * Y1 * Y4 - U12 * U34 * V23 * V24 * H2 * Y3 * Y4 + U12 * U34 * V23 * V24 * H2 * Y4^2 + U12 * U34 * V23 * V24 * H4 * Y1 * Y2 * Y3 - U12 * U34 * V23 * V24 * H4 * Y1 * Y2 * Y4 - U12 * U34 * V23 * V24 * H4 * Y2 * Y3 * Y4 + U12 * U34 * V23 * V24 * H4 * Y2 * Y4^2 - U12 * U34 * V23 * H2 * Y1 + U12 * U34 * V23 * H2 * Y2 - U12 * U34 * V23 * H2 * Y3 + U12 * U34 * V23 * H2 * Y4 - U12 * U34 * V23 * H4 * Y1 * Y3 + U12 * U34 * V23 * H4 * Y2 * Y4 + U12 * U34 * V24 * H2 * Y1 - U12 * U34 * V24 * H2 * Y2 + U12 * U34 * V24 * H4 * Y1 * Y4 - U12 * U34 * V24 * H4 * Y2 * Y4 - U23 * U24 * V12 * H2 * Y1 + U23 * U24 * V12 * H2 * Y2 - U23 * U24 * V12 * H4 * Y1^2 + U23 * U24 * V12 * H4 * Y1 * Y2 + U23 * U24 * H2 + U23 * U24 * H4 * Y1 + U23 * U34 * V12 * H2 * Y1 - U23 * U34 * V12 * H2 * Y2 + U23 * U34 * V12 * H4 * Y1^2 - U23 * U34 * V12 * H4 * Y1 * Y2 - U23 * U34 * H2 - U23 * U34 * H4 * Y1 - U24 * U34 * V12 * H2 * Y1 + U24 * U34 * V12 * H2 * Y2 - U24 * U34 * V12 * H4 * Y1^2 + U24 * U34 * V12 * H4 * Y1 * Y2 + U24 * U34 * H2 + U24 * U34 * H4 * Y1, U12 * U14 * U34 * Y2 * Y3 - U12 * U14 * U34 * Y2 * Y4 - U12 * U14 * U34 * Y3^2 + U12 * U14 * U34 * Y3 * Y4 + U12 * U14 * V34 * H2 * Y3 - U12 * U14 * V34 * H2 * Y4 + U12 * U14 * V34 * H4 * Y3^2 - U12 * U14 * V34 * H4 * Y3 * Y4 - U12 * U14 * H2 - U12 * U14 * H4 * Y3 + U12 * U24 * U34 * V14 * Y1 * Y2 * Y3 - U12 * U24 * U34 * V14 * Y1 * Y2 * Y4 - U12 * U24 * U34 * V14 * Y1 * Y3^2 + U12 * U24 * U34 * V14 * Y1 * Y3 * Y4 - U12 * U24 * U34 * V14 * Y2 * Y3 * Y4 + U12 * U24 * U34 * V14 * Y2 * Y4^2 + U12 * U24 * U34 * V14 * Y3^2 * Y4 - U12 * U24 * U34 * V14 * Y3 * Y4^2 - U12 * U24 * U34 * Y2 * Y3 + U12 * U24 * U34 * Y2 * Y4 + U12 * U24 * U34 * Y3^2 - U12 * U24 * U34 * Y3 * Y4 + U12 * U24 * V14 * V34 * H2 * Y1 * Y3 - U12 * U24 * V14 * V34 * H2 * Y1 * Y4 - U12 * U24 * V14 * V34 * H2 * Y3 * Y4 + U12 * U24 * V14 * V34 * H2 * Y4^2 + U12 * U24 * V14 * V34 * H4 * Y1 * Y3^2 - U12 * U24 * V14 * V34 * H4 * Y1 * Y3 * Y4 - U12 * U24 * V14 * V34 * H4 * Y3^2 * Y4 + U12 * U24 * V14 * V34 * H4 * Y3 * Y4^2 - U12 * U24 * V14 * H2 * Y1 + U12 * U24 * V14 * H2 * Y4 - U12 * U24 * V14 * H4 * Y1 * Y3 + U12 * U24 * V14 * H4 * Y3 * Y4 - U12 * U24 * V34 * H2 * Y3 + U12 * U24 * V34 * H2 * Y4 - U12 * U24 * V34 * H4 * Y3^2 + U12 * U24 * V34 * H4 * Y3 * Y4 + U12 * U24 * H2 + U12 * U24 * H4 * Y3 - U12 * U34 * V14 * V24 * H2 * Y1 * Y3 + U12 * U34 * V14 * V24 * H2 * Y1 * Y4 + U12 * U34 * V14 * V24 * H2 * Y3 * Y4 - U12 * U34 * V14 * V24 * H2 * Y4^2 - U12 * U34 * V14 * V24 * H4 * Y1 * Y2 * Y3 + U12 * U34 * V14 * V24 * H4 * Y1 * Y2 * Y4 + U12 * U34 * V14 * V24 * H4 * Y2 * Y3 * Y4 - U12 * U34 * V14 * V24 * H4 * Y2 * Y4^2 + U12 * U34 * V24 * H2 * Y3 - U12 * U34 * V24 * H2 * Y4 + U12 * U34 * V24 * H4 * Y2 * Y3 - U12 * U34 * V24 * H4 * Y2 * Y4 - U14 * U24 * U34 * V12 * Y1 * Y2 * Y3 + U14 * U24 * U34 * V12 * Y1 * Y2 * Y4 + U14 * U24 * U34 * V12 * Y1 * Y3^2 - U14 * U24 * U34 * V12 * Y1 * Y3 * Y4 + U14 * U24 * U34 * V12 * Y2 * Y3 * Y4 - U14 * U24 * U34 * V12 * Y2 * Y4^2 - U14 * U24 * U34 * V12 * Y3^2 * Y4 + U14 * U24 * U34 * V12 * Y3 * Y4^2 + U14 * U24 * U34 * Y2 * Y3 - U14 * U24 * U34 * Y2 * Y4 - U14 * U24 * U34 * Y3^2 + U14 * U24 * U34 * Y3 * Y4 - U14 * U24 * V12 * V34 * H2 * Y1 * Y3 + U14 * U24 * V12 * V34 * H2 * Y1 * Y4 + U14 * U24 * V12 * V34 * H2 * Y3 * Y4 - U14 * U24 * V12 * V34 * H2 * Y4^2 - U14 * U24 * V12 * V34 * H4 * Y1 * Y3^2 + U14 * U24 * V12 * V34 * H4 * Y1 * Y3 * Y4 + U14 * U24 * V12 * V34 * H4 * Y3^2 * Y4 - U14 * U24 * V12 * V34 * H4 * Y3 * Y4^2 + U14 * U24 * V12 * H2 * Y1 - U14 * U24 * V12 * H2 * Y4 + U14 * U24 * V12 * H4 * Y1 * Y3 - U14 * U24 * V12 * H4 * Y3 * Y4 + U14 * U24 * V34 * H2 * Y3 - U14 * U24 * V34 * H2 * Y4 + U14 * U24 * V34 * H4 * Y3^2 - U14 * U24 * V34 * H4 * Y3 * Y4 - U14 * U24 * H2 - U14 * U24 * H4 * Y3 + U14 * U34 * V12 * V24 * H2 * Y1 * Y3 - U14 * U34 * V12 * V24 * H2 * Y1 * Y4 - U14 * U34 * V12 * V24 * H2 * Y3 * Y4 + U14 * U34 * V12 * V24 * H2 * Y4^2 + U14 * U34 * V12 * V24 * H4 * Y1 * Y2 * Y3 - U14 * U34 * V12 * V24 * H4 * Y1 * Y2 * Y4 - U14 * U34 * V12 * V24 * H4 * Y2 * Y3 * Y4 + U14 * U34 * V12 * V24 * H4 * Y2 * Y4^2 - U14 * U34 * V12 * H2 * Y3 + U14 * U34 * V12 * H2 * Y4 - U14 * U34 * V12 * H4 * Y2 * Y3 + U14 * U34 * V12 * H4 * Y2 * Y4 - U14 * U34 * V24 * H2 * Y3 + U14 * U34 * V24 * H2 * Y4 - U14 * U34 * V24 * H4 * Y2 * Y3 + U14 * U34 * V24 * H4 * Y2 * Y4, U12 * U13 * U34 * Y2 * Y3 - U12 * U13 * U34 * Y2 * Y4 - U12 * U13 * U34 * Y3 * Y4 + U12 * U13 * U34 * Y4^2 + U12 * U13 * V34 * H2 * Y3 - U12 * U13 * V34 * H2 * Y4 + U12 * U13 * V34 * H4 * Y3 * Y4 - U12 * U13 * V34 * H4 * Y4^2 - U12 * U13 * H2 - U12 * U13 * H4 * Y4 + U12 * U23 * U34 * V13 * Y1 * Y2 * Y3 - U12 * U23 * U34 * V13 * Y1 * Y2 * Y4 - U12 * U23 * U34 * V13 * Y1 * Y3 * Y4 + U12 * U23 * U34 * V13 * Y1 * Y4^2 - U12 * U23 * U34 * V13 * Y2 * Y3^2 + U12 * U23 * U34 * V13 * Y2 * Y3 * Y4 + U12 * U23 * U34 * V13 * Y3^2 * Y4 - U12 * U23 * U34 * V13 * Y3 * Y4^2 - U12 * U23 * U34 * Y2 * Y3 + U12 * U23 * U34 * Y2 * Y4 + U12 * U23 * U34 * Y3 * Y4 - U12 * U23 * U34 * Y4^2 + U12 * U23 * V13 * V34 * H2 * Y1 * Y3 - U12 * U23 * V13 * V34 * H2 * Y1 * Y4 - U12 * U23 * V13 * V34 * H2 * Y3^2 + U12 * U23 * V13 * V34 * H2 * Y3 * Y4 + U12 * U23 * V13 * V34 * H4 * Y1 * Y3 * Y4 - U12 * U23 * V13 * V34 * H4 * Y1 * Y4^2 - U12 * U23 * V13 * V34 * H4 * Y3^2 * Y4 + U12 * U23 * V13 * V34 * H4 * Y3 * Y4^2 - U12 * U23 * V13 * H2 * Y1 + U12 * U23 * V13 * H2 * Y3 - U12 * U23 * V13 * H4 * Y1 * Y4 + U12 * U23 * V13 * H4 * Y3 * Y4 - U12 * U23 * V34 * H2 * Y3 + U12 * U23 * V34 * H2 * Y4 - U12 * U23 * V34 * H4 * Y3 * Y4 + U12 * U23 * V34 * H4 * Y4^2 + U12 * U23 * H2 + U12 * U23 * H4 * Y4 - U12 * U34 * V13 * V23 * H2 * Y1 * Y3 + U12 * U34 * V13 * V23 * H2 * Y1 * Y4 + U12 * U34 * V13 * V23 * H2 * Y3^2 - U12 * U34 * V13 * V23 * H2 * Y3 * Y4 - U12 * U34 * V13 * V23 * H4 * Y1 * Y2 * Y3 + U12 * U34 * V13 * V23 * H4 * Y1 * Y2 * Y4 + U12 * U34 * V13 * V23 * H4 * Y2 * Y3^2 - U12 * U34 * V13 * V23 * H4 * Y2 * Y3 * Y4 + U12 * U34 * V23 * H2 * Y3 - U12 * U34 * V23 * H2 * Y4 + U12 * U34 * V23 * H4 * Y2 * Y3 - U12 * U34 * V23 * H4 * Y2 * Y4 - U13 * U23 * U34 * V12 * Y1 * Y2 * Y3 + U13 * U23 * U34 * V12 * Y1 * Y2 * Y4 + U13 * U23 * U34 * V12 * Y1 * Y3 * Y4 - U13 * U23 * U34 * V12 * Y1 * Y4^2 + U13 * U23 * U34 * V12 * Y2 * Y3^2 - U13 * U23 * U34 * V12 * Y2 * Y3 * Y4 - U13 * U23 * U34 * V12 * Y3^2 * Y4 + U13 * U23 * U34 * V12 * Y3 * Y4^2 + U13 * U23 * U34 * Y2 * Y3 - U13 * U23 * U34 * Y2 * Y4 - U13 * U23 * U34 * Y3 * Y4 + U13 * U23 * U34 * Y4^2 - U13 * U23 * V12 * V34 * H2 * Y1 * Y3 + U13 * U23 * V12 * V34 * H2 * Y1 * Y4 + U13 * U23 * V12 * V34 * H2 * Y3^2 - U13 * U23 * V12 * V34 * H2 * Y3 * Y4 - U13 * U23 * V12 * V34 * H4 * Y1 * Y3 * Y4 + U13 * U23 * V12 * V34 * H4 * Y1 * Y4^2 + U13 * U23 * V12 * V34 * H4 * Y3^2 * Y4 - U13 * U23 * V12 * V34 * H4 * Y3 * Y4^2 + U13 * U23 * V12 * H2 * Y1 - U13 * U23 * V12 * H2 * Y3 + U13 * U23 * V12 * H4 * Y1 * Y4 - U13 * U23 * V12 * H4 * Y3 * Y4 + U13 * U23 * V34 * H2 * Y3 - U13 * U23 * V34 * H2 * Y4 + U13 * U23 * V34 * H4 * Y3 * Y4 - U13 * U23 * V34 * H4 * Y4^2 - U13 * U23 * H2 - U13 * U23 * H4 * Y4 + U13 * U34 * V12 * V23 * H2 * Y1 * Y3 - U13 * U34 * V12 * V23 * H2 * Y1 * Y4 - U13 * U34 * V12 * V23 * H2 * Y3^2 + U13 * U34 * V12 * V23 * H2 * Y3 * Y4 + U13 * U34 * V12 * V23 * H4 * Y1 * Y2 * Y3 - U13 * U34 * V12 * V23 * H4 * Y1 * Y2 * Y4 - U13 * U34 * V12 * V23 * H4 * Y2 * Y3^2 + U13 * U34 * V12 * V23 * H4 * Y2 * Y3 * Y4 - U13 * U34 * V12 * H2 * Y3 + U13 * U34 * V12 * H2 * Y4 - U13 * U34 * V12 * H4 * Y2 * Y3 + U13 * U34 * V12 * H4 * Y2 * Y4 - U13 * U34 * V23 * H2 * Y3 + U13 * U34 * V23 * H2 * Y4 - U13 * U34 * V23 * H4 * Y2 * Y3 + U13 * U34 * V23 * H4 * Y2 * Y4, E3 * H4^2 * X3 - E3 * H4^2 * X4 + E3 * H4 * Y3 - E3 * H4 * Y4 - E4 * H3 * H4 * X3 + E4 * H3 * H4 * X4 + E4 * H3 * Y3 - E4 * H3 * Y4 - E4 * H4 * X3 * Y1 - E4 * H4 * X3 * Y2 + E4 * H4 * X3 * Y3 - E4 * H4 * X3 * Y4 + E4 * H4 * X4 * Y1 + E4 * H4 * X4 * Y2 + E4 * H4 * X4 * Y3 - E4 * H4 * X4 * Y4 + E4 * Y3^2 - E4 * Y4^2 + 2 * H3 * X3 - 2 * H3 * X4 + H4 * X3^2 - H4 * X4^2 + X3 * Y1 + X3 * Y2 + X3 * Y3 + X3 * Y4 - X4 * Y1 - X4 * Y2 - X4 * Y3 - X4 * Y4, U23 * U24 * E4 * Y1 - U23 * U24 * E4 * Y2 + U23 * U24 * X1 - U23 * U24 * X4 - U23 * U34 * V24 * E4 * Y2^2 + U23 * U34 * V24 * E4 * Y2 * Y3 + U23 * U34 * V24 * E4 * Y2 * Y4 - U23 * U34 * V24 * E4 * Y3 * Y4 - U23 * U34 * E4 * Y1 + U23 * U34 * E4 * Y2 - U23 * U34 * X1 + U23 * U34 * X4 - U23 * V24 * V34 * H4 * X1 * Y2 + U23 * V24 * V34 * H4 * X1 * Y3 + U23 * V24 * V34 * H4 * X3 * Y2 - U23 * V24 * V34 * H4 * X3 * Y3 - U23 * V24 * V34 * Y1 * Y2 + U23 * V24 * V34 * Y1 * Y3 + U23 * V24 * V34 * Y2^2 - U23 * V24 * V34 * Y2 * Y4 - U23 * V24 * V34 * Y3^2 + U23 * V24 * V34 * Y3 * Y4 - U23 * V24 * H4 * X1 + U23 * V24 * H4 * X3 - U23 * V24 * Y1 + U23 * V24 * Y2 + U23 * V24 * Y3 - U23 * V24 * Y4 + U23 * V34 * H4 * X1 - U23 * V34 * H4 * X3 + U23 * V34 * Y1 - U23 * V34 * Y2 - U23 * V34 * Y3 + U23 * V34 * Y4 + U24 * U34 * V23 * E4 * Y2^2 - U24 * U34 * V23 * E4 * Y2 * Y3 - U24 * U34 * V23 * E4 * Y2 * Y4 + U24 * U34 * V23 * E4 * Y3 * Y4 + U24 * U34 * E4 * Y1 - U24 * U34 * E4 * Y2 + U24 * U34 * X1 - U24 * U34 * X4 + U24 * V23 * V34 * H4 * X1 * Y2 - U24 * V23 * V34 * H4 * X1 * Y4 - U24 * V23 * V34 * H4 * X4 * Y2 + U24 * V23 * V34 * H4 * X4 * Y4 + U24 * V23 * V34 * Y1 * Y2 - U24 * V23 * V34 * Y1 * Y4 - U24 * V23 * V34 * Y2^2 + U24 * V23 * V34 * Y2 * Y3 - U24 * V23 * V34 * Y3 * Y4 + U24 * V23 * V34 * Y4^2 - U24 * V23 * H4 * X1 + U24 * V23 * H4 * X4 - U24 * V23 * Y1 + U24 * V23 * Y4 - U24 * V34 * H4 * X1 + U24 * V34 * H4 * X4 - U24 * V34 * Y1 + U24 * V34 * Y2 - U34 * V23 * V24 * H4 * X1 * Y3 + U34 * V23 * V24 * H4 * X1 * Y4 + U34 * V23 * V24 * H4 * X4 * Y3 - U34 * V23 * V24 * H4 * X4 * Y4 - U34 * V23 * V24 * Y1 * Y3 + U34 * V23 * V24 * Y1 * Y4 - U34 * V23 * V24 * Y2 * Y3 + U34 * V23 * V24 * Y2 * Y4 + U34 * V23 * V24 * Y3^2 - U34 * V23 * V24 * Y4^2 + U34 * V23 * H4 * X1 - U34 * V23 * H4 * X4 + U34 * V23 * Y1 - U34 * V23 * Y4 - U34 * V24 * H4 * X1 + U34 * V24 * H4 * X4 - U34 * V24 * Y1 + U34 * V24 * Y3 + V23 * V24 * V34 * H4 * Y2 * Y3 - V23 * V24 * V34 * H4 * Y2 * Y4 - V23 * V24 * V34 * H4 * Y3^2 + V23 * V24 * V34 * H4 * Y3 * Y4 - V23 * V24 * H4 * Y2 + V23 * V24 * H4 * Y3 - V24 * V34 * H4 * Y3 + V24 * V34 * H4 * Y4 + V24 * H4, U13 * U14 * E4 * Y1 - U13 * U14 * E4 * Y2 - U13 * U14 * X2 + U13 * U14 * X4 + U13 * U34 * V14 * E4 * Y1^2 - 2 * U13 * U34 * V14 * E4 * Y1 * Y4 - U13 * U34 * V14 * E4 * Y2 * Y3 + U13 * U34 * V14 * E4 * Y2 * Y4 + U13 * U34 * V14 * E4 * Y3 * Y4 - U13 * U34 * V14 * X2 * Y3 + U13 * U34 * V14 * X2 * Y4 + U13 * U34 * V14 * X4 * Y3 - U13 * U34 * V14 * X4 * Y4 - U13 * U34 * E4 * Y1 + U13 * U34 * E4 * Y2 + U13 * U34 * X2 - U13 * U34 * X4 + U13 * V14 * V34 * H4 * X2 * Y1 - U13 * V14 * V34 * H4 * X2 * Y4 - U13 * V14 * V34 * H4 * X3 * Y1 + U13 * V14 * V34 * H4 * X3 * Y4 - U13 * V14 * V34 * Y1^2 + U13 * V14 * V34 * Y1 * Y2 - U13 * V14 * V34 * Y1 * Y3 + 2 * U13 * V14 * V34 * Y1 * Y4 - U13 * V14 * V34 * Y2 * Y4 + U13 * V14 * V34 * Y3 * Y4 - U13 * V14 * V34 * Y4^2 - U13 * V34 * H4 * X2 + U13 * V34 * H4 * X3 + U13 * V34 * Y1 - U13 * V34 * Y2 + U13 * V34 * Y3 - U13 * V34 * Y4 - U14 * U34 * V13 * E4 * Y1^2 + 2 * U14 * U34 * V13 * E4 * Y1 * Y4 + U14 * U34 * V13 * E4 * Y2 * Y3 - U14 * U34 * V13 * E4 * Y2 * Y4 - U14 * U34 * V13 * E4 * Y3 * Y4 + U14 * U34 * V13 * X2 * Y3 - U14 * U34 * V13 * X2 * Y4 - U14 * U34 * V13 * X4 * Y3 + U14 * U34 * V13 * X4 * Y4 + U14 * U34 * E4 * Y1 - U14 * U34 * E4 * Y2 - U14 * U34 * X2 + U14 * U34 * X4 - U14 * V13 * V34 * H4 * X2 * Y1 - U14 * V13 * V34 * H4 * X2 * Y3 + 2 * U14 * V13 * V34 * H4 * X2 * Y4 + U14 * V13 * V34 * H4 * X4 * Y1 + U14 * V13 * V34 * H4 * X4 * Y3 - 2 * U14 * V13 * V34 * H4 * X4 * Y4 + U14 * V13 * V34 * Y1^2 - U14 * V13 * V34 * Y1 * Y2 - U14 * V13 * V34 * Y1 * Y4 - U14 * V13 * V34 * Y2 * Y3 + 2 * U14 * V13 * V34 * Y2 * Y4 + U14 * V13 * V34 * Y3 * Y4 - U14 * V13 * V34 * Y4^2 + 2 * U14 * V13 * H4 * X2 - 2 * U14 * V13 * H4 * X4 - U14 * V13 * Y1 + 2 * U14 * V13 * Y2 - U14 * V13 * Y4 + U14 * V34 * H4 * X2 - U14 * V34 * H4 * X4 - U14 * V34 * Y1 + U14 * V34 * Y2 + U34 * V13 * V14 * H4 * X2 * Y3 - U34 * V13 * V14 * H4 * X2 * Y4 - U34 * V13 * V14 * H4 * X4 * Y3 + U34 * V13 * V14 * H4 * X4 * Y4 + U34 * V13 * V14 * Y1 * Y3 - U34 * V13 * V14 * Y1 * Y4 + U34 * V13 * V14 * Y2 * Y3 - U34 * V13 * V14 * Y2 * Y4 - 2 * U34 * V13 * V14 * Y3 * Y4 + 2 * U34 * V13 * V14 * Y4^2 - U34 * V13 * H4 * X2 + U34 * V13 * H4 * X4 - U34 * V13 * Y2 - U34 * V13 * Y3 + 2 * U34 * V13 * Y4 + U34 * V14 * H4 * X2 - U34 * V14 * H4 * X4 + U34 * V14 * Y2 - U34 * V14 * Y4 - V13 * V14 * V34 * H4 * Y1 * Y3 + V13 * V14 * V34 * H4 * Y1 * Y4 + V13 * V14 * V34 * H4 * Y3 * Y4 - V13 * V14 * V34 * H4 * Y4^2 + V13 * V14 * H4 * Y1 - V13 * V14 * H4 * Y4 + V13 * V34 * H4 * Y3 - V13 * V34 * H4 * Y4 - V13 * H4, U12 * U14 * E4 * Y1 - U12 * U14 * E4 * Y3 - U12 * U14 * X3 + U12 * U14 * X4 + U12 * U24 * V14 * E4 * Y1^2 - 2 * U12 * U24 * V14 * E4 * Y1 * Y4 - U12 * U24 * V14 * E4 * Y2 * Y3 + U12 * U24 * V14 * E4 * Y2 * Y4 + U12 * U24 * V14 * E4 * Y3 * Y4 - U12 * U24 * V14 * X3 * Y2 + U12 * U24 * V14 * X3 * Y4 + U12 * U24 * V14 * X4 * Y2 - U12 * U24 * V14 * X4 * Y4 - U12 * U24 * E4 * Y1 + U12 * U24 * E4 * Y3 + U12 * U24 * X3 - U12 * U24 * X4 - U12 * V14 * V24 * H4 * X2 * Y1 + U12 * V14 * V24 * H4 * X2 * Y4 + U12 * V14 * V24 * H4 * X3 * Y1 - U12 * V14 * V24 * H4 * X3 * Y4 - U12 * V14 * V24 * Y1^2 - U12 * V14 * V24 * Y1 * Y2 + U12 * V14 * V24 * Y1 * Y3 + 2 * U12 * V14 * V24 * Y1 * Y4 + U12 * V14 * V24 * Y2 * Y4 - U12 * V14 * V24 * Y3 * Y4 - U12 * V14 * V24 * Y4^2 + U12 * V24 * H4 * X2 - U12 * V24 * H4 * X3 + U12 * V24 * Y1 + U12 * V24 * Y2 - U12 * V24 * Y3 - U12 * V24 * Y4 - U14 * U24 * V12 * E4 * Y1^2 + 2 * U14 * U24 * V12 * E4 * Y1 * Y4 + U14 * U24 * V12 * E4 * Y2 * Y3 - U14 * U24 * V12 * E4 * Y2 * Y4 - U14 * U24 * V12 * E4 * Y3 * Y4 + U14 * U24 * V12 * X3 * Y2 - U14 * U24 * V12 * X3 * Y4 - U14 * U24 * V12 * X4 * Y2 + U14 * U24 * V12 * X4 * Y4 + U14 * U24 * E4 * Y1 - U14 * U24 * E4 * Y3 - U14 * U24 * X3 + U14 * U24 * X4 - U14 * V12 * V24 * H4 * X3 * Y1 - U14 * V12 * V24 * H4 * X3 * Y2 + 2 * U14 * V12 * V24 * H4 * X3 * Y4 + U14 * V12 * V24 * H4 * X4 * Y1 + U14 * V12 * V24 * H4 * X4 * Y2 - 2 * U14 * V12 * V24 * H4 * X4 * Y4 + U14 * V12 * V24 * Y1^2 - U14 * V12 * V24 * Y1 * Y3 - U14 * V12 * V24 * Y1 * Y4 - U14 * V12 * V24 * Y2 * Y3 + U14 * V12 * V24 * Y2 * Y4 + 2 * U14 * V12 * V24 * Y3 * Y4 - U14 * V12 * V24 * Y4^2 + 2 * U14 * V12 * H4 * X3 - 2 * U14 * V12 * H4 * X4 - U14 * V12 * Y1 + 2 * U14 * V12 * Y3 - U14 * V12 * Y4 + U14 * V24 * H4 * X3 - U14 * V24 * H4 * X4 - U14 * V24 * Y1 + U14 * V24 * Y3 + U24 * V12 * V14 * H4 * X3 * Y2 - U24 * V12 * V14 * H4 * X3 * Y4 - U24 * V12 * V14 * H4 * X4 * Y2 + U24 * V12 * V14 * H4 * X4 * Y4 + U24 * V12 * V14 * Y1 * Y2 - U24 * V12 * V14 * Y1 * Y4 + U24 * V12 * V14 * Y2 * Y3 - 2 * U24 * V12 * V14 * Y2 * Y4 - U24 * V12 * V14 * Y3 * Y4 + 2 * U24 * V12 * V14 * Y4^2 - U24 * V12 * H4 * X3 + U24 * V12 * H4 * X4 - U24 * V12 * Y2 - U24 * V12 * Y3 + 2 * U24 * V12 * Y4 + U24 * V14 * H4 * X3 - U24 * V14 * H4 * X4 + U24 * V14 * Y3 - U24 * V14 * Y4 - V12 * V14 * V24 * H4 * Y1 * Y2 + V12 * V14 * V24 * H4 * Y1 * Y4 + V12 * V14 * V24 * H4 * Y2 * Y4 - V12 * V14 * V24 * H4 * Y4^2 + V12 * V14 * H4 * Y1 - V12 * V14 * H4 * Y4 + V12 * V24 * H4 * Y2 - V12 * V24 * H4 * Y4 - V12 * H4, U12 * U14 * U34 * V24 * Y3^2 - 2 * U12 * U14 * U34 * V24 * Y3 * Y4 + U12 * U14 * U34 * V24 * Y4^2 - U12 * U14 * U34 * Y3 + U12 * U14 * U34 * Y4 - U12 * U14 * V24 * V34 * H2 * Y3 + U12 * U14 * V24 * V34 * H2 * Y4 - U12 * U14 * V24 * V34 * H4 * Y3^2 + U12 * U14 * V24 * V34 * H4 * Y3 * Y4 + U12 * U14 * V24 * H2 + U12 * U14 * V24 * H4 * Y3 - U12 * U24 * U34 * V14 * V24 * Y1 * Y2 * Y3 + U12 * U24 * U34 * V14 * V24 * Y1 * Y2 * Y4 + U12 * U24 * U34 * V14 * V24 * Y1 * Y3^2 - U12 * U24 * U34 * V14 * V24 * Y1 * Y3 * Y4 + U12 * U24 * U34 * V14 * V24 * Y2 * Y3 * Y4 - U12 * U24 * U34 * V14 * V24 * Y2 * Y4^2 - U12 * U24 * U34 * V14 * V24 * Y3^2 * Y4 + U12 * U24 * U34 * V14 * V24 * Y3 * Y4^2 - U12 * U24 * U34 * V14 * Y1 * Y3 + U12 * U24 * U34 * V14 * Y1 * Y4 + U12 * U24 * U34 * V14 * Y3 * Y4 - U12 * U24 * U34 * V14 * Y4^2 + U12 * U24 * U34 * V24 * Y2 * Y3 - U12 * U24 * U34 * V24 * Y2 * Y4 - U12 * U24 * U34 * V24 * Y3^2 + U12 * U24 * U34 * V24 * Y3 * Y4 + U12 * U24 * U34 * Y3 - U12 * U24 * U34 * Y4 - U12 * U24 * V14 * V24 * V34 * H2 * Y1 * Y3 + U12 * U24 * V14 * V24 * V34 * H2 * Y1 * Y4 + U12 * U24 * V14 * V24 * V34 * H2 * Y3 * Y4 - U12 * U24 * V14 * V24 * V34 * H2 * Y4^2 - U12 * U24 * V14 * V24 * V34 * H4 * Y1 * Y3^2 + U12 * U24 * V14 * V24 * V34 * H4 * Y1 * Y3 * Y4 + U12 * U24 * V14 * V24 * V34 * H4 * Y3^2 * Y4 - U12 * U24 * V14 * V24 * V34 * H4 * Y3 * Y4^2 + U12 * U24 * V14 * V24 * H2 * Y1 - U12 * U24 * V14 * V24 * H2 * Y4 + U12 * U24 * V14 * V24 * H4 * Y1 * Y3 - U12 * U24 * V14 * V24 * H4 * Y3 * Y4 + U12 * U24 * V24 * V34 * H2 * Y3 - U12 * U24 * V24 * V34 * H2 * Y4 + U12 * U24 * V24 * V34 * H4 * Y3^2 - U12 * U24 * V24 * V34 * H4 * Y3 * Y4 - U12 * U24 * V24 * H2 - U12 * U24 * V24 * H4 * Y3 + U12 * U34 * V14 * V24^2 * H2 * Y1 * Y3 - U12 * U34 * V14 * V24^2 * H2 * Y1 * Y4 - U12 * U34 * V14 * V24^2 * H2 * Y3 * Y4 + U12 * U34 * V14 * V24^2 * H2 * Y4^2 + U12 * U34 * V14 * V24^2 * H4 * Y1 * Y2 * Y3 - U12 * U34 * V14 * V24^2 * H4 * Y1 * Y2 * Y4 - U12 * U34 * V14 * V24^2 * H4 * Y2 * Y3 * Y4 + U12 * U34 * V14 * V24^2 * H4 * Y2 * Y4^2 - U12 * U34 * V24^2 * H2 * Y3 + U12 * U34 * V24^2 * H2 * Y4 - U12 * U34 * V24^2 * H4 * Y2 * Y3 + U12 * U34 * V24^2 * H4 * Y2 * Y4 + U14 * U24 * U34 * V12 * V24 * Y1 * Y2 * Y3 - U14 * U24 * U34 * V12 * V24 * Y1 * Y2 * Y4 - U14 * U24 * U34 * V12 * V24 * Y1 * Y3^2 + U14 * U24 * U34 * V12 * V24 * Y1 * Y3 * Y4 - U14 * U24 * U34 * V12 * V24 * Y2 * Y3 * Y4 + U14 * U24 * U34 * V12 * V24 * Y2 * Y4^2 + U14 * U24 * U34 * V12 * V24 * Y3^2 * Y4 - U14 * U24 * U34 * V12 * V24 * Y3 * Y4^2 + U14 * U24 * U34 * V12 * Y1 * Y3 - U14 * U24 * U34 * V12 * Y1 * Y4 - U14 * U24 * U34 * V12 * Y2 * Y3 + U14 * U24 * U34 * V12 * Y2 * Y4 - U14 * U24 * U34 * V24 * Y2 * Y3 + U14 * U24 * U34 * V24 * Y2 * Y4 + U14 * U24 * U34 * V24 * Y3^2 - U14 * U24 * U34 * V24 * Y3 * Y4 - U14 * U24 * U34 * Y3 + U14 * U24 * U34 * Y4 + U14 * U24 * V12 * V24 * V34 * H2 * Y1 * Y3 - U14 * U24 * V12 * V24 * V34 * H2 * Y1 * Y4 - U14 * U24 * V12 * V24 * V34 * H2 * Y3 * Y4 + U14 * U24 * V12 * V24 * V34 * H2 * Y4^2 + U14 * U24 * V12 * V24 * V34 * H4 * Y1 * Y3^2 - U14 * U24 * V12 * V24 * V34 * H4 * Y1 * Y3 * Y4 - U14 * U24 * V12 * V24 * V34 * H4 * Y3^2 * Y4 + U14 * U24 * V12 * V24 * V34 * H4 * Y3 * Y4^2 - U14 * U24 * V12 * V24 * H2 * Y1 + U14 * U24 * V12 * V24 * H2 * Y4 - U14 * U24 * V12 * V24 * H4 * Y1 * Y3 + U14 * U24 * V12 * V24 * H4 * Y3 * Y4 - U14 * U24 * V24 * V34 * H2 * Y3 + U14 * U24 * V24 * V34 * H2 * Y4 - U14 * U24 * V24 * V34 * H4 * Y3^2 + U14 * U24 * V24 * V34 * H4 * Y3 * Y4 + U14 * U24 * V24 * H2 + U14 * U24 * V24 * H4 * Y3 - U14 * U34 * V12 * V24^2 * H2 * Y1 * Y3 + U14 * U34 * V12 * V24^2 * H2 * Y1 * Y4 + U14 * U34 * V12 * V24^2 * H2 * Y3 * Y4 - U14 * U34 * V12 * V24^2 * H2 * Y4^2 - U14 * U34 * V12 * V24^2 * H4 * Y1 * Y2 * Y3 + U14 * U34 * V12 * V24^2 * H4 * Y1 * Y2 * Y4 + U14 * U34 * V12 * V24^2 * H4 * Y2 * Y3 * Y4 - U14 * U34 * V12 * V24^2 * H4 * Y2 * Y4^2 + U14 * U34 * V12 * V24 * H2 * Y3 - U14 * U34 * V12 * V24 * H2 * Y4 + U14 * U34 * V12 * V24 * H4 * Y2 * Y3 - U14 * U34 * V12 * V24 * H4 * Y2 * Y4 + U14 * U34 * V24^2 * H2 * Y3 - U14 * U34 * V24^2 * H2 * Y4 + U14 * U34 * V24^2 * H4 * Y2 * Y3 - U14 * U34 * V24^2 * H4 * Y2 * Y4, U12 * U14 * U23 * Y2 - U12 * U14 * U23 * Y3 - U12 * U14 * U34 * V23 * Y2^2 + 2 * U12 * U14 * U34 * V23 * Y2 * Y4 + U12 * U14 * U34 * V23 * Y3^2 - 2 * U12 * U14 * U34 * V23 * Y3 * Y4 + U12 * U14 * U34 * Y2 - U12 * U14 * U34 * Y3 - U12 * U14 * V23 * V34 * H2 * Y2 - U12 * U14 * V23 * V34 * H2 * Y3 + 2 * U12 * U14 * V23 * V34 * H2 * Y4 - U12 * U14 * V23 * V34 * H4 * Y2 * Y3 - U12 * U14 * V23 * V34 * H4 * Y3^2 + 2 * U12 * U14 * V23 * V34 * H4 * Y3 * Y4 + 2 * U12 * U14 * V23 * H2 + 2 * U12 * U14 * V23 * H4 * Y3 + U12 * U14 * V34 * H2 + U12 * U14 * V34 * H4 * Y3 + U12 * U23 * U24 * V14 * Y1 * Y2 - U12 * U23 * U24 * V14 * Y1 * Y3 - U12 * U23 * U24 * V14 * Y2 * Y4 + U12 * U23 * U24 * V14 * Y3 * Y4 - U12 * U23 * U24 * Y2 + U12 * U23 * U24 * Y3 + U12 * U23 * U34 * V14 * V24 * Y1 * Y2^2 - U12 * U23 * U34 * V14 * V24 * Y1 * Y2 * Y3 - U12 * U23 * U34 * V14 * V24 * Y1 * Y2 * Y4 + U12 * U23 * U34 * V14 * V24 * Y1 * Y3 * Y4 - U12 * U23 * U34 * V14 * V24 * Y2^2 * Y4 + U12 * U23 * U34 * V14 * V24 * Y2 * Y3 * Y4 + U12 * U23 * U34 * V14 * V24 * Y2 * Y4^2 - U12 * U23 * U34 * V14 * V24 * Y3 * Y4^2 - U12 * U23 * U34 * V24 * Y2^2 + U12 * U23 * U34 * V24 * Y2 * Y3 + U12 * U23 * U34 * V24 * Y2 * Y4 - U12 * U23 * U34 * V24 * Y3 * Y4 + U12 * U23 * V14 * V24 * V34 * H2 * Y1 * Y2 - U12 * U23 * V14 * V24 * V34 * H2 * Y1 * Y3 - U12 * U23 * V14 * V24 * V34 * H2 * Y2 * Y4 + U12 * U23 * V14 * V24 * V34 * H2 * Y3 * Y4 + U12 * U23 * V14 * V24 * V34 * H4 * Y1 * Y2 * Y4 - U12 * U23 * V14 * V24 * V34 * H4 * Y1 * Y3 * Y4 - U12 * U23 * V14 * V24 * V34 * H4 * Y2 * Y4^2 + U12 * U23 * V14 * V24 * V34 * H4 * Y3 * Y4^2 - U12 * U23 * V24 * V34 * H2 * Y2 + U12 * U23 * V24 * V34 * H2 * Y3 - U12 * U23 * V24 * V34 * H4 * Y2 * Y4 + U12 * U23 * V24 * V34 * H4 * Y3 * Y4 - U12 * U24 * U34 * V14 * V23 * Y1 * Y2^2 + 2 * U12 * U24 * U34 * V14 * V23 * Y1 * Y2 * Y4 + U12 * U24 * U34 * V14 * V23 * Y1 * Y3^2 - 2 * U12 * U24 * U34 * V14 * V23 * Y1 * Y3 * Y4 + U12 * U24 * U34 * V14 * V23 * Y2^2 * Y4 - 2 * U12 * U24 * U34 * V14 * V23 * Y2 * Y4^2 - U12 * U24 * U34 * V14 * V23 * Y3^2 * Y4 + 2 * U12 * U24 * U34 * V14 * V23 * Y3 * Y4^2 + U12 * U24 * U34 * V14 * Y1 * Y2 - U12 * U24 * U34 * V14 * Y1 * Y3 - U12 * U24 * U34 * V14 * Y2 * Y4 + U12 * U24 * U34 * V14 * Y3 * Y4 + U12 * U24 * U34 * V23 * Y2^2 - 2 * U12 * U24 * U34 * V23 * Y2 * Y4 - U12 * U24 * U34 * V23 * Y3^2 + 2 * U12 * U24 * U34 * V23 * Y3 * Y4 - U12 * U24 * U34 * Y2 + U12 * U24 * U34 * Y3 - U12 * U24 * V14 * V23 * V34 * H2 * Y1 * Y2 - U12 * U24 * V14 * V23 * V34 * H2 * Y1 * Y3 + 2 * U12 * U24 * V14 * V23 * V34 * H2 * Y1 * Y4 + U12 * U24 * V14 * V23 * V34 * H2 * Y2 * Y4 + U12 * U24 * V14 * V23 * V34 * H2 * Y3 * Y4 - 2 * U12 * U24 * V14 * V23 * V34 * H2 * Y4^2 - U12 * U24 * V14 * V23 * V34 * H4 * Y1 * Y2 * Y3 - U12 * U24 * V14 * V23 * V34 * H4 * Y1 * Y3^2 + 2 * U12 * U24 * V14 * V23 * V34 * H4 * Y1 * Y3 * Y4 + U12 * U24 * V14 * V23 * V34 * H4 * Y2 * Y3 * Y4 + U12 * U24 * V14 * V23 * V34 * H4 * Y3^2 * Y4 - 2 * U12 * U24 * V14 * V23 * V34 * H4 * Y3 * Y4^2 + 2 * U12 * U24 * V14 * V23 * H2 * Y1 - 2 * U12 * U24 * V14 * V23 * H2 * Y4 + 2 * U12 * U24 * V14 * V23 * H4 * Y1 * Y3 - 2 * U12 * U24 * V14 * V23 * H4 * Y3 * Y4 + U12 * U24 * V14 * V34 * H2 * Y1 - U12 * U24 * V14 * V34 * H2 * Y4 + U12 * U24 * V14 * V34 * H4 * Y1 * Y3 - U12 * U24 * V14 * V34 * H4 * Y3 * Y4 + U12 * U24 * V23 * V34 * H2 * Y2 + U12 * U24 * V23 * V34 * H2 * Y3 - 2 * U12 * U24 * V23 * V34 * H2 * Y4 + U12 * U24 * V23 * V34 * H4 * Y2 * Y3 + U12 * U24 * V23 * V34 * H4 * Y3^2 - 2 * U12 * U24 * V23 * V34 * H4 * Y3 * Y4 - 2 * U12 * U24 * V23 * H2 - 2 * U12 * U24 * V23 * H4 * Y3 - U12 * U24 * V34 * H2 - U12 * U24 * V34 * H4 * Y3 + 2 * U12 * U34 * V14 * V23 * V24 * H2 * Y1 * Y3 - 2 * U12 * U34 * V14 * V23 * V24 * H2 * Y1 * Y4 - 2 * U12 * U34 * V14 * V23 * V24 * H2 * Y3 * Y4 + 2 * U12 * U34 * V14 * V23 * V24 * H2 * Y4^2 + 2 * U12 * U34 * V14 * V23 * V24 * H4 * Y1 * Y2 * Y3 - 2 * U12 * U34 * V14 * V23 * V24 * H4 * Y1 * Y2 * Y4 - 2 * U12 * U34 * V14 * V23 * V24 * H4 * Y2 * Y3 * Y4 + 2 * U12 * U34 * V14 * V23 * V24 * H4 * Y2 * Y4^2 - 2 * U12 * U34 * V23 * V24 * H2 * Y3 + 2 * U12 * U34 * V23 * V24 * H2 * Y4 - 2 * U12 * U34 * V23 * V24 * H4 * Y2 * Y3 + 2 * U12 * U34 * V23 * V24 * H4 * Y2 * Y4 - U14 * U23 * U24 * V12 * Y1 * Y2 + U14 * U23 * U24 * V12 * Y1 * Y3 + U14 * U23 * U24 * V12 * Y2 * Y4 - U14 * U23 * U24 * V12 * Y3 * Y4 + U14 * U23 * U24 * Y2 - U14 * U23 * U24 * Y3 - U14 * U23 * U34 * V12 * V24 * Y1 * Y2^2 + U14 * U23 * U34 * V12 * V24 * Y1 * Y2 * Y3 + U14 * U23 * U34 * V12 * V24 * Y1 * Y2 * Y4 - U14 * U23 * U34 * V12 * V24 * Y1 * Y3 * Y4 + U14 * U23 * U34 * V12 * V24 * Y2^2 * Y4 - U14 * U23 * U34 * V12 * V24 * Y2 * Y3 * Y4 - U14 * U23 * U34 * V12 * V24 * Y2 * Y4^2 + U14 * U23 * U34 * V12 * V24 * Y3 * Y4^2 + U14 * U23 * U34 * V12 * Y2^2 - U14 * U23 * U34 * V12 * Y2 * Y3 - U14 * U23 * U34 * V12 * Y2 * Y4 + U14 * U23 * U34 * V12 * Y3 * Y4 + U14 * U23 * U34 * V24 * Y2^2 - U14 * U23 * U34 * V24 * Y2 * Y3 - U14 * U23 * U34 * V24 * Y2 * Y4 + U14 * U23 * U34 * V24 * Y3 * Y4 - U14 * U23 * V12 * V24 * V34 * H2 * Y1 * Y2 + U14 * U23 * V12 * V24 * V34 * H2 * Y1 * Y3 + U14 * U23 * V12 * V24 * V34 * H2 * Y2 * Y4 - U14 * U23 * V12 * V24 * V34 * H2 * Y3 * Y4 - U14 * U23 * V12 * V24 * V34 * H4 * Y1 * Y2 * Y4 + U14 * U23 * V12 * V24 * V34 * H4 * Y1 * Y3 * Y4 + U14 * U23 * V12 * V24 * V34 * H4 * Y2 * Y4^2 - U14 * U23 * V12 * V24 * V34 * H4 * Y3 * Y4^2 + U14 * U23 * V12 * V34 * H2 * Y2 - U14 * U23 * V12 * V34 * H2 * Y3 + U14 * U23 * V12 * V34 * H4 * Y2 * Y4 - U14 * U23 * V12 * V34 * H4 * Y3 * Y4 + U14 * U23 * V24 * V34 * H2 * Y2 - U14 * U23 * V24 * V34 * H2 * Y3 + U14 * U23 * V24 * V34 * H4 * Y2 * Y4 - U14 * U23 * V24 * V34 * H4 * Y3 * Y4 + U14 * U24 * U34 * V12 * V23 * Y1 * Y2^2 - 2 * U14 * U24 * U34 * V12 * V23 * Y1 * Y2 * Y4 - U14 * U24 * U34 * V12 * V23 * Y1 * Y3^2 + 2 * U14 * U24 * U34 * V12 * V23 * Y1 * Y3 * Y4 - U14 * U24 * U34 * V12 * V23 * Y2^2 * Y4 + 2 * U14 * U24 * U34 * V12 * V23 * Y2 * Y4^2 + U14 * U24 * U34 * V12 * V23 * Y3^2 * Y4 - 2 * U14 * U24 * U34 * V12 * V23 * Y3 * Y4^2 - U14 * U24 * U34 * V12 * Y1 * Y2 + U14 * U24 * U34 * V12 * Y1 * Y3 + U14 * U24 * U34 * V12 * Y2 * Y4 - U14 * U24 * U34 * V12 * Y3 * Y4 - U14 * U24 * U34 * V23 * Y2^2 + 2 * U14 * U24 * U34 * V23 * Y2 * Y4 + U14 * U24 * U34 * V23 * Y3^2 - 2 * U14 * U24 * U34 * V23 * Y3 * Y4 + U14 * U24 * U34 * Y2 - U14 * U24 * U34 * Y3 + U14 * U24 * V12 * V23 * V34 * H2 * Y1 * Y2 + U14 * U24 * V12 * V23 * V34 * H2 * Y1 * Y3 - 2 * U14 * U24 * V12 * V23 * V34 * H2 * Y1 * Y4 - U14 * U24 * V12 * V23 * V34 * H2 * Y2 * Y4 - U14 * U24 * V12 * V23 * V34 * H2 * Y3 * Y4 + 2 * U14 * U24 * V12 * V23 * V34 * H2 * Y4^2 + U14 * U24 * V12 * V23 * V34 * H4 * Y1 * Y2 * Y3 + U14 * U24 * V12 * V23 * V34 * H4 * Y1 * Y3^2 - 2 * U14 * U24 * V12 * V23 * V34 * H4 * Y1 * Y3 * Y4 - U14 * U24 * V12 * V23 * V34 * H4 * Y2 * Y3 * Y4 - U14 * U24 * V12 * V23 * V34 * H4 * Y3^2 * Y4 + 2 * U14 * U24 * V12 * V23 * V34 * H4 * Y3 * Y4^2 - 2 * U14 * U24 * V12 * V23 * H2 * Y1 + 2 * U14 * U24 * V12 * V23 * H2 * Y4 - 2 * U14 * U24 * V12 * V23 * H4 * Y1 * Y3 + 2 * U14 * U24 * V12 * V23 * H4 * Y3 * Y4 - U14 * U24 * V12 * V34 * H2 * Y1 + U14 * U24 * V12 * V34 * H2 * Y4 - U14 * U24 * V12 * V34 * H4 * Y1 * Y3 + U14 * U24 * V12 * V34 * H4 * Y3 * Y4 - U14 * U24 * V23 * V34 * H2 * Y2 - U14 * U24 * V23 * V34 * H2 * Y3 + 2 * U14 * U24 * V23 * V34 * H2 * Y4 - U14 * U24 * V23 * V34 * H4 * Y2 * Y3 - U14 * U24 * V23 * V34 * H4 * Y3^2 + 2 * U14 * U24 * V23 * V34 * H4 * Y3 * Y4 + 2 * U14 * U24 * V23 * H2 + 2 * U14 * U24 * V23 * H4 * Y3 + U14 * U24 * V34 * H2 + U14 * U24 * V34 * H4 * Y3 - 2 * U14 * U34 * V12 * V23 * V24 * H2 * Y1 * Y3 + 2 * U14 * U34 * V12 * V23 * V24 * H2 * Y1 * Y4 + 2 * U14 * U34 * V12 * V23 * V24 * H2 * Y3 * Y4 - 2 * U14 * U34 * V12 * V23 * V24 * H2 * Y4^2 - 2 * U14 * U34 * V12 * V23 * V24 * H4 * Y1 * Y2 * Y3 + 2 * U14 * U34 * V12 * V23 * V24 * H4 * Y1 * Y2 * Y4 + 2 * U14 * U34 * V12 * V23 * V24 * H4 * Y2 * Y3 * Y4 - 2 * U14 * U34 * V12 * V23 * V24 * H4 * Y2 * Y4^2 + 2 * U14 * U34 * V12 * V23 * H2 * Y3 - 2 * U14 * U34 * V12 * V23 * H2 * Y4 + 2 * U14 * U34 * V12 * V23 * H4 * Y2 * Y3 - 2 * U14 * U34 * V12 * V23 * H4 * Y2 * Y4 + 2 * U14 * U34 * V23 * V24 * H2 * Y3 - 2 * U14 * U34 * V23 * V24 * H2 * Y4 + 2 * U14 * U34 * V23 * V24 * H4 * Y2 * Y3 - 2 * U14 * U34 * V23 * V24 * H4 * Y2 * Y4, U12 * U13 * E4 * Y1 - U12 * U13 * E4 * Y4 + U12 * U13 * X3 - U12 * U13 * X4 + U12 * U23 * V13 * E4 * Y1^2 - 2 * U12 * U23 * V13 * E4 * Y1 * Y4 - U12 * U23 * V13 * E4 * Y2 * Y3 + U12 * U23 * V13 * E4 * Y2 * Y4 + U12 * U23 * V13 * E4 * Y3 * Y4 + 2 * U12 * U23 * V13 * X3 * Y1 - U12 * U23 * V13 * X3 * Y2 - U12 * U23 * V13 * X3 * Y3 - 2 * U12 * U23 * V13 * X4 * Y1 + U12 * U23 * V13 * X4 * Y2 + U12 * U23 * V13 * X4 * Y3 - U12 * U23 * E4 * Y1 + U12 * U23 * E4 * Y4 - U12 * U23 * X3 + U12 * U23 * X4 - U12 * V13 * V23 * H4 * X2 * Y1 + U12 * V13 * V23 * H4 * X2 * Y3 + U12 * V13 * V23 * H4 * X4 * Y1 - U12 * V13 * V23 * H4 * X4 * Y3 - U12 * V13 * V23 * Y1^2 - U12 * V13 * V23 * Y1 * Y2 + 2 * U12 * V13 * V23 * Y1 * Y3 + U12 * V13 * V23 * Y1 * Y4 + U12 * V13 * V23 * Y2 * Y3 - U12 * V13 * V23 * Y3^2 - U12 * V13 * V23 * Y3 * Y4 + U12 * V23 * H4 * X2 - U12 * V23 * H4 * X4 + U12 * V23 * Y1 + U12 * V23 * Y2 - U12 * V23 * Y3 - U12 * V23 * Y4 - U13 * U23 * V12 * E4 * Y1^2 + 2 * U13 * U23 * V12 * E4 * Y1 * Y4 + U13 * U23 * V12 * E4 * Y2 * Y3 - U13 * U23 * V12 * E4 * Y2 * Y4 - U13 * U23 * V12 * E4 * Y3 * Y4 - 2 * U13 * U23 * V12 * X3 * Y1 + U13 * U23 * V12 * X3 * Y2 + U13 * U23 * V12 * X3 * Y3 + 2 * U13 * U23 * V12 * X4 * Y1 - U13 * U23 * V12 * X4 * Y2 - U13 * U23 * V12 * X4 * Y3 + U13 * U23 * E4 * Y1 - U13 * U23 * E4 * Y4 + U13 * U23 * X3 - U13 * U23 * X4 + U13 * V12 * V23 * H4 * X3 * Y1 - U13 * V12 * V23 * H4 * X3 * Y2 - U13 * V12 * V23 * H4 * X4 * Y1 + U13 * V12 * V23 * H4 * X4 * Y2 + U13 * V12 * V23 * Y1^2 - U13 * V12 * V23 * Y1 * Y3 - U13 * V12 * V23 * Y1 * Y4 - U13 * V12 * V23 * Y2 * Y3 + U13 * V12 * V23 * Y2 * Y4 + U13 * V12 * V23 * Y3^2 - U13 * V12 * Y1 + U13 * V12 * Y3 - U13 * V23 * H4 * X3 + U13 * V23 * H4 * X4 - U13 * V23 * Y1 + U13 * V23 * Y4 + U23 * V12 * V13 * H4 * X3 * Y2 - U23 * V12 * V13 * H4 * X3 * Y3 - U23 * V12 * V13 * H4 * X4 * Y2 + U23 * V12 * V13 * H4 * X4 * Y3 + U23 * V12 * V13 * Y1 * Y2 - U23 * V12 * V13 * Y1 * Y3 - U23 * V12 * V13 * Y2 * Y4 + U23 * V12 * V13 * Y3 * Y4 - U23 * V12 * H4 * X3 + U23 * V12 * H4 * X4 - U23 * V12 * Y2 + U23 * V12 * Y4 + U23 * V13 * H4 * X3 - U23 * V13 * H4 * X4 + U23 * V13 * Y3 - U23 * V13 * Y4 - V12 * V13 * V23 * H4 * Y1 * Y2 + V12 * V13 * V23 * H4 * Y1 * Y3 + V12 * V13 * V23 * H4 * Y2 * Y3 - V12 * V13 * V23 * H4 * Y3^2 + V12 * V13 * H4 * Y1 - V12 * V13 * H4 * Y3 + V12 * V23 * H4 * Y2 - V12 * V23 * H4 * Y3 - V12 * H4, U12 * U13 * U34 * V23 * Y3^2 - 2 * U12 * U13 * U34 * V23 * Y3 * Y4 + U12 * U13 * U34 * V23 * Y4^2 + U12 * U13 * U34 * Y3 - U12 * U13 * U34 * Y4 + U12 * U13 * V23 * V34 * H2 * Y3 - U12 * U13 * V23 * V34 * H2 * Y4 + U12 * U13 * V23 * V34 * H4 * Y3 * Y4 - U12 * U13 * V23 * V34 * H4 * Y4^2 - U12 * U13 * V23 * H2 - U12 * U13 * V23 * H4 * Y4 + U12 * U23 * U34 * V13 * V23 * Y1 * Y2 * Y3 - U12 * U23 * U34 * V13 * V23 * Y1 * Y2 * Y4 - U12 * U23 * U34 * V13 * V23 * Y1 * Y3 * Y4 + U12 * U23 * U34 * V13 * V23 * Y1 * Y4^2 - U12 * U23 * U34 * V13 * V23 * Y2 * Y3^2 + U12 * U23 * U34 * V13 * V23 * Y2 * Y3 * Y4 + U12 * U23 * U34 * V13 * V23 * Y3^2 * Y4 - U12 * U23 * U34 * V13 * V23 * Y3 * Y4^2 + U12 * U23 * U34 * V13 * Y1 * Y3 - U12 * U23 * U34 * V13 * Y1 * Y4 - U12 * U23 * U34 * V13 * Y3^2 + U12 * U23 * U34 * V13 * Y3 * Y4 - U12 * U23 * U34 * V23 * Y2 * Y3 + U12 * U23 * U34 * V23 * Y2 * Y4 + U12 * U23 * U34 * V23 * Y3 * Y4 - U12 * U23 * U34 * V23 * Y4^2 - U12 * U23 * U34 * Y3 + U12 * U23 * U34 * Y4 + U12 * U23 * V13 * V23 * V34 * H2 * Y1 * Y3 - U12 * U23 * V13 * V23 * V34 * H2 * Y1 * Y4 - U12 * U23 * V13 * V23 * V34 * H2 * Y3^2 + U12 * U23 * V13 * V23 * V34 * H2 * Y3 * Y4 + U12 * U23 * V13 * V23 * V34 * H4 * Y1 * Y3 * Y4 - U12 * U23 * V13 * V23 * V34 * H4 * Y1 * Y4^2 - U12 * U23 * V13 * V23 * V34 * H4 * Y3^2 * Y4 + U12 * U23 * V13 * V23 * V34 * H4 * Y3 * Y4^2 - U12 * U23 * V13 * V23 * H2 * Y1 + U12 * U23 * V13 * V23 * H2 * Y3 - U12 * U23 * V13 * V23 * H4 * Y1 * Y4 + U12 * U23 * V13 * V23 * H4 * Y3 * Y4 - U12 * U23 * V23 * V34 * H2 * Y3 + U12 * U23 * V23 * V34 * H2 * Y4 - U12 * U23 * V23 * V34 * H4 * Y3 * Y4 + U12 * U23 * V23 * V34 * H4 * Y4^2 + U12 * U23 * V23 * H2 + U12 * U23 * V23 * H4 * Y4 - U12 * U34 * V13 * V23^2 * H2 * Y1 * Y3 + U12 * U34 * V13 * V23^2 * H2 * Y1 * Y4 + U12 * U34 * V13 * V23^2 * H2 * Y3^2 - U12 * U34 * V13 * V23^2 * H2 * Y3 * Y4 - U12 * U34 * V13 * V23^2 * H4 * Y1 * Y2 * Y3 + U12 * U34 * V13 * V23^2 * H4 * Y1 * Y2 * Y4 + U12 * U34 * V13 * V23^2 * H4 * Y2 * Y3^2 - U12 * U34 * V13 * V23^2 * H4 * Y2 * Y3 * Y4 + U12 * U34 * V23^2 * H2 * Y3 - U12 * U34 * V23^2 * H2 * Y4 + U12 * U34 * V23^2 * H4 * Y2 * Y3 - U12 * U34 * V23^2 * H4 * Y2 * Y4 - U13 * U23 * U34 * V12 * V23 * Y1 * Y2 * Y3 + U13 * U23 * U34 * V12 * V23 * Y1 * Y2 * Y4 + U13 * U23 * U34 * V12 * V23 * Y1 * Y3 * Y4 - U13 * U23 * U34 * V12 * V23 * Y1 * Y4^2 + U13 * U23 * U34 * V12 * V23 * Y2 * Y3^2 - U13 * U23 * U34 * V12 * V23 * Y2 * Y3 * Y4 - U13 * U23 * U34 * V12 * V23 * Y3^2 * Y4 + U13 * U23 * U34 * V12 * V23 * Y3 * Y4^2 - U13 * U23 * U34 * V12 * Y1 * Y3 + U13 * U23 * U34 * V12 * Y1 * Y4 + U13 * U23 * U34 * V12 * Y2 * Y3 - U13 * U23 * U34 * V12 * Y2 * Y4 + U13 * U23 * U34 * V23 * Y2 * Y3 - U13 * U23 * U34 * V23 * Y2 * Y4 - U13 * U23 * U34 * V23 * Y3 * Y4 + U13 * U23 * U34 * V23 * Y4^2 + U13 * U23 * U34 * Y3 - U13 * U23 * U34 * Y4 - U13 * U23 * V12 * V23 * V34 * H2 * Y1 * Y3 + U13 * U23 * V12 * V23 * V34 * H2 * Y1 * Y4 + U13 * U23 * V12 * V23 * V34 * H2 * Y3^2 - U13 * U23 * V12 * V23 * V34 * H2 * Y3 * Y4 - U13 * U23 * V12 * V23 * V34 * H4 * Y1 * Y3 * Y4 + U13 * U23 * V12 * V23 * V34 * H4 * Y1 * Y4^2 + U13 * U23 * V12 * V23 * V34 * H4 * Y3^2 * Y4 - U13 * U23 * V12 * V23 * V34 * H4 * Y3 * Y4^2 + U13 * U23 * V12 * V23 * H2 * Y1 - U13 * U23 * V12 * V23 * H2 * Y3 + U13 * U23 * V12 * V23 * H4 * Y1 * Y4 - U13 * U23 * V12 * V23 * H4 * Y3 * Y4 + U13 * U23 * V23 * V34 * H2 * Y3 - U13 * U23 * V23 * V34 * H2 * Y4 + U13 * U23 * V23 * V34 * H4 * Y3 * Y4 - U13 * U23 * V23 * V34 * H4 * Y4^2 - U13 * U23 * V23 * H2 - U13 * U23 * V23 * H4 * Y4 + U13 * U34 * V12 * V23^2 * H2 * Y1 * Y3 - U13 * U34 * V12 * V23^2 * H2 * Y1 * Y4 - U13 * U34 * V12 * V23^2 * H2 * Y3^2 + U13 * U34 * V12 * V23^2 * H2 * Y3 * Y4 + U13 * U34 * V12 * V23^2 * H4 * Y1 * Y2 * Y3 - U13 * U34 * V12 * V23^2 * H4 * Y1 * Y2 * Y4 - U13 * U34 * V12 * V23^2 * H4 * Y2 * Y3^2 + U13 * U34 * V12 * V23^2 * H4 * Y2 * Y3 * Y4 - U13 * U34 * V12 * V23 * H2 * Y3 + U13 * U34 * V12 * V23 * H2 * Y4 - U13 * U34 * V12 * V23 * H4 * Y2 * Y3 + U13 * U34 * V12 * V23 * H4 * Y2 * Y4 - U13 * U34 * V23^2 * H2 * Y3 + U13 * U34 * V23^2 * H2 * Y4 - U13 * U34 * V23^2 * H4 * Y2 * Y3 + U13 * U34 * V23^2 * H4 * Y2 * Y4, U12 * U13 * U24 * Y2 - U12 * U13 * U24 * Y4 + U12 * U13 * U34 * V24 * Y2^2 - 2 * U12 * U13 * U34 * V24 * Y2 * Y4 + U12 * U13 * U34 * V24 * Y4^2 - U12 * U13 * U34 * Y2 + U12 * U13 * U34 * Y4 + U12 * U13 * V24 * V34 * H2 * Y2 - U12 * U13 * V24 * V34 * H2 * Y4 + U12 * U13 * V24 * V34 * H4 * Y2 * Y4 - U12 * U13 * V24 * V34 * H4 * Y4^2 - U12 * U13 * V34 * H2 - U12 * U13 * V34 * H4 * Y4 + U12 * U23 * U24 * V13 * Y1 * Y2 - U12 * U23 * U24 * V13 * Y1 * Y4 - U12 * U23 * U24 * V13 * Y2 * Y3 + U12 * U23 * U24 * V13 * Y3 * Y4 - U12 * U23 * U24 * Y2 + U12 * U23 * U24 * Y4 + U12 * U23 * U34 * V13 * V24 * Y1 * Y2^2 - 2 * U12 * U23 * U34 * V13 * V24 * Y1 * Y2 * Y4 + U12 * U23 * U34 * V13 * V24 * Y1 * Y4^2 - U12 * U23 * U34 * V13 * V24 * Y2^2 * Y4 - U12 * U23 * U34 * V13 * V24 * Y2 * Y3^2 + 2 * U12 * U23 * U34 * V13 * V24 * Y2 * Y3 * Y4 + U12 * U23 * U34 * V13 * V24 * Y2 * Y4^2 + U12 * U23 * U34 * V13 * V24 * Y3^2 * Y4 - 2 * U12 * U23 * U34 * V13 * V24 * Y3 * Y4^2 - U12 * U23 * U34 * V13 * Y1 * Y2 + U12 * U23 * U34 * V13 * Y1 * Y4 + U12 * U23 * U34 * V13 * Y2 * Y3 - U12 * U23 * U34 * V13 * Y3 * Y4 - U12 * U23 * U34 * V24 * Y2^2 + 2 * U12 * U23 * U34 * V24 * Y2 * Y4 - U12 * U23 * U34 * V24 * Y4^2 + U12 * U23 * U34 * Y2 - U12 * U23 * U34 * Y4 + U12 * U23 * V13 * V24 * V34 * H2 * Y1 * Y2 - U12 * U23 * V13 * V24 * V34 * H2 * Y1 * Y4 - U12 * U23 * V13 * V24 * V34 * H2 * Y2 * Y4 - U12 * U23 * V13 * V24 * V34 * H2 * Y3^2 + 2 * U12 * U23 * V13 * V24 * V34 * H2 * Y3 * Y4 + U12 * U23 * V13 * V24 * V34 * H4 * Y1 * Y2 * Y4 - U12 * U23 * V13 * V24 * V34 * H4 * Y1 * Y4^2 - U12 * U23 * V13 * V24 * V34 * H4 * Y2 * Y4^2 - U12 * U23 * V13 * V24 * V34 * H4 * Y3^2 * Y4 + 2 * U12 * U23 * V13 * V24 * V34 * H4 * Y3 * Y4^2 - U12 * U23 * V13 * V24 * H2 * Y2 + U12 * U23 * V13 * V24 * H2 * Y3 - U12 * U23 * V13 * V24 * H4 * Y2 * Y4 + U12 * U23 * V13 * V24 * H4 * Y3 * Y4 - U12 * U23 * V13 * V34 * H2 * Y1 + U12 * U23 * V13 * V34 * H2 * Y3 - U12 * U23 * V13 * V34 * H4 * Y1 * Y4 + U12 * U23 * V13 * V34 * H4 * Y3 * Y4 - U12 * U23 * V24 * V34 * H2 * Y2 + U12 * U23 * V24 * V34 * H2 * Y4 - U12 * U23 * V24 * V34 * H4 * Y2 * Y4 + U12 * U23 * V24 * V34 * H4 * Y4^2 + U12 * U23 * V34 * H2 + U12 * U23 * V34 * H4 * Y4 - U12 * U24 * U34 * V13 * V23 * Y1 * Y2^2 + U12 * U24 * U34 * V13 * V23 * Y1 * Y2 * Y3 + U12 * U24 * U34 * V13 * V23 * Y1 * Y2 * Y4 - U12 * U24 * U34 * V13 * V23 * Y1 * Y3 * Y4 + U12 * U24 * U34 * V13 * V23 * Y2^2 * Y4 - U12 * U24 * U34 * V13 * V23 * Y2 * Y3 * Y4 - U12 * U24 * U34 * V13 * V23 * Y2 * Y4^2 + U12 * U24 * U34 * V13 * V23 * Y3 * Y4^2 + U12 * U24 * U34 * V23 * Y2^2 - U12 * U24 * U34 * V23 * Y2 * Y3 - U12 * U24 * U34 * V23 * Y2 * Y4 + U12 * U24 * U34 * V23 * Y3 * Y4 - U12 * U24 * V13 * V23 * V34 * H2 * Y1 * Y2 + U12 * U24 * V13 * V23 * V34 * H2 * Y1 * Y4 + U12 * U24 * V13 * V23 * V34 * H2 * Y2 * Y4 - U12 * U24 * V13 * V23 * V34 * H2 * Y4^2 - U12 * U24 * V13 * V23 * V34 * H4 * Y1 * Y2 * Y3 + U12 * U24 * V13 * V23 * V34 * H4 * Y1 * Y3 * Y4 + U12 * U24 * V13 * V23 * V34 * H4 * Y2 * Y3 * Y4 - U12 * U24 * V13 * V23 * V34 * H4 * Y3 * Y4^2 + U12 * U24 * V13 * V23 * H2 * Y2 - U12 * U24 * V13 * V23 * H2 * Y4 + U12 * U24 * V13 * V23 * H4 * Y2 * Y3 - U12 * U24 * V13 * V23 * H4 * Y3 * Y4 + U12 * U24 * V23 * V34 * H2 * Y2 - U12 * U24 * V23 * V34 * H2 * Y4 + U12 * U24 * V23 * V34 * H4 * Y2 * Y3 - U12 * U24 * V23 * V34 * H4 * Y3 * Y4 + U12 * U34 * V13 * V23 * V24 * H2 * Y3^2 - 2 * U12 * U34 * V13 * V23 * V24 * H2 * Y3 * Y4 + U12 * U34 * V13 * V23 * V24 * H2 * Y4^2 + U12 * U34 * V13 * V23 * V24 * H4 * Y2 * Y3^2 - 2 * U12 * U34 * V13 * V23 * V24 * H4 * Y2 * Y3 * Y4 + U12 * U34 * V13 * V23 * V24 * H4 * Y2 * Y4^2 - U12 * U34 * V13 * V23 * H2 * Y3 + U12 * U34 * V13 * V23 * H2 * Y4 - U12 * U34 * V13 * V23 * H4 * Y2 * Y3 + U12 * U34 * V13 * V23 * H4 * Y2 * Y4 + U12 * U34 * V13 * V24 * H2 * Y3 - U12 * U34 * V13 * V24 * H2 * Y4 + U12 * U34 * V13 * V24 * H4 * Y2 * Y3 - U12 * U34 * V13 * V24 * H4 * Y2 * Y4 - U13 * U23 * U24 * V12 * Y1 * Y2 + U13 * U23 * U24 * V12 * Y1 * Y4 + U13 * U23 * U24 * V12 * Y2 * Y3 - U13 * U23 * U24 * V12 * Y3 * Y4 + U13 * U23 * U24 * Y2 - U13 * U23 * U24 * Y4 - U13 * U23 * U34 * V12 * V24 * Y1 * Y2^2 + 2 * U13 * U23 * U34 * V12 * V24 * Y1 * Y2 * Y4 - U13 * U23 * U34 * V12 * V24 * Y1 * Y4^2 + U13 * U23 * U34 * V12 * V24 * Y2^2 * Y4 + U13 * U23 * U34 * V12 * V24 * Y2 * Y3^2 - 2 * U13 * U23 * U34 * V12 * V24 * Y2 * Y3 * Y4 - U13 * U23 * U34 * V12 * V24 * Y2 * Y4^2 - U13 * U23 * U34 * V12 * V24 * Y3^2 * Y4 + 2 * U13 * U23 * U34 * V12 * V24 * Y3 * Y4^2 + U13 * U23 * U34 * V12 * Y1 * Y2 - U13 * U23 * U34 * V12 * Y1 * Y4 - U13 * U23 * U34 * V12 * Y2 * Y3 + U13 * U23 * U34 * V12 * Y3 * Y4 + U13 * U23 * U34 * V24 * Y2^2 - 2 * U13 * U23 * U34 * V24 * Y2 * Y4 + U13 * U23 * U34 * V24 * Y4^2 - U13 * U23 * U34 * Y2 + U13 * U23 * U34 * Y4 - U13 * U23 * V12 * V24 * V34 * H2 * Y1 * Y2 + U13 * U23 * V12 * V24 * V34 * H2 * Y1 * Y4 + U13 * U23 * V12 * V24 * V34 * H2 * Y2 * Y4 + U13 * U23 * V12 * V24 * V34 * H2 * Y3^2 - 2 * U13 * U23 * V12 * V24 * V34 * H2 * Y3 * Y4 - U13 * U23 * V12 * V24 * V34 * H4 * Y1 * Y2 * Y4 + U13 * U23 * V12 * V24 * V34 * H4 * Y1 * Y4^2 + U13 * U23 * V12 * V24 * V34 * H4 * Y2 * Y4^2 + U13 * U23 * V12 * V24 * V34 * H4 * Y3^2 * Y4 - 2 * U13 * U23 * V12 * V24 * V34 * H4 * Y3 * Y4^2 + U13 * U23 * V12 * V24 * H2 * Y2 - U13 * U23 * V12 * V24 * H2 * Y3 + U13 * U23 * V12 * V24 * H4 * Y2 * Y4 - U13 * U23 * V12 * V24 * H4 * Y3 * Y4 + U13 * U23 * V12 * V34 * H2 * Y1 - U13 * U23 * V12 * V34 * H2 * Y3 + U13 * U23 * V12 * V34 * H4 * Y1 * Y4 - U13 * U23 * V12 * V34 * H4 * Y3 * Y4 + U13 * U23 * V24 * V34 * H2 * Y2 - U13 * U23 * V24 * V34 * H2 * Y4 + U13 * U23 * V24 * V34 * H4 * Y2 * Y4 - U13 * U23 * V24 * V34 * H4 * Y4^2 - U13 * U23 * V34 * H2 - U13 * U23 * V34 * H4 * Y4 + U13 * U24 * U34 * V12 * V23 * Y1 * Y2^2 - U13 * U24 * U34 * V12 * V23 * Y1 * Y2 * Y3 - U13 * U24 * U34 * V12 * V23 * Y1 * Y2 * Y4 + U13 * U24 * U34 * V12 * V23 * Y1 * Y3 * Y4 - U13 * U24 * U34 * V12 * V23 * Y2^2 * Y4 + U13 * U24 * U34 * V12 * V23 * Y2 * Y3 * Y4 + U13 * U24 * U34 * V12 * V23 * Y2 * Y4^2 - U13 * U24 * U34 * V12 * V23 * Y3 * Y4^2 - U13 * U24 * U34 * V12 * Y2^2 + U13 * U24 * U34 * V12 * Y2 * Y3 + U13 * U24 * U34 * V12 * Y2 * Y4 - U13 * U24 * U34 * V12 * Y3 * Y4 - U13 * U24 * U34 * V23 * Y2^2 + U13 * U24 * U34 * V23 * Y2 * Y3 + U13 * U24 * U34 * V23 * Y2 * Y4 - U13 * U24 * U34 * V23 * Y3 * Y4 + U13 * U24 * V12 * V23 * V34 * H2 * Y1 * Y2 - U13 * U24 * V12 * V23 * V34 * H2 * Y1 * Y4 - U13 * U24 * V12 * V23 * V34 * H2 * Y2 * Y4 + U13 * U24 * V12 * V23 * V34 * H2 * Y4^2 + U13 * U24 * V12 * V23 * V34 * H4 * Y1 * Y2 * Y3 - U13 * U24 * V12 * V23 * V34 * H4 * Y1 * Y3 * Y4 - U13 * U24 * V12 * V23 * V34 * H4 * Y2 * Y3 * Y4 + U13 * U24 * V12 * V23 * V34 * H4 * Y3 * Y4^2 - U13 * U24 * V12 * V23 * H2 * Y2 + U13 * U24 * V12 * V23 * H2 * Y4 - U13 * U24 * V12 * V23 * H4 * Y2 * Y3 + U13 * U24 * V12 * V23 * H4 * Y3 * Y4 - U13 * U24 * V12 * V34 * H2 * Y2 + U13 * U24 * V12 * V34 * H2 * Y4 - U13 * U24 * V12 * V34 * H4 * Y2 * Y3 + U13 * U24 * V12 * V34 * H4 * Y3 * Y4 - U13 * U24 * V23 * V34 * H2 * Y2 + U13 * U24 * V23 * V34 * H2 * Y4 - U13 * U24 * V23 * V34 * H4 * Y2 * Y3 + U13 * U24 * V23 * V34 * H4 * Y3 * Y4 - U13 * U34 * V12 * V23 * V24 * H2 * Y3^2 + 2 * U13 * U34 * V12 * V23 * V24 * H2 * Y3 * Y4 - U13 * U34 * V12 * V23 * V24 * H2 * Y4^2 - U13 * U34 * V12 * V23 * V24 * H4 * Y2 * Y3^2 + 2 * U13 * U34 * V12 * V23 * V24 * H4 * Y2 * Y3 * Y4 - U13 * U34 * V12 * V23 * V24 * H4 * Y2 * Y4^2 + U13 * U34 * V12 * V23 * H2 * Y3 - U13 * U34 * V12 * V23 * H2 * Y4 + U13 * U34 * V12 * V23 * H4 * Y2 * Y3 - U13 * U34 * V12 * V23 * H4 * Y2 * Y4 - U13 * U34 * V12 * V24 * H2 * Y3 + U13 * U34 * V12 * V24 * H2 * Y4 - U13 * U34 * V12 * V24 * H4 * Y2 * Y3 + U13 * U34 * V12 * V24 * H4 * Y2 * Y4, E4 * H3 * Y3^2 - 2 * E4 * H3 * Y3 * Y4 + E4 * H3 * Y4^2 - E4 * H4 * X3 * Y2 * Y3 + E4 * H4 * X3 * Y2 * Y4 + E4 * H4 * X3 * Y3^2 - E4 * H4 * X3 * Y3 * Y4 + E4 * H4 * X4 * Y2 * Y3 - E4 * H4 * X4 * Y2 * Y4 - E4 * H4 * X4 * Y3 * Y4 + E4 * H4 * X4 * Y4^2 + E4 * Y3^3 - E4 * Y3^2 * Y4 - E4 * Y3 * Y4^2 + E4 * Y4^3 + H3 * H4 * X3^2 - 2 * H3 * H4 * X3 * X4 + H3 * H4 * X4^2 + 2 * H3 * X3 * Y3 - 2 * H3 * X3 * Y4 - 2 * H3 * X4 * Y3 + 2 * H3 * X4 * Y4 + H4^2 * X1 * X3^2 - 2 * H4^2 * X1 * X3 * X4 + H4^2 * X1 * X4^2 + H4 * X1 * X3 * Y3 - H4 * X1 * X3 * Y4 - H4 * X1 * X4 * Y3 + H4 * X1 * X4 * Y4 + H4 * X3^2 * Y1 + H4 * X3^2 * Y3 - 2 * H4 * X3 * X4 * Y1 - H4 * X3 * X4 * Y3 - H4 * X3 * X4 * Y4 + H4 * X4^2 * Y1 + H4 * X4^2 * Y4 + X3 * Y1 * Y3 - X3 * Y1 * Y4 + X3 * Y2 * Y3 - X3 * Y2 * Y4 + X3 * Y3^2 - X3 * Y4^2 - X4 * Y1 * Y3 + X4 * Y1 * Y4 - X4 * Y2 * Y3 + X4 * Y2 * Y4 - X4 * Y3^2 + X4 * Y4^2, E4 * H3 * Y2 * Y3 - E4 * H3 * Y2 * Y4 - E4 * H3 * Y3 * Y4 + E4 * H3 * Y4^2 + E4 * H4 * X4 * Y2 * Y3 - E4 * H4 * X4 * Y2 * Y4 - E4 * H4 * X4 * Y3 * Y4 + E4 * H4 * X4 * Y4^2 + E4 * Y2 * Y3^2 - E4 * Y2 * Y4^2 - E4 * Y3^2 * Y4 + E4 * Y4^3 + H3 * H4 * X2 * X3 - H3 * H4 * X2 * X4 - H3 * H4 * X3 * X4 + H3 * H4 * X4^2 + 2 * H3 * X3 * Y2 - 2 * H3 * X3 * Y4 - 2 * H3 * X4 * Y2 + 2 * H3 * X4 * Y4 + H4^2 * X1 * X2 * X3 - H4^2 * X1 * X2 * X4 - H4^2 * X1 * X3 * X4 + H4^2 * X1 * X4^2 + H4 * X1 * X3 * Y2 - H4 * X1 * X3 * Y4 - H4 * X1 * X4 * Y2 + H4 * X1 * X4 * Y4 + H4 * X2 * X3 * Y1 + H4 * X2 * X3 * Y2 - H4 * X2 * X4 * Y1 - H4 * X2 * X4 * Y2 - H4 * X3 * X4 * Y1 - H4 * X3 * X4 * Y4 + H4 * X4^2 * Y1 + H4 * X4^2 * Y4 + X3 * Y1 * Y2 - X3 * Y1 * Y4 + X3 * Y2^2 + X3 * Y2 * Y3 - X3 * Y3 * Y4 - X3 * Y4^2 - X4 * Y1 * Y2 + X4 * Y1 * Y4 - X4 * Y2^2 - X4 * Y2 * Y3 + X4 * Y3 * Y4 + X4 * Y4^2, E4 * H3 * Y2^2 - 2 * E4 * H3 * Y2 * Y4 + E4 * H3 * Y4^2 + E4 * H4 * X2 * Y2^2 - E4 * H4 * X2 * Y2 * Y3 - E4 * H4 * X2 * Y2 * Y4 + E4 * H4 * X2 * Y3 * Y4 + E4 * H4 * X4 * Y2 * Y3 - E4 * H4 * X4 * Y2 * Y4 - E4 * H4 * X4 * Y3 * Y4 + E4 * H4 * X4 * Y4^2 + E4 * Y2^3 - E4 * Y2^2 * Y4 - E4 * Y2 * Y4^2 + E4 * Y4^3 + H3 * H4 * X2^2 - 2 * H3 * H4 * X2 * X4 + H3 * H4 * X4^2 + 2 * H3 * X2 * Y2 - 2 * H3 * X2 * Y4 - 2 * H3 * X4 * Y2 + 2 * H3 * X4 * Y4 + H4^2 * X1 * X2^2 - 2 * H4^2 * X1 * X2 * X4 + H4^2 * X1 * X4^2 + H4 * X1 * X2 * Y2 - H4 * X1 * X2 * Y4 - H4 * X1 * X4 * Y2 + H4 * X1 * X4 * Y4 + H4 * X2^2 * Y1 + H4 * X2^2 * Y2 - 2 * H4 * X2 * X4 * Y1 - H4 * X2 * X4 * Y2 - H4 * X2 * X4 * Y4 + H4 * X4^2 * Y1 + H4 * X4^2 * Y4 + X2 * Y1 * Y2 - X2 * Y1 * Y4 + X2 * Y2^2 + X2 * Y2 * Y3 - X2 * Y3 * Y4 - X2 * Y4^2 - X4 * Y1 * Y2 + X4 * Y1 * Y4 - X4 * Y2^2 - X4 * Y2 * Y3 + X4 * Y3 * Y4 + X4 * Y4^2, E4 * H3 * Y1^2 - 2 * E4 * H3 * Y1 * Y4 + E4 * H3 * Y4^2 + E4 * H4 * X1 * Y1^2 - 2 * E4 * H4 * X1 * Y1 * Y4 - E4 * H4 * X1 * Y2 * Y3 + E4 * H4 * X1 * Y2 * Y4 + E4 * H4 * X1 * Y3 * Y4 + E4 * H4 * X4 * Y2 * Y3 - E4 * H4 * X4 * Y2 * Y4 - E4 * H4 * X4 * Y3 * Y4 + E4 * H4 * X4 * Y4^2 + E4 * Y1^3 - E4 * Y1^2 * Y4 - E4 * Y1 * Y4^2 + E4 * Y4^3 + H3 * H4 * X1^2 - 2 * H3 * H4 * X1 * X4 + H3 * H4 * X4^2 + 2 * H3 * X1 * Y1 - 2 * H3 * X1 * Y4 - 2 * H3 * X4 * Y1 + 2 * H3 * X4 * Y4 + H4^2 * X1^2 * X2 + H4^2 * X1^2 * X3 - H4^2 * X1^2 * X4 - H4^2 * X1 * X2 * X3 - H4^2 * X1 * X2 * X4 - H4^2 * X1 * X3 * X4 + H4^2 * X1 * X4^2 + H4^2 * X2 * X3 * X4 + H4 * X1^2 * Y1 + H4 * X1^2 * Y2 + H4 * X1^2 * Y3 - H4 * X1^2 * Y4 + H4 * X1 * X2 * Y1 - H4 * X1 * X2 * Y3 + H4 * X1 * X3 * Y1 - H4 * X1 * X3 * Y2 - 2 * H4 * X1 * X4 * Y1 - H4 * X1 * X4 * Y2 - H4 * X1 * X4 * Y3 - H4 * X2 * X4 * Y1 + H4 * X2 * X4 * Y3 - H4 * X3 * X4 * Y1 + H4 * X3 * X4 * Y2 + H4 * X4^2 * Y1 + H4 * X4^2 * Y4 + X1 * Y1^2 + X1 * Y1 * Y2 + X1 * Y1 * Y3 - X1 * Y2 * Y4 - X1 * Y3 * Y4 - X1 * Y4^2 - X4 * Y1^2 - X4 * Y1 * Y2 - X4 * Y1 * Y3 + X4 * Y2 * Y4 + X4 * Y3 * Y4 + X4 * Y4^2, E3 * E4 * Y3^2 - 2 * E3 * E4 * Y3 * Y4 + E3 * E4 * Y4^2 + E3 * H4 * X3^2 - 2 * E3 * H4 * X3 * X4 + E3 * H4 * X4^2 + 2 * E3 * X3 * Y3 - 2 * E3 * X3 * Y4 - 2 * E3 * X4 * Y3 + 2 * E3 * X4 * Y4 - E4^2 * X3 * Y2 * Y3 + E4^2 * X3 * Y2 * Y4 + E4^2 * X3 * Y3^2 - E4^2 * X3 * Y3 * Y4 + E4^2 * X4 * Y2 * Y3 - E4^2 * X4 * Y2 * Y4 - E4^2 * X4 * Y3 * Y4 + E4^2 * X4 * Y4^2 + E4 * H4 * X1 * X3^2 - 2 * E4 * H4 * X1 * X3 * X4 + E4 * H4 * X1 * X4^2 - E4 * X2 * X3 * Y3 + E4 * X2 * X3 * Y4 + E4 * X2 * X4 * Y3 - E4 * X2 * X4 * Y4 - E4 * X3^2 * Y2 + 2 * E4 * X3^2 * Y3 - E4 * X3^2 * Y4 + 2 * E4 * X3 * X4 * Y2 - E4 * X3 * X4 * Y3 - E4 * X3 * X4 * Y4 - E4 * X4^2 * Y2 - E4 * X4^2 * Y3 + 2 * E4 * X4^2 * Y4 - X1 * X3^2 + 2 * X1 * X3 * X4 - X1 * X4^2 - X2 * X3^2 + 2 * X2 * X3 * X4 - X2 * X4^2 + X3^3 - X3^2 * X4 - X3 * X4^2 + X4^3, E3 * E4 * Y2 * Y3 - E3 * E4 * Y2 * Y4 - E3 * E4 * Y3 * Y4 + E3 * E4 * Y4^2 + E3 * H4 * X2 * X3 - E3 * H4 * X2 * X4 - E3 * H4 * X3 * X4 + E3 * H4 * X4^2 + 2 * E3 * X3 * Y2 - 2 * E3 * X3 * Y4 - 2 * E3 * X4 * Y2 + 2 * E3 * X4 * Y4 + E4^2 * X4 * Y2 * Y3 - E4^2 * X4 * Y2 * Y4 - E4^2 * X4 * Y3 * Y4 + E4^2 * X4 * Y4^2 + E4 * H4 * X1 * X2 * X3 - E4 * H4 * X1 * X2 * X4 - E4 * H4 * X1 * X3 * X4 + E4 * H4 * X1 * X4^2 + E4 * X2 * X3 * Y2 - E4 * X2 * X3 * Y3 - E4 * X2 * X4 * Y2 + E4 * X2 * X4 * Y3 + E4 * X3 * X4 * Y2 + E4 * X3 * X4 * Y3 - 2 * E4 * X3 * X4 * Y4 - E4 * X4^2 * Y2 - E4 * X4^2 * Y3 + 2 * E4 * X4^2 * Y4 - X1 * X2 * X3 + X1 * X2 * X4 + X1 * X3 * X4 - X1 * X4^2 + X2^2 * X3 - X2^2 * X4 - X2 * X3^2 + X2 * X3 * X4 + X3^2 * X4 - 2 * X3 * X4^2 + X4^3, E3 * E4 * Y2^2 - 2 * E3 * E4 * Y2 * Y4 + E3 * E4 * Y4^2 + E3 * H4 * X2^2 - 2 * E3 * H4 * X2 * X4 + E3 * H4 * X4^2 + 2 * E3 * X2 * Y2 - 2 * E3 * X2 * Y4 - 2 * E3 * X4 * Y2 + 2 * E3 * X4 * Y4 + E4^2 * X2 * Y2^2 - E4^2 * X2 * Y2 * Y3 - E4^2 * X2 * Y2 * Y4 + E4^2 * X2 * Y3 * Y4 + E4^2 * X4 * Y2 * Y3 - E4^2 * X4 * Y2 * Y4 - E4^2 * X4 * Y3 * Y4 + E4^2 * X4 * Y4^2 + E4 * H4 * X1 * X2^2 - 2 * E4 * H4 * X1 * X2 * X4 + E4 * H4 * X1 * X4^2 + 2 * E4 * X2^2 * Y2 - E4 * X2^2 * Y3 - E4 * X2^2 * Y4 - E4 * X2 * X3 * Y2 + E4 * X2 * X3 * Y4 - E4 * X2 * X4 * Y2 + 2 * E4 * X2 * X4 * Y3 - E4 * X2 * X4 * Y4 + E4 * X3 * X4 * Y2 - E4 * X3 * X4 * Y4 - E4 * X4^2 * Y2 - E4 * X4^2 * Y3 + 2 * E4 * X4^2 * Y4 - X1 * X2^2 + 2 * X1 * X2 * X4 - X1 * X4^2 + X2^3 - X2^2 * X3 - X2^2 * X4 + 2 * X2 * X3 * X4 - X2 * X4^2 - X3 * X4^2 + X4^3, E3 * E4 * Y1^2 - 2 * E3 * E4 * Y1 * Y4 + E3 * E4 * Y4^2 + E3 * H4 * X1^2 - 2 * E3 * H4 * X1 * X4 + E3 * H4 * X4^2 + 2 * E3 * X1 * Y1 - 2 * E3 * X1 * Y4 - 2 * E3 * X4 * Y1 + 2 * E3 * X4 * Y4 + E4^2 * X1 * Y1^2 - 2 * E4^2 * X1 * Y1 * Y4 - E4^2 * X1 * Y2 * Y3 + E4^2 * X1 * Y2 * Y4 + E4^2 * X1 * Y3 * Y4 + E4^2 * X4 * Y2 * Y3 - E4^2 * X4 * Y2 * Y4 - E4^2 * X4 * Y3 * Y4 + E4^2 * X4 * Y4^2 + E4 * H4 * X1^2 * X2 + E4 * H4 * X1^2 * X3 - E4 * H4 * X1^2 * X4 - E4 * H4 * X1 * X2 * X3 - E4 * H4 * X1 * X2 * X4 - E4 * H4 * X1 * X3 * X4 + E4 * H4 * X1 * X4^2 + E4 * H4 * X2 * X3 * X4 + 2 * E4 * X1^2 * Y1 - 2 * E4 * X1^2 * Y4 - E4 * X1 * X2 * Y3 + E4 * X1 * X2 * Y4 - E4 * X1 * X3 * Y2 + E4 * X1 * X3 * Y4 - 2 * E4 * X1 * X4 * Y1 + E4 * X1 * X4 * Y2 + E4 * X1 * X4 * Y3 + E4 * X2 * X4 * Y3 - E4 * X2 * X4 * Y4 + E4 * X3 * X4 * Y2 - E4 * X3 * X4 * Y4 - E4 * X4^2 * Y2 - E4 * X4^2 * Y3 + 2 * E4 * X4^2 * Y4 + X1^3 - X1^2 * X2 - X1^2 * X3 - X1^2 * X4 + 2 * X1 * X2 * X4 + 2 * X1 * X3 * X4 - X1 * X4^2 - X2 * X4^2 - X3 * X4^2 + X4^3, 2 * E2 - E3 * E4 * H4^2 - E3 * H4 + 2 * E4^2 * H2 + E4^2 * H3 * H4 + E4^2 * H4 * Y1 + E4^2 * H4 * Y2 + E4^2 * H4 * Y3 + E4^2 * H4 * Y4 - 3 * E4 * H3 - E4 * H4 * X1 - E4 * H4 * X2 - E4 * H4 * X3 - E4 * H4 * X4 - E4 * Y1 - E4 * Y2 - E4 * Y3 - E4 * Y4 + X1 + X2 + X3 + X4, 2 * U23 * U24 * E3 + 2 * U23 * U24 * E4 * X4 - 2 * U23 * U34 * E3 - 2 * U23 * U34 * E4 * X4 - U23 * V24 * E3 * E4 * H4^2 - U23 * V24 * E3 * H4 + 2 * U23 * V24 * E4^2 * H2 + U23 * V24 * E4^2 * H3 * H4 + U23 * V24 * E4^2 * H4 * Y1 + U23 * V24 * E4^2 * H4 * Y2 + U23 * V24 * E4^2 * H4 * Y3 + U23 * V24 * E4^2 * H4 * Y4 - 3 * U23 * V24 * E4 * H3 - U23 * V24 * E4 * H4 * X1 - 2 * U23 * V24 * E4 * H4 * X3 - U23 * V24 * E4 * H4 * X4 - U23 * V24 * E4 * Y1 - 3 * U23 * V24 * E4 * Y2 - U23 * V24 * E4 * Y3 - U23 * V24 * E4 * Y4 + U23 * V24 * X1 - U23 * V24 * X4 + U23 * V34 * E3 * E4 * H4^2 + U23 * V34 * E3 * H4 - 2 * U23 * V34 * E4^2 * H2 - U23 * V34 * E4^2 * H3 * H4 - U23 * V34 * E4^2 * H4 * Y1 - U23 * V34 * E4^2 * H4 * Y2 - U23 * V34 * E4^2 * H4 * Y3 - U23 * V34 * E4^2 * H4 * Y4 + 3 * U23 * V34 * E4 * H3 + U23 * V34 * E4 * H4 * X1 + 2 * U23 * V34 * E4 * H4 * X3 + U23 * V34 * E4 * H4 * X4 + U23 * V34 * E4 * Y1 + U23 * V34 * E4 * Y2 + 3 * U23 * V34 * E4 * Y3 + U23 * V34 * E4 * Y4 - U23 * V34 * X1 + U23 * V34 * X4 + 2 * U24 * U34 * E3 + 2 * U24 * U34 * E4 * X4 - U24 * V23 * E3 * E4 * H4^2 - U24 * V23 * E3 * H4 + 2 * U24 * V23 * E4^2 * H2 + U24 * V23 * E4^2 * H3 * H4 + U24 * V23 * E4^2 * H4 * Y1 + U24 * V23 * E4^2 * H4 * Y2 + U24 * V23 * E4^2 * H4 * Y3 + U24 * V23 * E4^2 * H4 * Y4 - 3 * U24 * V23 * E4 * H3 - U24 * V23 * E4 * H4 * X1 - U24 * V23 * E4 * H4 * X3 - 2 * U24 * V23 * E4 * H4 * X4 - U24 * V23 * E4 * Y1 - U24 * V23 * E4 * Y2 - 3 * U24 * V23 * E4 * Y3 - U24 * V23 * E4 * Y4 + U24 * V23 * X1 - U24 * V23 * X3 - U24 * V34 * E3 * E4 * H4^2 - U24 * V34 * E3 * H4 + 2 * U24 * V34 * E4^2 * H2 + U24 * V34 * E4^2 * H3 * H4 + U24 * V34 * E4^2 * H4 * Y1 + U24 * V34 * E4^2 * H4 * Y2 + U24 * V34 * E4^2 * H4 * Y3 + U24 * V34 * E4^2 * H4 * Y4 - 3 * U24 * V34 * E4 * H3 - U24 * V34 * E4 * H4 * X1 - U24 * V34 * E4 * H4 * X3 - 2 * U24 * V34 * E4 * H4 * X4 - U24 * V34 * E4 * Y1 - U24 * V34 * E4 * Y2 - 3 * U24 * V34 * E4 * Y3 - U24 * V34 * E4 * Y4 + U24 * V34 * X1 - U24 * V34 * X3 + U34 * V23 * E3 * E4 * H4^2 + U34 * V23 * E3 * H4 - 2 * U34 * V23 * E4^2 * H2 - U34 * V23 * E4^2 * H3 * H4 - U34 * V23 * E4^2 * H4 * Y1 - U34 * V23 * E4^2 * H4 * Y2 - U34 * V23 * E4^2 * H4 * Y3 - U34 * V23 * E4^2 * H4 * Y4 + 3 * U34 * V23 * E4 * H3 + U34 * V23 * E4 * H4 * X1 + U34 * V23 * E4 * H4 * X2 + 2 * U34 * V23 * E4 * H4 * X4 + U34 * V23 * E4 * Y1 + 3 * U34 * V23 * E4 * Y2 + U34 * V23 * E4 * Y3 + U34 * V23 * E4 * Y4 - U34 * V23 * X1 + U34 * V23 * X2 - U34 * V24 * E3 * E4 * H4^2 - U34 * V24 * E3 * H4 + 2 * U34 * V24 * E4^2 * H2 + U34 * V24 * E4^2 * H3 * H4 + U34 * V24 * E4^2 * H4 * Y1 + U34 * V24 * E4^2 * H4 * Y2 + U34 * V24 * E4^2 * H4 * Y3 + U34 * V24 * E4^2 * H4 * Y4 - 3 * U34 * V24 * E4 * H3 - U34 * V24 * E4 * H4 * X1 - U34 * V24 * E4 * H4 * X2 - 2 * U34 * V24 * E4 * H4 * X4 - U34 * V24 * E4 * Y1 - 3 * U34 * V24 * E4 * Y2 - U34 * V24 * E4 * Y3 - U34 * V24 * E4 * Y4 + U34 * V24 * X1 - U34 * V24 * X2 + 2 * V23 * V24 * E3 * H4^2 - 4 * V23 * V24 * E4 * H2 - 2 * V23 * V24 * E4 * H3 * H4 - 2 * V23 * V24 * E4 * H4 * Y1 - 3 * V23 * V24 * E4 * H4 * Y3 - 3 * V23 * V24 * E4 * H4 * Y4 + 6 * V23 * V24 * H3 + 2 * V23 * V24 * H4 * X2 + 2 * V23 * V24 * H4 * X3 + 2 * V23 * V24 * H4 * X4 + 2 * V23 * V24 * Y1 + 4 * V23 * V24 * Y2 + 3 * V23 * V24 * Y3 + 3 * V23 * V24 * Y4 - 2 * V23 * V34 * E3 * H4^2 + 4 * V23 * V34 * E4 * H2 + 2 * V23 * V34 * E4 * H3 * H4 + 2 * V23 * V34 * E4 * H4 * Y1 + V23 * V34 * E4 * H4 * Y2 + 2 * V23 * V34 * E4 * H4 * Y3 + 3 * V23 * V34 * E4 * H4 * Y4 - 6 * V23 * V34 * H3 - 2 * V23 * V34 * H4 * X2 - 2 * V23 * V34 * H4 * X3 - 2 * V23 * V34 * H4 * X4 - 2 * V23 * V34 * Y1 - 3 * V23 * V34 * Y2 - 4 * V23 * V34 * Y3 - 3 * V23 * V34 * Y4 + 2 * V24 * V34 * E3 * H4^2 - 4 * V24 * V34 * E4 * H2 - 2 * V24 * V34 * E4 * H3 * H4 - 2 * V24 * V34 * E4 * H4 * Y1 - V24 * V34 * E4 * H4 * Y2 - V24 * V34 * E4 * H4 * Y3 - 4 * V24 * V34 * E4 * H4 * Y4 + 6 * V24 * V34 * H3 + 2 * V24 * V34 * H4 * X2 + 2 * V24 * V34 * H4 * X3 + 2 * V24 * V34 * H4 * X4 + 2 * V24 * V34 * Y1 + 3 * V24 * V34 * Y2 + 3 * V24 * V34 * Y3 + 4 * V24 * V34 * Y4 - 2 * V24 * E4 * H4, U13 * U14 * E4 * Y2^2 - U13 * U14 * E4 * Y2 * Y3 - U13 * U14 * E4 * Y2 * Y4 + U13 * U14 * E4 * Y3 * Y4 + U13 * U14 * X2 * Y1 + U13 * U14 * X2 * Y2 - U13 * U14 * X2 * Y3 - U13 * U14 * X2 * Y4 - U13 * U14 * X4 * Y1 - U13 * U14 * X4 * Y2 + U13 * U14 * X4 * Y3 + U13 * U14 * X4 * Y4 + U13 * U34 * V14 * X2 * Y1^2 - U13 * U34 * V14 * X2 * Y1 * Y3 - U13 * U34 * V14 * X2 * Y1 * Y4 + U13 * U34 * V14 * X2 * Y3 * Y4 - U13 * U34 * V14 * X4 * Y1^2 + U13 * U34 * V14 * X4 * Y1 * Y3 + U13 * U34 * V14 * X4 * Y1 * Y4 - U13 * U34 * V14 * X4 * Y3 * Y4 - U13 * U34 * E4 * Y2^2 + U13 * U34 * E4 * Y2 * Y3 + U13 * U34 * E4 * Y2 * Y4 - U13 * U34 * E4 * Y3 * Y4 - U13 * U34 * X2 * Y1 - U13 * U34 * X2 * Y2 + U13 * U34 * X2 * Y3 + U13 * U34 * X2 * Y4 + U13 * U34 * X4 * Y1 + U13 * U34 * X4 * Y2 - U13 * U34 * X4 * Y3 - U13 * U34 * X4 * Y4 - U13 * V14 * V34 * H4 * X2 * Y1 * Y2 + U13 * V14 * V34 * H4 * X2 * Y1 * Y4 + U13 * V14 * V34 * H4 * X2 * Y2 * Y3 - U13 * V14 * V34 * H4 * X2 * Y3 * Y4 + U13 * V14 * V34 * H4 * X3 * Y1 * Y2 - U13 * V14 * V34 * H4 * X3 * Y1 * Y4 - U13 * V14 * V34 * H4 * X3 * Y2 * Y3 + U13 * V14 * V34 * H4 * X3 * Y3 * Y4 + U13 * V14 * V34 * Y1^2 * Y2 - U13 * V14 * V34 * Y1^2 * Y4 - U13 * V14 * V34 * Y1 * Y2^2 + U13 * V14 * V34 * Y1 * Y4^2 + U13 * V14 * V34 * Y2^2 * Y3 - U13 * V14 * V34 * Y2 * Y3^2 + U13 * V14 * V34 * Y3^2 * Y4 - U13 * V14 * V34 * Y3 * Y4^2 - U13 * V14 * H4 * X2 * Y2 + U13 * V14 * H4 * X2 * Y4 + U13 * V14 * H4 * X3 * Y2 - U13 * V14 * H4 * X3 * Y4 + U13 * V14 * Y1 * Y2 - U13 * V14 * Y1 * Y4 - U13 * V14 * Y2^2 + U13 * V14 * Y2 * Y3 - U13 * V14 * Y3 * Y4 + U13 * V14 * Y4^2 + U13 * V34 * H4 * X2 * Y2 - U13 * V34 * H4 * X2 * Y4 - U13 * V34 * H4 * X3 * Y2 + U13 * V34 * H4 * X3 * Y4 - U13 * V34 * Y1 * Y2 + U13 * V34 * Y1 * Y4 + U13 * V34 * Y2^2 - U13 * V34 * Y2 * Y3 + U13 * V34 * Y3 * Y4 - U13 * V34 * Y4^2 - U14 * U34 * V13 * X2 * Y1^2 + U14 * U34 * V13 * X2 * Y1 * Y3 + U14 * U34 * V13 * X2 * Y1 * Y4 - U14 * U34 * V13 * X2 * Y3 * Y4 + U14 * U34 * V13 * X4 * Y1^2 - U14 * U34 * V13 * X4 * Y1 * Y3 - U14 * U34 * V13 * X4 * Y1 * Y4 + U14 * U34 * V13 * X4 * Y3 * Y4 + U14 * U34 * E4 * Y2^2 - U14 * U34 * E4 * Y2 * Y3 - U14 * U34 * E4 * Y2 * Y4 + U14 * U34 * E4 * Y3 * Y4 + U14 * U34 * X2 * Y1 + U14 * U34 * X2 * Y2 - U14 * U34 * X2 * Y3 - U14 * U34 * X2 * Y4 - U14 * U34 * X4 * Y1 - U14 * U34 * X4 * Y2 + U14 * U34 * X4 * Y3 + U14 * U34 * X4 * Y4 + U14 * V13 * V34 * H4 * X2 * Y1 * Y2 - U14 * V13 * V34 * H4 * X2 * Y1 * Y3 - U14 * V13 * V34 * H4 * X2 * Y2 * Y4 + U14 * V13 * V34 * H4 * X2 * Y3 * Y4 - U14 * V13 * V34 * H4 * X4 * Y1 * Y2 + U14 * V13 * V34 * H4 * X4 * Y1 * Y3 + U14 * V13 * V34 * H4 * X4 * Y2 * Y4 - U14 * V13 * V34 * H4 * X4 * Y3 * Y4 - U14 * V13 * V34 * Y1^2 * Y2 + U14 * V13 * V34 * Y1^2 * Y4 + U14 * V13 * V34 * Y1 * Y2^2 - U14 * V13 * V34 * Y1 * Y4^2 - U14 * V13 * V34 * Y2^2 * Y4 + U14 * V13 * V34 * Y2 * Y4^2 - U14 * V13 * H4 * X2 * Y2 + U14 * V13 * H4 * X2 * Y3 + U14 * V13 * H4 * X4 * Y2 - U14 * V13 * H4 * X4 * Y3 - U14 * V13 * Y2^2 + U14 * V13 * Y2 * Y3 + U14 * V13 * Y2 * Y4 - U14 * V13 * Y3 * Y4 - U14 * V34 * H4 * X2 * Y2 + U14 * V34 * H4 * X2 * Y3 + U14 * V34 * H4 * X4 * Y2 - U14 * V34 * H4 * X4 * Y3 + U14 * V34 * Y1 * Y2 - U14 * V34 * Y1 * Y4 - U14 * V34 * Y2^2 + U14 * V34 * Y2 * Y3 - U14 * V34 * Y3 * Y4 + U14 * V34 * Y4^2 + U34 * V13 * V14 * H4 * X2 * Y1 * Y3 - U34 * V13 * V14 * H4 * X2 * Y1 * Y4 - U34 * V13 * V14 * H4 * X2 * Y2 * Y3 + U34 * V13 * V14 * H4 * X2 * Y2 * Y4 - U34 * V13 * V14 * H4 * X4 * Y1 * Y3 + U34 * V13 * V14 * H4 * X4 * Y1 * Y4 + U34 * V13 * V14 * H4 * X4 * Y2 * Y3 - U34 * V13 * V14 * H4 * X4 * Y2 * Y4 - U34 * V13 * V14 * Y2^2 * Y3 + U34 * V13 * V14 * Y2^2 * Y4 + U34 * V13 * V14 * Y2 * Y3^2 - U34 * V13 * V14 * Y2 * Y4^2 - U34 * V13 * V14 * Y3^2 * Y4 + U34 * V13 * V14 * Y3 * Y4^2 + U34 * V13 * H4 * X2 * Y2 - U34 * V13 * H4 * X2 * Y3 - U34 * V13 * H4 * X4 * Y2 + U34 * V13 * H4 * X4 * Y3 + U34 * V13 * Y2^2 - U34 * V13 * Y2 * Y3 - U34 * V13 * Y2 * Y4 + U34 * V13 * Y3 * Y4 - U34 * V14 * H4 * X2 * Y2 + U34 * V14 * H4 * X2 * Y4 + U34 * V14 * H4 * X4 * Y2 - U34 * V14 * H4 * X4 * Y4 - U34 * V14 * Y2^2 + U34 * V14 * Y2 * Y3 + U34 * V14 * Y2 * Y4 - U34 * V14 * Y3 * Y4 + V13 * V14 * V34 * H4 * Y1 * Y2 * Y3 - V13 * V14 * V34 * H4 * Y1 * Y2 * Y4 - V13 * V14 * V34 * H4 * Y1 * Y3 * Y4 + V13 * V14 * V34 * H4 * Y1 * Y4^2 - V13 * V14 * V34 * H4 * Y2 * Y3^2 + V13 * V14 * V34 * H4 * Y2 * Y3 * Y4 + V13 * V14 * V34 * H4 * Y3^2 * Y4 - V13 * V14 * V34 * H4 * Y3 * Y4^2 - V13 * V14 * H4 * Y1 * Y2 + V13 * V14 * H4 * Y1 * Y4 + V13 * V14 * H4 * Y2 * Y3 - V13 * V14 * H4 * Y3 * Y4 - V14 * V34 * H4 * Y2 * Y3 + V14 * V34 * H4 * Y2 * Y4 + V14 * V34 * H4 * Y3 * Y4 - V14 * V34 * H4 * Y4^2 + V14 * H4 * Y2 - V14 * H4 * Y4, 2 * U13 * U14 * E3 + 2 * U13 * U14 * E4 * X4 - 2 * U13 * U34 * E3 - 2 * U13 * U34 * E4 * X4 - U13 * V14 * E3 * E4 * H4^2 - U13 * V14 * E3 * H4 + 2 * U13 * V14 * E4^2 * H2 + U13 * V14 * E4^2 * H3 * H4 + U13 * V14 * E4^2 * H4 * Y1 + U13 * V14 * E4^2 * H4 * Y2 + U13 * V14 * E4^2 * H4 * Y3 + U13 * V14 * E4^2 * H4 * Y4 - 3 * U13 * V14 * E4 * H3 - U13 * V14 * E4 * H4 * X2 - 2 * U13 * V14 * E4 * H4 * X3 - U13 * V14 * E4 * H4 * X4 - 3 * U13 * V14 * E4 * Y1 - U13 * V14 * E4 * Y2 - U13 * V14 * E4 * Y3 - U13 * V14 * E4 * Y4 + U13 * V14 * X2 - U13 * V14 * X4 + U13 * V34 * E3 * E4 * H4^2 + U13 * V34 * E3 * H4 - 2 * U13 * V34 * E4^2 * H2 - U13 * V34 * E4^2 * H3 * H4 - U13 * V34 * E4^2 * H4 * Y1 - U13 * V34 * E4^2 * H4 * Y2 - U13 * V34 * E4^2 * H4 * Y3 - U13 * V34 * E4^2 * H4 * Y4 + 3 * U13 * V34 * E4 * H3 + U13 * V34 * E4 * H4 * X2 + 2 * U13 * V34 * E4 * H4 * X3 + U13 * V34 * E4 * H4 * X4 + U13 * V34 * E4 * Y1 + U13 * V34 * E4 * Y2 + 3 * U13 * V34 * E4 * Y3 + U13 * V34 * E4 * Y4 - U13 * V34 * X2 + U13 * V34 * X4 + 2 * U14 * U34 * E3 + 2 * U14 * U34 * E4 * X4 - U14 * V13 * E3 * E4 * H4^2 - U14 * V13 * E3 * H4 + 2 * U14 * V13 * E4^2 * H2 + U14 * V13 * E4^2 * H3 * H4 + U14 * V13 * E4^2 * H4 * Y1 + U14 * V13 * E4^2 * H4 * Y2 + U14 * V13 * E4^2 * H4 * Y3 + U14 * V13 * E4^2 * H4 * Y4 - 3 * U14 * V13 * E4 * H3 - U14 * V13 * E4 * H4 * X2 - U14 * V13 * E4 * H4 * X3 - 2 * U14 * V13 * E4 * H4 * X4 - U14 * V13 * E4 * Y1 - U14 * V13 * E4 * Y2 - 3 * U14 * V13 * E4 * Y3 - U14 * V13 * E4 * Y4 + U14 * V13 * X2 - U14 * V13 * X3 - U14 * V34 * E3 * E4 * H4^2 - U14 * V34 * E3 * H4 + 2 * U14 * V34 * E4^2 * H2 + U14 * V34 * E4^2 * H3 * H4 + U14 * V34 * E4^2 * H4 * Y1 + U14 * V34 * E4^2 * H4 * Y2 + U14 * V34 * E4^2 * H4 * Y3 + U14 * V34 * E4^2 * H4 * Y4 - 3 * U14 * V34 * E4 * H3 - U14 * V34 * E4 * H4 * X2 - U14 * V34 * E4 * H4 * X3 - 2 * U14 * V34 * E4 * H4 * X4 - U14 * V34 * E4 * Y1 - U14 * V34 * E4 * Y2 - 3 * U14 * V34 * E4 * Y3 - U14 * V34 * E4 * Y4 + U14 * V34 * X2 - U14 * V34 * X3 + U34 * V13 * E3 * E4 * H4^2 + U34 * V13 * E3 * H4 - 2 * U34 * V13 * E4^2 * H2 - U34 * V13 * E4^2 * H3 * H4 - U34 * V13 * E4^2 * H4 * Y1 - U34 * V13 * E4^2 * H4 * Y2 - U34 * V13 * E4^2 * H4 * Y3 - U34 * V13 * E4^2 * H4 * Y4 + 3 * U34 * V13 * E4 * H3 + U34 * V13 * E4 * H4 * X1 + U34 * V13 * E4 * H4 * X2 + 2 * U34 * V13 * E4 * H4 * X4 + 3 * U34 * V13 * E4 * Y1 + U34 * V13 * E4 * Y2 + U34 * V13 * E4 * Y3 + U34 * V13 * E4 * Y4 + U34 * V13 * X1 - U34 * V13 * X2 - U34 * V14 * E3 * E4 * H4^2 - U34 * V14 * E3 * H4 + 2 * U34 * V14 * E4^2 * H2 + U34 * V14 * E4^2 * H3 * H4 + U34 * V14 * E4^2 * H4 * Y1 + U34 * V14 * E4^2 * H4 * Y2 + U34 * V14 * E4^2 * H4 * Y3 + U34 * V14 * E4^2 * H4 * Y4 - 3 * U34 * V14 * E4 * H3 - U34 * V14 * E4 * H4 * X1 - U34 * V14 * E4 * H4 * X2 - 2 * U34 * V14 * E4 * H4 * X4 - 3 * U34 * V14 * E4 * Y1 - U34 * V14 * E4 * Y2 - U34 * V14 * E4 * Y3 - U34 * V14 * E4 * Y4 - U34 * V14 * X1 + U34 * V14 * X2 + 2 * V13 * V14 * E3 * H4^2 - 4 * V13 * V14 * E4 * H2 - 2 * V13 * V14 * E4 * H3 * H4 - 2 * V13 * V14 * E4 * H4 * Y2 - 3 * V13 * V14 * E4 * H4 * Y3 - 3 * V13 * V14 * E4 * H4 * Y4 + 6 * V13 * V14 * H3 + 2 * V13 * V14 * H4 * X1 + 2 * V13 * V14 * H4 * X3 + 2 * V13 * V14 * H4 * X4 + 4 * V13 * V14 * Y1 + 2 * V13 * V14 * Y2 + 3 * V13 * V14 * Y3 + 3 * V13 * V14 * Y4 - 2 * V13 * V34 * E3 * H4^2 + 4 * V13 * V34 * E4 * H2 + 2 * V13 * V34 * E4 * H3 * H4 + V13 * V34 * E4 * H4 * Y1 + 2 * V13 * V34 * E4 * H4 * Y2 + 2 * V13 * V34 * E4 * H4 * Y3 + 3 * V13 * V34 * E4 * H4 * Y4 - 6 * V13 * V34 * H3 - 2 * V13 * V34 * H4 * X1 - 2 * V13 * V34 * H4 * X3 - 2 * V13 * V34 * H4 * X4 - 3 * V13 * V34 * Y1 - 2 * V13 * V34 * Y2 - 4 * V13 * V34 * Y3 - 3 * V13 * V34 * Y4 + 2 * V14 * V34 * E3 * H4^2 - 4 * V14 * V34 * E4 * H2 - 2 * V14 * V34 * E4 * H3 * H4 - V14 * V34 * E4 * H4 * Y1 - 2 * V14 * V34 * E4 * H4 * Y2 - V14 * V34 * E4 * H4 * Y3 - 4 * V14 * V34 * E4 * H4 * Y4 + 6 * V14 * V34 * H3 + 2 * V14 * V34 * H4 * X1 + 2 * V14 * V34 * H4 * X3 + 2 * V14 * V34 * H4 * X4 + 3 * V14 * V34 * Y1 + 2 * V14 * V34 * Y2 + 3 * V14 * V34 * Y3 + 4 * V14 * V34 * Y4 - 2 * V14 * E4 * H4, U12 * U14 * E4 * Y2 * Y3 - U12 * U14 * E4 * Y2 * Y4 - U12 * U14 * E4 * Y3^2 + U12 * U14 * E4 * Y3 * Y4 - U12 * U14 * X3 * Y1 + U12 * U14 * X3 * Y2 - U12 * U14 * X3 * Y3 + U12 * U14 * X3 * Y4 + U12 * U14 * X4 * Y1 - U12 * U14 * X4 * Y2 + U12 * U14 * X4 * Y3 - U12 * U14 * X4 * Y4 - U12 * U24 * V14 * X3 * Y1^2 + U12 * U24 * V14 * X3 * Y1 * Y2 + U12 * U24 * V14 * X3 * Y1 * Y4 - U12 * U24 * V14 * X3 * Y2 * Y4 + U12 * U24 * V14 * X4 * Y1^2 - U12 * U24 * V14 * X4 * Y1 * Y2 - U12 * U24 * V14 * X4 * Y1 * Y4 + U12 * U24 * V14 * X4 * Y2 * Y4 - U12 * U24 * E4 * Y2 * Y3 + U12 * U24 * E4 * Y2 * Y4 + U12 * U24 * E4 * Y3^2 - U12 * U24 * E4 * Y3 * Y4 + U12 * U24 * X3 * Y1 - U12 * U24 * X3 * Y2 + U12 * U24 * X3 * Y3 - U12 * U24 * X3 * Y4 - U12 * U24 * X4 * Y1 + U12 * U24 * X4 * Y2 - U12 * U24 * X4 * Y3 + U12 * U24 * X4 * Y4 - U12 * V14 * V24 * H4 * X2 * Y1 * Y3 + U12 * V14 * V24 * H4 * X2 * Y1 * Y4 + U12 * V14 * V24 * H4 * X2 * Y2 * Y3 - U12 * V14 * V24 * H4 * X2 * Y2 * Y4 + U12 * V14 * V24 * H4 * X3 * Y1 * Y3 - U12 * V14 * V24 * H4 * X3 * Y1 * Y4 - U12 * V14 * V24 * H4 * X3 * Y2 * Y3 + U12 * V14 * V24 * H4 * X3 * Y2 * Y4 - U12 * V14 * V24 * Y1^2 * Y3 + U12 * V14 * V24 * Y1^2 * Y4 + U12 * V14 * V24 * Y1 * Y3^2 - U12 * V14 * V24 * Y1 * Y4^2 + U12 * V14 * V24 * Y2^2 * Y3 - U12 * V14 * V24 * Y2^2 * Y4 - U12 * V14 * V24 * Y2 * Y3^2 + U12 * V14 * V24 * Y2 * Y4^2 - U12 * V14 * H4 * X2 * Y3 + U12 * V14 * H4 * X2 * Y4 + U12 * V14 * H4 * X3 * Y3 - U12 * V14 * H4 * X3 * Y4 - U12 * V14 * Y1 * Y3 + U12 * V14 * Y1 * Y4 - U12 * V14 * Y2 * Y3 + U12 * V14 * Y2 * Y4 + U12 * V14 * Y3^2 - U12 * V14 * Y4^2 + U12 * V24 * H4 * X2 * Y3 - U12 * V24 * H4 * X2 * Y4 - U12 * V24 * H4 * X3 * Y3 + U12 * V24 * H4 * X3 * Y4 + U12 * V24 * Y1 * Y3 - U12 * V24 * Y1 * Y4 + U12 * V24 * Y2 * Y3 - U12 * V24 * Y2 * Y4 - U12 * V24 * Y3^2 + U12 * V24 * Y4^2 + U14 * U24 * V12 * X3 * Y1^2 - U14 * U24 * V12 * X3 * Y1 * Y2 - U14 * U24 * V12 * X3 * Y1 * Y4 + U14 * U24 * V12 * X3 * Y2 * Y4 - U14 * U24 * V12 * X4 * Y1^2 + U14 * U24 * V12 * X4 * Y1 * Y2 + U14 * U24 * V12 * X4 * Y1 * Y4 - U14 * U24 * V12 * X4 * Y2 * Y4 + U14 * U24 * E4 * Y2 * Y3 - U14 * U24 * E4 * Y2 * Y4 - U14 * U24 * E4 * Y3^2 + U14 * U24 * E4 * Y3 * Y4 - U14 * U24 * X3 * Y1 + U14 * U24 * X3 * Y2 - U14 * U24 * X3 * Y3 + U14 * U24 * X3 * Y4 + U14 * U24 * X4 * Y1 - U14 * U24 * X4 * Y2 + U14 * U24 * X4 * Y3 - U14 * U24 * X4 * Y4 + U14 * V12 * V24 * H4 * X3 * Y1 * Y2 - U14 * V12 * V24 * H4 * X3 * Y1 * Y3 - U14 * V12 * V24 * H4 * X3 * Y2 * Y4 + U14 * V12 * V24 * H4 * X3 * Y3 * Y4 - U14 * V12 * V24 * H4 * X4 * Y1 * Y2 + U14 * V12 * V24 * H4 * X4 * Y1 * Y3 + U14 * V12 * V24 * H4 * X4 * Y2 * Y4 - U14 * V12 * V24 * H4 * X4 * Y3 * Y4 + U14 * V12 * V24 * Y1^2 * Y3 - U14 * V12 * V24 * Y1^2 * Y4 - U14 * V12 * V24 * Y1 * Y3^2 + U14 * V12 * V24 * Y1 * Y4^2 + U14 * V12 * V24 * Y3^2 * Y4 - U14 * V12 * V24 * Y3 * Y4^2 - U14 * V12 * H4 * X3 * Y2 + U14 * V12 * H4 * X3 * Y3 + U14 * V12 * H4 * X4 * Y2 - U14 * V12 * H4 * X4 * Y3 - U14 * V12 * Y2 * Y3 + U14 * V12 * Y2 * Y4 + U14 * V12 * Y3^2 - U14 * V12 * Y3 * Y4 - U14 * V24 * H4 * X3 * Y2 + U14 * V24 * H4 * X3 * Y3 + U14 * V24 * H4 * X4 * Y2 - U14 * V24 * H4 * X4 * Y3 - U14 * V24 * Y1 * Y3 + U14 * V24 * Y1 * Y4 - U14 * V24 * Y2 * Y3 + U14 * V24 * Y2 * Y4 + U14 * V24 * Y3^2 - U14 * V24 * Y4^2 - U24 * V12 * V14 * H4 * X3 * Y1 * Y2 + U24 * V12 * V14 * H4 * X3 * Y1 * Y4 + U24 * V12 * V14 * H4 * X3 * Y2 * Y3 - U24 * V12 * V14 * H4 * X3 * Y3 * Y4 + U24 * V12 * V14 * H4 * X4 * Y1 * Y2 - U24 * V12 * V14 * H4 * X4 * Y1 * Y4 - U24 * V12 * V14 * H4 * X4 * Y2 * Y3 + U24 * V12 * V14 * H4 * X4 * Y3 * Y4 - U24 * V12 * V14 * Y2^2 * Y3 + U24 * V12 * V14 * Y2^2 * Y4 + U24 * V12 * V14 * Y2 * Y3^2 - U24 * V12 * V14 * Y2 * Y4^2 - U24 * V12 * V14 * Y3^2 * Y4 + U24 * V12 * V14 * Y3 * Y4^2 + U24 * V12 * H4 * X3 * Y2 - U24 * V12 * H4 * X3 * Y3 - U24 * V12 * H4 * X4 * Y2 + U24 * V12 * H4 * X4 * Y3 + U24 * V12 * Y2 * Y3 - U24 * V12 * Y2 * Y4 - U24 * V12 * Y3^2 + U24 * V12 * Y3 * Y4 + U24 * V14 * H4 * X3 * Y3 - U24 * V14 * H4 * X3 * Y4 - U24 * V14 * H4 * X4 * Y3 + U24 * V14 * H4 * X4 * Y4 - U24 * V14 * Y2 * Y3 + U24 * V14 * Y2 * Y4 + U24 * V14 * Y3^2 - U24 * V14 * Y3 * Y4 - V12 * V14 * V24 * H4 * Y1 * Y2 * Y3 + V12 * V14 * V24 * H4 * Y1 * Y2 * Y4 + V12 * V14 * V24 * H4 * Y1 * Y3 * Y4 - V12 * V14 * V24 * H4 * Y1 * Y4^2 + V12 * V14 * V24 * H4 * Y2^2 * Y3 - V12 * V14 * V24 * H4 * Y2^2 * Y4 - V12 * V14 * V24 * H4 * Y2 * Y3 * Y4 + V12 * V14 * V24 * H4 * Y2 * Y4^2 + V12 * V14 * H4 * Y1 * Y3 - V12 * V14 * H4 * Y1 * Y4 - V12 * V14 * H4 * Y2 * Y3 + V12 * V14 * H4 * Y2 * Y4 + V14 * V24 * H4 * Y2 * Y3 - V14 * V24 * H4 * Y2 * Y4 - V14 * V24 * H4 * Y3 * Y4 + V14 * V24 * H4 * Y4^2 - V14 * H4 * Y3 + V14 * H4 * Y4, 2 * U12 * U14 * E3 + 2 * U12 * U14 * E4 * X4 - 2 * U12 * U24 * E3 - 2 * U12 * U24 * E4 * X4 - U12 * V14 * E3 * E4 * H4^2 - U12 * V14 * E3 * H4 + 2 * U12 * V14 * E4^2 * H2 + U12 * V14 * E4^2 * H3 * H4 + U12 * V14 * E4^2 * H4 * Y1 + U12 * V14 * E4^2 * H4 * Y2 + U12 * V14 * E4^2 * H4 * Y3 + U12 * V14 * E4^2 * H4 * Y4 - 3 * U12 * V14 * E4 * H3 - 2 * U12 * V14 * E4 * H4 * X2 - U12 * V14 * E4 * H4 * X3 - U12 * V14 * E4 * H4 * X4 - 3 * U12 * V14 * E4 * Y1 - U12 * V14 * E4 * Y2 - U12 * V14 * E4 * Y3 - U12 * V14 * E4 * Y4 + U12 * V14 * X3 - U12 * V14 * X4 + U12 * V24 * E3 * E4 * H4^2 + U12 * V24 * E3 * H4 - 2 * U12 * V24 * E4^2 * H2 - U12 * V24 * E4^2 * H3 * H4 - U12 * V24 * E4^2 * H4 * Y1 - U12 * V24 * E4^2 * H4 * Y2 - U12 * V24 * E4^2 * H4 * Y3 - U12 * V24 * E4^2 * H4 * Y4 + 3 * U12 * V24 * E4 * H3 + 2 * U12 * V24 * E4 * H4 * X2 + U12 * V24 * E4 * H4 * X3 + U12 * V24 * E4 * H4 * X4 + U12 * V24 * E4 * Y1 + 3 * U12 * V24 * E4 * Y2 + U12 * V24 * E4 * Y3 + U12 * V24 * E4 * Y4 - U12 * V24 * X3 + U12 * V24 * X4 + 2 * U14 * U24 * E3 + 2 * U14 * U24 * E4 * X4 - U14 * V12 * E3 * E4 * H4^2 - U14 * V12 * E3 * H4 + 2 * U14 * V12 * E4^2 * H2 + U14 * V12 * E4^2 * H3 * H4 + U14 * V12 * E4^2 * H4 * Y1 + U14 * V12 * E4^2 * H4 * Y2 + U14 * V12 * E4^2 * H4 * Y3 + U14 * V12 * E4^2 * H4 * Y4 - 3 * U14 * V12 * E4 * H3 - U14 * V12 * E4 * H4 * X2 - U14 * V12 * E4 * H4 * X3 - 2 * U14 * V12 * E4 * H4 * X4 - U14 * V12 * E4 * Y1 - 3 * U14 * V12 * E4 * Y2 - U14 * V12 * E4 * Y3 - U14 * V12 * E4 * Y4 - U14 * V12 * X2 + U14 * V12 * X3 - U14 * V24 * E3 * E4 * H4^2 - U14 * V24 * E3 * H4 + 2 * U14 * V24 * E4^2 * H2 + U14 * V24 * E4^2 * H3 * H4 + U14 * V24 * E4^2 * H4 * Y1 + U14 * V24 * E4^2 * H4 * Y2 + U14 * V24 * E4^2 * H4 * Y3 + U14 * V24 * E4^2 * H4 * Y4 - 3 * U14 * V24 * E4 * H3 - U14 * V24 * E4 * H4 * X2 - U14 * V24 * E4 * H4 * X3 - 2 * U14 * V24 * E4 * H4 * X4 - U14 * V24 * E4 * Y1 - 3 * U14 * V24 * E4 * Y2 - U14 * V24 * E4 * Y3 - U14 * V24 * E4 * Y4 - U14 * V24 * X2 + U14 * V24 * X3 + U24 * V12 * E3 * E4 * H4^2 + U24 * V12 * E3 * H4 - 2 * U24 * V12 * E4^2 * H2 - U24 * V12 * E4^2 * H3 * H4 - U24 * V12 * E4^2 * H4 * Y1 - U24 * V12 * E4^2 * H4 * Y2 - U24 * V12 * E4^2 * H4 * Y3 - U24 * V12 * E4^2 * H4 * Y4 + 3 * U24 * V12 * E4 * H3 + U24 * V12 * E4 * H4 * X1 + U24 * V12 * E4 * H4 * X3 + 2 * U24 * V12 * E4 * H4 * X4 + 3 * U24 * V12 * E4 * Y1 + U24 * V12 * E4 * Y2 + U24 * V12 * E4 * Y3 + U24 * V12 * E4 * Y4 + U24 * V12 * X1 - U24 * V12 * X3 - U24 * V14 * E3 * E4 * H4^2 - U24 * V14 * E3 * H4 + 2 * U24 * V14 * E4^2 * H2 + U24 * V14 * E4^2 * H3 * H4 + U24 * V14 * E4^2 * H4 * Y1 + U24 * V14 * E4^2 * H4 * Y2 + U24 * V14 * E4^2 * H4 * Y3 + U24 * V14 * E4^2 * H4 * Y4 - 3 * U24 * V14 * E4 * H3 - U24 * V14 * E4 * H4 * X1 - U24 * V14 * E4 * H4 * X3 - 2 * U24 * V14 * E4 * H4 * X4 - 3 * U24 * V14 * E4 * Y1 - U24 * V14 * E4 * Y2 - U24 * V14 * E4 * Y3 - U24 * V14 * E4 * Y4 - U24 * V14 * X1 + U24 * V14 * X3 + 2 * V12 * V14 * E3 * H4^2 - 4 * V12 * V14 * E4 * H2 - 2 * V12 * V14 * E4 * H3 * H4 - 3 * V12 * V14 * E4 * H4 * Y2 - 2 * V12 * V14 * E4 * H4 * Y3 - 3 * V12 * V14 * E4 * H4 * Y4 + 6 * V12 * V14 * H3 + 2 * V12 * V14 * H4 * X1 + 2 * V12 * V14 * H4 * X2 + 2 * V12 * V14 * H4 * X4 + 4 * V12 * V14 * Y1 + 3 * V12 * V14 * Y2 + 2 * V12 * V14 * Y3 + 3 * V12 * V14 * Y4 - 2 * V12 * V24 * E3 * H4^2 + 4 * V12 * V24 * E4 * H2 + 2 * V12 * V24 * E4 * H3 * H4 + V12 * V24 * E4 * H4 * Y1 + 2 * V12 * V24 * E4 * H4 * Y2 + 2 * V12 * V24 * E4 * H4 * Y3 + 3 * V12 * V24 * E4 * H4 * Y4 - 6 * V12 * V24 * H3 - 2 * V12 * V24 * H4 * X1 - 2 * V12 * V24 * H4 * X2 - 2 * V12 * V24 * H4 * X4 - 3 * V12 * V24 * Y1 - 4 * V12 * V24 * Y2 - 2 * V12 * V24 * Y3 - 3 * V12 * V24 * Y4 + 2 * V14 * V24 * E3 * H4^2 - 4 * V14 * V24 * E4 * H2 - 2 * V14 * V24 * E4 * H3 * H4 - V14 * V24 * E4 * H4 * Y1 - V14 * V24 * E4 * H4 * Y2 - 2 * V14 * V24 * E4 * H4 * Y3 - 4 * V14 * V24 * E4 * H4 * Y4 + 6 * V14 * V24 * H3 + 2 * V14 * V24 * H4 * X1 + 2 * V14 * V24 * H4 * X2 + 2 * V14 * V24 * H4 * X4 + 3 * V14 * V24 * Y1 + 3 * V14 * V24 * Y2 + 2 * V14 * V24 * Y3 + 4 * V14 * V24 * Y4 - 2 * V14 * E4 * H4, U12 * U13 * E4 * Y2 * Y3 - U12 * U13 * E4 * Y2 * Y4 - U12 * U13 * E4 * Y3 * Y4 + U12 * U13 * E4 * Y4^2 - U12 * U13 * X3 * Y1 + U12 * U13 * X3 * Y2 + U12 * U13 * X3 * Y3 - U12 * U13 * X3 * Y4 + U12 * U13 * X4 * Y1 - U12 * U13 * X4 * Y2 - U12 * U13 * X4 * Y3 + U12 * U13 * X4 * Y4 - U12 * U23 * V13 * X3 * Y1^2 + U12 * U23 * V13 * X3 * Y1 * Y2 + U12 * U23 * V13 * X3 * Y1 * Y3 - U12 * U23 * V13 * X3 * Y2 * Y3 + U12 * U23 * V13 * X4 * Y1^2 - U12 * U23 * V13 * X4 * Y1 * Y2 - U12 * U23 * V13 * X4 * Y1 * Y3 + U12 * U23 * V13 * X4 * Y2 * Y3 - U12 * U23 * E4 * Y2 * Y3 + U12 * U23 * E4 * Y2 * Y4 + U12 * U23 * E4 * Y3 * Y4 - U12 * U23 * E4 * Y4^2 + U12 * U23 * X3 * Y1 - U12 * U23 * X3 * Y2 - U12 * U23 * X3 * Y3 + U12 * U23 * X3 * Y4 - U12 * U23 * X4 * Y1 + U12 * U23 * X4 * Y2 + U12 * U23 * X4 * Y3 - U12 * U23 * X4 * Y4 - U12 * V13 * V23 * H4 * X2 * Y1 * Y3 + U12 * V13 * V23 * H4 * X2 * Y1 * Y4 + U12 * V13 * V23 * H4 * X2 * Y2 * Y3 - U12 * V13 * V23 * H4 * X2 * Y2 * Y4 + U12 * V13 * V23 * H4 * X4 * Y1 * Y3 - U12 * V13 * V23 * H4 * X4 * Y1 * Y4 - U12 * V13 * V23 * H4 * X4 * Y2 * Y3 + U12 * V13 * V23 * H4 * X4 * Y2 * Y4 - U12 * V13 * V23 * Y1^2 * Y3 + U12 * V13 * V23 * Y1^2 * Y4 + U12 * V13 * V23 * Y1 * Y3^2 - U12 * V13 * V23 * Y1 * Y4^2 + U12 * V13 * V23 * Y2^2 * Y3 - U12 * V13 * V23 * Y2^2 * Y4 - U12 * V13 * V23 * Y2 * Y3^2 + U12 * V13 * V23 * Y2 * Y4^2 - U12 * V13 * H4 * X2 * Y3 + U12 * V13 * H4 * X2 * Y4 + U12 * V13 * H4 * X4 * Y3 - U12 * V13 * H4 * X4 * Y4 - U12 * V13 * Y1 * Y3 + U12 * V13 * Y1 * Y4 - U12 * V13 * Y2 * Y3 + U12 * V13 * Y2 * Y4 + U12 * V13 * Y3^2 - U12 * V13 * Y4^2 + U12 * V23 * H4 * X2 * Y3 - U12 * V23 * H4 * X2 * Y4 - U12 * V23 * H4 * X4 * Y3 + U12 * V23 * H4 * X4 * Y4 + U12 * V23 * Y1 * Y3 - U12 * V23 * Y1 * Y4 + U12 * V23 * Y2 * Y3 - U12 * V23 * Y2 * Y4 - U12 * V23 * Y3^2 + U12 * V23 * Y4^2 + U13 * U23 * V12 * X3 * Y1^2 - U13 * U23 * V12 * X3 * Y1 * Y2 - U13 * U23 * V12 * X3 * Y1 * Y3 + U13 * U23 * V12 * X3 * Y2 * Y3 - U13 * U23 * V12 * X4 * Y1^2 + U13 * U23 * V12 * X4 * Y1 * Y2 + U13 * U23 * V12 * X4 * Y1 * Y3 - U13 * U23 * V12 * X4 * Y2 * Y3 + U13 * U23 * E4 * Y2 * Y3 - U13 * U23 * E4 * Y2 * Y4 - U13 * U23 * E4 * Y3 * Y4 + U13 * U23 * E4 * Y4^2 - U13 * U23 * X3 * Y1 + U13 * U23 * X3 * Y2 + U13 * U23 * X3 * Y3 - U13 * U23 * X3 * Y4 + U13 * U23 * X4 * Y1 - U13 * U23 * X4 * Y2 - U13 * U23 * X4 * Y3 + U13 * U23 * X4 * Y4 + U13 * V12 * V23 * H4 * X3 * Y1 * Y2 - U13 * V12 * V23 * H4 * X3 * Y1 * Y4 - U13 * V12 * V23 * H4 * X3 * Y2 * Y3 + U13 * V12 * V23 * H4 * X3 * Y3 * Y4 - U13 * V12 * V23 * H4 * X4 * Y1 * Y2 + U13 * V12 * V23 * H4 * X4 * Y1 * Y4 + U13 * V12 * V23 * H4 * X4 * Y2 * Y3 - U13 * V12 * V23 * H4 * X4 * Y3 * Y4 + U13 * V12 * V23 * Y1^2 * Y3 - U13 * V12 * V23 * Y1^2 * Y4 - U13 * V12 * V23 * Y1 * Y3^2 + U13 * V12 * V23 * Y1 * Y4^2 + U13 * V12 * V23 * Y3^2 * Y4 - U13 * V12 * V23 * Y3 * Y4^2 - U13 * V12 * H4 * X3 * Y2 + U13 * V12 * H4 * X3 * Y4 + U13 * V12 * H4 * X4 * Y2 - U13 * V12 * H4 * X4 * Y4 - U13 * V12 * Y2 * Y3 + U13 * V12 * Y2 * Y4 + U13 * V12 * Y3 * Y4 - U13 * V12 * Y4^2 - U13 * V23 * H4 * X3 * Y2 + U13 * V23 * H4 * X3 * Y4 + U13 * V23 * H4 * X4 * Y2 - U13 * V23 * H4 * X4 * Y4 - U13 * V23 * Y1 * Y3 + U13 * V23 * Y1 * Y4 - U13 * V23 * Y2 * Y3 + U13 * V23 * Y2 * Y4 + U13 * V23 * Y3^2 - U13 * V23 * Y4^2 - U23 * V12 * V13 * H4 * X3 * Y1 * Y2 + U23 * V12 * V13 * H4 * X3 * Y1 * Y3 + U23 * V12 * V13 * H4 * X3 * Y2 * Y4 - U23 * V12 * V13 * H4 * X3 * Y3 * Y4 + U23 * V12 * V13 * H4 * X4 * Y1 * Y2 - U23 * V12 * V13 * H4 * X4 * Y1 * Y3 - U23 * V12 * V13 * H4 * X4 * Y2 * Y4 + U23 * V12 * V13 * H4 * X4 * Y3 * Y4 - U23 * V12 * V13 * Y2^2 * Y3 + U23 * V12 * V13 * Y2^2 * Y4 + U23 * V12 * V13 * Y2 * Y3^2 - U23 * V12 * V13 * Y2 * Y4^2 - U23 * V12 * V13 * Y3^2 * Y4 + U23 * V12 * V13 * Y3 * Y4^2 + U23 * V12 * H4 * X3 * Y2 - U23 * V12 * H4 * X3 * Y4 - U23 * V12 * H4 * X4 * Y2 + U23 * V12 * H4 * X4 * Y4 + U23 * V12 * Y2 * Y3 - U23 * V12 * Y2 * Y4 - U23 * V12 * Y3 * Y4 + U23 * V12 * Y4^2 - U23 * V13 * H4 * X3 * Y3 + U23 * V13 * H4 * X3 * Y4 + U23 * V13 * H4 * X4 * Y3 - U23 * V13 * H4 * X4 * Y4 - U23 * V13 * Y2 * Y3 + U23 * V13 * Y2 * Y4 + U23 * V13 * Y3 * Y4 - U23 * V13 * Y4^2 - V12 * V13 * V23 * H4 * Y1 * Y2 * Y3 + V12 * V13 * V23 * H4 * Y1 * Y2 * Y4 + V12 * V13 * V23 * H4 * Y1 * Y3^2 - V12 * V13 * V23 * H4 * Y1 * Y3 * Y4 + V12 * V13 * V23 * H4 * Y2^2 * Y3 - V12 * V13 * V23 * H4 * Y2^2 * Y4 - V12 * V13 * V23 * H4 * Y2 * Y3^2 + V12 * V13 * V23 * H4 * Y2 * Y3 * Y4 + V12 * V13 * H4 * Y1 * Y3 - V12 * V13 * H4 * Y1 * Y4 - V12 * V13 * H4 * Y2 * Y3 + V12 * V13 * H4 * Y2 * Y4 + V13 * V23 * H4 * Y2 * Y3 - V13 * V23 * H4 * Y2 * Y4 - V13 * V23 * H4 * Y3^2 + V13 * V23 * H4 * Y3 * Y4 - V13 * H4 * Y3 + V13 * H4 * Y4, 2 * U12 * U13 * E3 + 2 * U12 * U13 * E4 * X3 - 2 * U12 * U23 * E3 - 2 * U12 * U23 * E4 * X3 - U12 * V13 * E3 * E4 * H4^2 - U12 * V13 * E3 * H4 + 2 * U12 * V13 * E4^2 * H2 + U12 * V13 * E4^2 * H3 * H4 + U12 * V13 * E4^2 * H4 * Y1 + U12 * V13 * E4^2 * H4 * Y2 + U12 * V13 * E4^2 * H4 * Y3 + U12 * V13 * E4^2 * H4 * Y4 - 3 * U12 * V13 * E4 * H3 - 2 * U12 * V13 * E4 * H4 * X2 - U12 * V13 * E4 * H4 * X3 - U12 * V13 * E4 * H4 * X4 - 3 * U12 * V13 * E4 * Y1 - U12 * V13 * E4 * Y2 - U12 * V13 * E4 * Y3 - U12 * V13 * E4 * Y4 - U12 * V13 * X3 + U12 * V13 * X4 + U12 * V23 * E3 * E4 * H4^2 + U12 * V23 * E3 * H4 - 2 * U12 * V23 * E4^2 * H2 - U12 * V23 * E4^2 * H3 * H4 - U12 * V23 * E4^2 * H4 * Y1 - U12 * V23 * E4^2 * H4 * Y2 - U12 * V23 * E4^2 * H4 * Y3 - U12 * V23 * E4^2 * H4 * Y4 + 3 * U12 * V23 * E4 * H3 + 2 * U12 * V23 * E4 * H4 * X2 + U12 * V23 * E4 * H4 * X3 + U12 * V23 * E4 * H4 * X4 + U12 * V23 * E4 * Y1 + 3 * U12 * V23 * E4 * Y2 + U12 * V23 * E4 * Y3 + U12 * V23 * E4 * Y4 + U12 * V23 * X3 - U12 * V23 * X4 + 2 * U13 * U23 * E3 + 2 * U13 * U23 * E4 * X3 - U13 * V12 * E3 * E4 * H4^2 - U13 * V12 * E3 * H4 + 2 * U13 * V12 * E4^2 * H2 + U13 * V12 * E4^2 * H3 * H4 + U13 * V12 * E4^2 * H4 * Y1 + U13 * V12 * E4^2 * H4 * Y2 + U13 * V12 * E4^2 * H4 * Y3 + U13 * V12 * E4^2 * H4 * Y4 - 3 * U13 * V12 * E4 * H3 - U13 * V12 * E4 * H4 * X2 - 2 * U13 * V12 * E4 * H4 * X3 - U13 * V12 * E4 * H4 * X4 - U13 * V12 * E4 * Y1 - 3 * U13 * V12 * E4 * Y2 - U13 * V12 * E4 * Y3 - U13 * V12 * E4 * Y4 - U13 * V12 * X2 + U13 * V12 * X4 - U13 * V23 * E3 * E4 * H4^2 - U13 * V23 * E3 * H4 + 2 * U13 * V23 * E4^2 * H2 + U13 * V23 * E4^2 * H3 * H4 + U13 * V23 * E4^2 * H4 * Y1 + U13 * V23 * E4^2 * H4 * Y2 + U13 * V23 * E4^2 * H4 * Y3 + U13 * V23 * E4^2 * H4 * Y4 - 3 * U13 * V23 * E4 * H3 - U13 * V23 * E4 * H4 * X2 - 2 * U13 * V23 * E4 * H4 * X3 - U13 * V23 * E4 * H4 * X4 - U13 * V23 * E4 * Y1 - 3 * U13 * V23 * E4 * Y2 - U13 * V23 * E4 * Y3 - U13 * V23 * E4 * Y4 - U13 * V23 * X2 + U13 * V23 * X4 + U23 * V12 * E3 * E4 * H4^2 + U23 * V12 * E3 * H4 - 2 * U23 * V12 * E4^2 * H2 - U23 * V12 * E4^2 * H3 * H4 - U23 * V12 * E4^2 * H4 * Y1 - U23 * V12 * E4^2 * H4 * Y2 - U23 * V12 * E4^2 * H4 * Y3 - U23 * V12 * E4^2 * H4 * Y4 + 3 * U23 * V12 * E4 * H3 + U23 * V12 * E4 * H4 * X1 + 2 * U23 * V12 * E4 * H4 * X3 + U23 * V12 * E4 * H4 * X4 + 3 * U23 * V12 * E4 * Y1 + U23 * V12 * E4 * Y2 + U23 * V12 * E4 * Y3 + U23 * V12 * E4 * Y4 + U23 * V12 * X1 - U23 * V12 * X4 - U23 * V13 * E3 * E4 * H4^2 - U23 * V13 * E3 * H4 + 2 * U23 * V13 * E4^2 * H2 + U23 * V13 * E4^2 * H3 * H4 + U23 * V13 * E4^2 * H4 * Y1 + U23 * V13 * E4^2 * H4 * Y2 + U23 * V13 * E4^2 * H4 * Y3 + U23 * V13 * E4^2 * H4 * Y4 - 3 * U23 * V13 * E4 * H3 - U23 * V13 * E4 * H4 * X1 - 2 * U23 * V13 * E4 * H4 * X3 - U23 * V13 * E4 * H4 * X4 - 3 * U23 * V13 * E4 * Y1 - U23 * V13 * E4 * Y2 - U23 * V13 * E4 * Y3 - U23 * V13 * E4 * Y4 - U23 * V13 * X1 + U23 * V13 * X4 + 2 * V12 * V13 * E3 * H4^2 - 4 * V12 * V13 * E4 * H2 - 2 * V12 * V13 * E4 * H3 * H4 - 3 * V12 * V13 * E4 * H4 * Y2 - 3 * V12 * V13 * E4 * H4 * Y3 - 2 * V12 * V13 * E4 * H4 * Y4 + 6 * V12 * V13 * H3 + 2 * V12 * V13 * H4 * X1 + 2 * V12 * V13 * H4 * X2 + 2 * V12 * V13 * H4 * X3 + 4 * V12 * V13 * Y1 + 3 * V12 * V13 * Y2 + 3 * V12 * V13 * Y3 + 2 * V12 * V13 * Y4 - 2 * V12 * V23 * E3 * H4^2 + 4 * V12 * V23 * E4 * H2 + 2 * V12 * V23 * E4 * H3 * H4 + V12 * V23 * E4 * H4 * Y1 + 2 * V12 * V23 * E4 * H4 * Y2 + 3 * V12 * V23 * E4 * H4 * Y3 + 2 * V12 * V23 * E4 * H4 * Y4 - 6 * V12 * V23 * H3 - 2 * V12 * V23 * H4 * X1 - 2 * V12 * V23 * H4 * X2 - 2 * V12 * V23 * H4 * X3 - 3 * V12 * V23 * Y1 - 4 * V12 * V23 * Y2 - 3 * V12 * V23 * Y3 - 2 * V12 * V23 * Y4 + 2 * V13 * V23 * E3 * H4^2 - 4 * V13 * V23 * E4 * H2 - 2 * V13 * V23 * E4 * H3 * H4 - V13 * V23 * E4 * H4 * Y1 - V13 * V23 * E4 * H4 * Y2 - 4 * V13 * V23 * E4 * H4 * Y3 - 2 * V13 * V23 * E4 * H4 * Y4 + 6 * V13 * V23 * H3 + 2 * V13 * V23 * H4 * X1 + 2 * V13 * V23 * H4 * X2 + 2 * V13 * V23 * H4 * X3 + 3 * V13 * V23 * Y1 + 3 * V13 * V23 * Y2 + 4 * V13 * V23 * Y3 + 2 * V13 * V23 * Y4 - 2 * V13 * E4 * H4, E4 * H2^2 + 2 * E4 * H2 * H4 * Y4 - E4 * H4^2 * Y2 * Y3 + E4 * H4^2 * Y2 * Y4 + E4 * H4^2 * Y3 * Y4 - 2 * H2 * H3 - 2 * H2 * H4 * X4 - H2 * Y1 - H2 * Y2 - H2 * Y3 - H2 * Y4 + H3^2 * H4 + H3 * H4^2 * X1 + H3 * H4^2 * X2 + H3 * H4^2 * X3 - H3 * H4^2 * X4 + 2 * H3 * H4 * Y1 + 2 * H3 * H4 * Y2 + 2 * H3 * H4 * Y3 - 4 * H3 * H4 * Y4 + H4^3 * X1 * X2 + H4^3 * X1 * X3 - H4^3 * X1 * X4 + H4^2 * X1 * Y1 + H4^2 * X1 * Y2 + H4^2 * X1 * Y3 - H4^2 * X1 * Y4 + H4^2 * X2 * Y1 + H4^2 * X2 * Y2 + H4^2 * X3 * Y1 + H4^2 * X3 * Y3 - H4^2 * X4 * Y1 - 3 * H4^2 * X4 * Y4 + H4 * Y1^2 + H4 * Y1 * Y2 + H4 * Y1 * Y3 - H4 * Y1 * Y4 + H4 * Y2^2 + H4 * Y2 * Y3 - H4 * Y2 * Y4 + H4 * Y3^2 - H4 * Y3 * Y4 - 3 * H4 * Y4^2, E3 * H2 * H4 - E3 * H3 * H4^2 - E3 * H4^3 * X4 - E3 * H4^2 * Y4 + E4 * H2 * H3 + 2 * E4 * H2 * H4 * X4 + 2 * E4 * H2 * Y4 + E4 * H3^2 * H4 + E4 * H3 * H4^2 * X4 + E4 * H3 * H4 * Y1 + E4 * H3 * H4 * Y2 + E4 * H3 * H4 * Y3 + 2 * E4 * H3 * H4 * Y4 + E4 * H4^2 * X4 * Y1 + E4 * H4^2 * X4 * Y2 + E4 * H4^2 * X4 * Y3 + E4 * H4^2 * X4 * Y4 + 2 * E4 * H4 * Y1 * Y4 + E4 * H4 * Y2 * Y3 + E4 * H4 * Y2 * Y4 + E4 * H4 * Y3 * Y4 + E4 * H4 * Y4^2 - 2 * H3^2 - 4 * H3 * H4 * X4 - H3 * Y1 - H3 * Y2 - H3 * Y3 - 5 * H3 * Y4 + H4^2 * X2 * X3 - H4^2 * X2 * X4 - H4^2 * X3 * X4 - H4^2 * X4^2 + H4 * X2 * Y3 - H4 * X2 * Y4 + H4 * X3 * Y2 - H4 * X3 * Y4 - H4 * X4 * Y1 - 2 * H4 * X4 * Y2 - 2 * H4 * X4 * Y3 - 3 * H4 * X4 * Y4 - 2 * Y1 * Y4 - 2 * Y2 * Y4 - 2 * Y3 * Y4 - 2 * Y4^2, U23 * U24 * E4 * H2 + U23 * U24 * E4 * H4 * Y2 - U23 * U24 * H4 * X1 + U23 * U24 * H4 * X4 - U23 * U24 * Y1 - U23 * U24 * Y2 + U23 * U24 * Y3 + U23 * U24 * Y4 + U23 * U34 * V24 * E4 * H4 * Y2^2 - U23 * U34 * V24 * E4 * H4 * Y2 * Y3 - U23 * U34 * V24 * E4 * H4 * Y2 * Y4 + U23 * U34 * V24 * E4 * H4 * Y3 * Y4 - 2 * U23 * U34 * V24 * Y2^2 + 2 * U23 * U34 * V24 * Y2 * Y3 + 2 * U23 * U34 * V24 * Y2 * Y4 - 2 * U23 * U34 * V24 * Y3 * Y4 - U23 * U34 * E4 * H2 - U23 * U34 * E4 * H4 * Y2 + U23 * U34 * H4 * X1 - U23 * U34 * H4 * X4 + U23 * U34 * Y1 + U23 * U34 * Y2 - U23 * U34 * Y3 - U23 * U34 * Y4 - 2 * U23 * V24 * V34 * H2 * Y2 + 2 * U23 * V24 * V34 * H2 * Y3 + U23 * V24 * V34 * H4^2 * X1 * Y2 - U23 * V24 * V34 * H4^2 * X1 * Y3 - U23 * V24 * V34 * H4^2 * X3 * Y2 + U23 * V24 * V34 * H4^2 * X3 * Y3 + U23 * V24 * V34 * H4 * Y1 * Y2 - U23 * V24 * V34 * H4 * Y1 * Y3 - U23 * V24 * V34 * H4 * Y2^2 - U23 * V24 * V34 * H4 * Y2 * Y4 + U23 * V24 * V34 * H4 * Y3^2 + U23 * V24 * V34 * H4 * Y3 * Y4 - 2 * U23 * V24 * H2 + U23 * V24 * H3 * H4 + U23 * V24 * H4^2 * X1 + U23 * V24 * H4 * Y1 - U23 * V24 * H4 * Y2 + 2 * U23 * V34 * H2 - U23 * V34 * H3 * H4 - U23 * V34 * H4^2 * X1 - U23 * V34 * H4 * Y1 + U23 * V34 * H4 * Y3 - U24 * U34 * V23 * E4 * H4 * Y2^2 + U24 * U34 * V23 * E4 * H4 * Y2 * Y3 + U24 * U34 * V23 * E4 * H4 * Y2 * Y4 - U24 * U34 * V23 * E4 * H4 * Y3 * Y4 + 2 * U24 * U34 * V23 * Y2^2 - 2 * U24 * U34 * V23 * Y2 * Y3 - 2 * U24 * U34 * V23 * Y2 * Y4 + 2 * U24 * U34 * V23 * Y3 * Y4 + U24 * U34 * E4 * H2 + U24 * U34 * E4 * H4 * Y2 - U24 * U34 * H4 * X1 + U24 * U34 * H4 * X4 - U24 * U34 * Y1 - U24 * U34 * Y2 + U24 * U34 * Y3 + U24 * U34 * Y4 + 2 * U24 * V23 * V34 * H2 * Y2 - 2 * U24 * V23 * V34 * H2 * Y4 - U24 * V23 * V34 * H4^2 * X1 * Y2 + U24 * V23 * V34 * H4^2 * X1 * Y4 + U24 * V23 * V34 * H4^2 * X4 * Y2 - U24 * V23 * V34 * H4^2 * X4 * Y4 - U24 * V23 * V34 * H4 * Y1 * Y2 + U24 * V23 * V34 * H4 * Y1 * Y4 + U24 * V23 * V34 * H4 * Y2^2 + U24 * V23 * V34 * H4 * Y2 * Y3 - U24 * V23 * V34 * H4 * Y3 * Y4 - U24 * V23 * V34 * H4 * Y4^2 - 2 * U24 * V23 * H2 + U24 * V23 * H3 * H4 + U24 * V23 * H4^2 * X1 + U24 * V23 * H4 * Y1 - U24 * V23 * H4 * Y3 - 2 * U24 * V34 * H2 + U24 * V34 * H3 * H4 + U24 * V34 * H4^2 * X1 + U24 * V34 * H4 * Y1 - U24 * V34 * H4 * Y3 - 2 * U34 * V23 * V24 * H2 * Y3 + 2 * U34 * V23 * V24 * H2 * Y4 + U34 * V23 * V24 * H4^2 * X1 * Y3 - U34 * V23 * V24 * H4^2 * X1 * Y4 - U34 * V23 * V24 * H4^2 * X4 * Y3 + U34 * V23 * V24 * H4^2 * X4 * Y4 + U34 * V23 * V24 * H4 * Y1 * Y3 - U34 * V23 * V24 * H4 * Y1 * Y4 - U34 * V23 * V24 * H4 * Y2 * Y3 + U34 * V23 * V24 * H4 * Y2 * Y4 - U34 * V23 * V24 * H4 * Y3^2 + U34 * V23 * V24 * H4 * Y4^2 + 2 * U34 * V23 * H2 - U34 * V23 * H3 * H4 - U34 * V23 * H4^2 * X1 - U34 * V23 * H4 * Y1 + U34 * V23 * H4 * Y2 - 2 * U34 * V24 * H2 + U34 * V24 * H3 * H4 + U34 * V24 * H4^2 * X1 + U34 * V24 * H4 * Y1 - U34 * V24 * H4 * Y2 - V23 * V24 * V34 * H4^2 * Y2 * Y3 + V23 * V24 * V34 * H4^2 * Y2 * Y4 + V23 * V24 * V34 * H4^2 * Y3^2 - V23 * V24 * V34 * H4^2 * Y3 * Y4 - V23 * V24 * H2 * H4 - V23 * V24 * H4^2 * Y3 + V23 * V34 * H2 * H4 + V23 * V34 * H4^2 * Y2 - V24 * V34 * H2 * H4 - V24 * V34 * H4^2 * Y2, U13 * U14 * E4 * H2 + U13 * U14 * E4 * H4 * Y2 - U13 * U14 * Y1 - U13 * U14 * Y2 + U13 * U14 * Y3 + U13 * U14 * Y4 - 2 * U13 * U34 * V14 * Y1^2 + 2 * U13 * U34 * V14 * Y1 * Y3 + 2 * U13 * U34 * V14 * Y1 * Y4 - 2 * U13 * U34 * V14 * Y3 * Y4 - U13 * U34 * E4 * H2 - U13 * U34 * E4 * H4 * Y2 + U13 * U34 * Y1 + U13 * U34 * Y2 - U13 * U34 * Y3 - U13 * U34 * Y4 - 2 * U13 * V14 * V34 * H2 * Y1 + 2 * U13 * V14 * V34 * H2 * Y3 - 2 * U13 * V14 * V34 * H4 * Y1 * Y4 + 2 * U13 * V14 * V34 * H4 * Y3 * Y4 - 2 * U13 * V14 * H2 + U13 * V14 * H3 * H4 + U13 * V14 * H4^2 * X3 + U13 * V14 * H4 * Y3 - U13 * V14 * H4 * Y4 + 2 * U13 * V34 * H2 - U13 * V34 * H3 * H4 - U13 * V34 * H4^2 * X3 - U13 * V34 * H4 * Y1 + U13 * V34 * H4 * Y4 + 2 * U14 * U34 * V13 * Y1^2 - 2 * U14 * U34 * V13 * Y1 * Y3 - 2 * U14 * U34 * V13 * Y1 * Y4 + 2 * U14 * U34 * V13 * Y3 * Y4 + U14 * U34 * E4 * H2 + U14 * U34 * E4 * H4 * Y2 - U14 * U34 * Y1 - U14 * U34 * Y2 + U14 * U34 * Y3 + U14 * U34 * Y4 + 2 * U14 * V13 * V34 * H2 * Y1 - 2 * U14 * V13 * V34 * H2 * Y4 + 2 * U14 * V13 * V34 * H4 * Y1 * Y3 - 2 * U14 * V13 * V34 * H4 * Y3 * Y4 - 2 * U14 * V13 * H2 + U14 * V13 * H3 * H4 + U14 * V13 * H4^2 * X4 - U14 * V13 * H4 * Y3 + U14 * V13 * H4 * Y4 - 2 * U14 * V34 * H2 + U14 * V34 * H3 * H4 + U14 * V34 * H4^2 * X4 + U14 * V34 * H4 * Y1 - U14 * V34 * H4 * Y3 - 2 * U34 * V13 * V14 * H2 * Y3 + 2 * U34 * V13 * V14 * H2 * Y4 - 2 * U34 * V13 * V14 * H4 * Y1 * Y3 + 2 * U34 * V13 * V14 * H4 * Y1 * Y4 + 2 * U34 * V13 * H2 - U34 * V13 * H3 * H4 - U34 * V13 * H4^2 * X4 + U34 * V13 * H4 * Y1 - U34 * V13 * H4 * Y4 - 2 * U34 * V14 * H2 + U34 * V14 * H3 * H4 + U34 * V14 * H4^2 * X4 - U34 * V14 * H4 * Y1 + U34 * V14 * H4 * Y3 - V13 * V14 * H2 * H4 - V13 * V14 * H4^2 * Y1 + V13 * V34 * H2 * H4 + V13 * V34 * H4^2 * Y1 - V14 * V34 * H2 * H4 - V14 * V34 * H4^2 * Y1 - V14 * V34 * H4^2 * Y3 + V14 * V34 * H4^2 * Y4 + V14 * H4^2, U13 * U14 * U23 * V24 - U13 * U14 * U23 * V34 + U13 * U14 * U24 * V23 * V24 * Y2 - U13 * U14 * U24 * V23 * V24 * Y3 - U13 * U14 * U24 * V23 * V34 * Y2 + U13 * U14 * U24 * V23 * V34 * Y4 + U13 * U14 * U24 * V23 + U13 * U14 * U24 * V24 * V34 * Y2 - U13 * U14 * U24 * V24 * V34 * Y4 - U13 * U14 * U24 * V24 + U13 * U14 * U24 * V34 - U13 * U14 * V23 * V24^2 * H2 - U13 * U14 * V23 * V24^2 * H4 * Y2 + U13 * U14 * V23 * V24 * V34 * H2 + U13 * U14 * V23 * V24 * V34 * H4 * Y2 - U13 * U14 * V24^2 * V34 * H2 - U13 * U14 * V24^2 * V34 * H4 * Y2 - U13 * U23 * U24 * V14 * V24 * V34 * Y1 * Y2 + U13 * U23 * U24 * V14 * V24 * V34 * Y1 * Y4 + U13 * U23 * U24 * V14 * V24 * V34 * Y2 * Y4 - U13 * U23 * U24 * V14 * V24 * V34 * Y4^2 + U13 * U23 * U24 * V14 * V24 * Y1 - U13 * U23 * U24 * V14 * V24 * Y4 - U13 * U23 * U24 * V14 * V34 * Y1 + U13 * U23 * U24 * V14 * V34 * Y4 + U13 * U23 * U24 * V24 * V34 * Y2 - U13 * U23 * U24 * V24 * V34 * Y4 - U13 * U23 * U24 * V24 + U13 * U23 * U24 * V34 - U13 * U23 * U34 * V14 * V24^2 * V34 * Y1 * Y2^2 + U13 * U23 * U34 * V14 * V24^2 * V34 * Y1 * Y2 * Y3 + U13 * U23 * U34 * V14 * V24^2 * V34 * Y1 * Y2 * Y4 - U13 * U23 * U34 * V14 * V24^2 * V34 * Y1 * Y3 * Y4 + U13 * U23 * U34 * V14 * V24^2 * V34 * Y2^2 * Y4 - U13 * U23 * U34 * V14 * V24^2 * V34 * Y2 * Y3 * Y4 - U13 * U23 * U34 * V14 * V24^2 * V34 * Y2 * Y4^2 + U13 * U23 * U34 * V14 * V24^2 * V34 * Y3 * Y4^2 + U13 * U23 * U34 * V14 * V24^2 * Y1 * Y2 - U13 * U23 * U34 * V14 * V24^2 * Y1 * Y4 - U13 * U23 * U34 * V14 * V24^2 * Y2 * Y4 + U13 * U23 * U34 * V14 * V24^2 * Y4^2 + U13 * U23 * U34 * V24^2 * V34 * Y2^2 - U13 * U23 * U34 * V24^2 * V34 * Y2 * Y3 - U13 * U23 * U34 * V24^2 * V34 * Y2 * Y4 + U13 * U23 * U34 * V24^2 * V34 * Y3 * Y4 - U13 * U23 * U34 * V24^2 * Y2 + U13 * U23 * U34 * V24^2 * Y4 - U13 * U23 * V14 * V24^2 * V34^2 * H2 * Y1 * Y2 + U13 * U23 * V14 * V24^2 * V34^2 * H2 * Y1 * Y3 + U13 * U23 * V14 * V24^2 * V34^2 * H2 * Y2 * Y4 - U13 * U23 * V14 * V24^2 * V34^2 * H2 * Y3 * Y4 - U13 * U23 * V14 * V24^2 * V34^2 * H4 * Y1 * Y2 * Y4 + U13 * U23 * V14 * V24^2 * V34^2 * H4 * Y1 * Y3 * Y4 + U13 * U23 * V14 * V24^2 * V34^2 * H4 * Y2 * Y4^2 - U13 * U23 * V14 * V24^2 * V34^2 * H4 * Y3 * Y4^2 + U13 * U23 * V24^2 * V34^2 * H2 * Y2 - U13 * U23 * V24^2 * V34^2 * H2 * Y3 + U13 * U23 * V24^2 * V34^2 * H4 * Y2 * Y4 - U13 * U23 * V24^2 * V34^2 * H4 * Y3 * Y4 + U13 * U24 * U34 * V14 * V23 * V24 * V34 * Y1 * Y2^2 - U13 * U24 * U34 * V14 * V23 * V24 * V34 * Y1 * Y2 * Y3 - U13 * U24 * U34 * V14 * V23 * V24 * V34 * Y1 * Y2 * Y4 + U13 * U24 * U34 * V14 * V23 * V24 * V34 * Y1 * Y3 * Y4 - U13 * U24 * U34 * V14 * V23 * V24 * V34 * Y2^2 * Y4 + U13 * U24 * U34 * V14 * V23 * V24 * V34 * Y2 * Y3 * Y4 + U13 * U24 * U34 * V14 * V23 * V24 * V34 * Y2 * Y4^2 - U13 * U24 * U34 * V14 * V23 * V24 * V34 * Y3 * Y4^2 + U13 * U24 * U34 * V14 * V23 * Y1 - U13 * U24 * U34 * V14 * V23 * Y4 - U13 * U24 * U34 * V23 * V24 * V34 * Y2^2 + U13 * U24 * U34 * V23 * V24 * V34 * Y2 * Y3 + U13 * U24 * U34 * V23 * V24 * V34 * Y2 * Y4 - U13 * U24 * U34 * V23 * V24 * V34 * Y3 * Y4 - U13 * U24 * U34 * V23 + U13 * U24 * V14 * V23 * V24 * V34^2 * H2 * Y1 * Y2 - U13 * U24 * V14 * V23 * V24 * V34^2 * H2 * Y1 * Y4 - U13 * U24 * V14 * V23 * V24 * V34^2 * H2 * Y2 * Y4 + U13 * U24 * V14 * V23 * V24 * V34^2 * H2 * Y4^2 + U13 * U24 * V14 * V23 * V24 * V34^2 * H4 * Y1 * Y2 * Y3 - U13 * U24 * V14 * V23 * V24 * V34^2 * H4 * Y1 * Y3 * Y4 - U13 * U24 * V14 * V23 * V24 * V34^2 * H4 * Y2 * Y3 * Y4 + U13 * U24 * V14 * V23 * V24 * V34^2 * H4 * Y3 * Y4^2 - U13 * U24 * V23 * V24 * V34^2 * H2 * Y2 + U13 * U24 * V23 * V24 * V34^2 * H2 * Y4 - U13 * U24 * V23 * V24 * V34^2 * H4 * Y2 * Y3 + U13 * U24 * V23 * V24 * V34^2 * H4 * Y3 * Y4 - U13 * U34 * V14 * V23 * V24^2 * V34 * H2 * Y1 * Y3 + U13 * U34 * V14 * V23 * V24^2 * V34 * H2 * Y1 * Y4 + U13 * U34 * V14 * V23 * V24^2 * V34 * H2 * Y3 * Y4 - U13 * U34 * V14 * V23 * V24^2 * V34 * H2 * Y4^2 - U13 * U34 * V14 * V23 * V24^2 * V34 * H4 * Y1 * Y2 * Y3 + U13 * U34 * V14 * V23 * V24^2 * V34 * H4 * Y1 * Y2 * Y4 + U13 * U34 * V14 * V23 * V24^2 * V34 * H4 * Y2 * Y3 * Y4 - U13 * U34 * V14 * V23 * V24^2 * V34 * H4 * Y2 * Y4^2 - U13 * U34 * V14 * V23 * V24^2 * H2 * Y1 + U13 * U34 * V14 * V23 * V24^2 * H2 * Y4 - U13 * U34 * V14 * V23 * V24^2 * H4 * Y1 * Y2 + U13 * U34 * V14 * V23 * V24^2 * H4 * Y2 * Y4 + U13 * U34 * V14 * V23 * V24 * V34 * H2 * Y1 - U13 * U34 * V14 * V23 * V24 * V34 * H2 * Y4 + U13 * U34 * V14 * V23 * V24 * V34 * H4 * Y1 * Y2 - U13 * U34 * V14 * V23 * V24 * V34 * H4 * Y2 * Y4 - U13 * U34 * V14 * V24^2 * V34 * H2 * Y1 + U13 * U34 * V14 * V24^2 * V34 * H2 * Y4 - U13 * U34 * V14 * V24^2 * V34 * H4 * Y1 * Y2 + U13 * U34 * V14 * V24^2 * V34 * H4 * Y2 * Y4 + U13 * U34 * V23 * V24^2 * V34 * H2 * Y3 - U13 * U34 * V23 * V24^2 * V34 * H2 * Y4 + U13 * U34 * V23 * V24^2 * V34 * H4 * Y2 * Y3 - U13 * U34 * V23 * V24^2 * V34 * H4 * Y2 * Y4 + U13 * U34 * V23 * V24^2 * H2 + U13 * U34 * V23 * V24^2 * H4 * Y2 - U13 * U34 * V23 * V24 * V34 * H2 - U13 * U34 * V23 * V24 * V34 * H4 * Y2 + U13 * U34 * V24^2 * V34 * H2 + U13 * U34 * V24^2 * V34 * H4 * Y2 + U14 * U23 * U24 * V13 * V24 * V34 * Y1 * Y2 - U14 * U23 * U24 * V13 * V24 * V34 * Y1 * Y4 - U14 * U23 * U24 * V13 * V24 * V34 * Y2 * Y4 + U14 * U23 * U24 * V13 * V24 * V34 * Y4^2 - U14 * U23 * U24 * V13 * V24 * Y1 - U14 * U23 * U24 * V13 * V24 * Y2 + U14 * U23 * U24 * V13 * V24 * Y3 + U14 * U23 * U24 * V13 * V24 * Y4 + U14 * U23 * U24 * V13 * V34 * Y1 - U14 * U23 * U24 * V13 * V34 * Y4 - U14 * U23 * U24 * V13 - U14 * U23 * U24 * V24 * V34 * Y2 + U14 * U23 * U24 * V24 * V34 * Y4 + U14 * U23 * U24 * V24 - U14 * U23 * U24 * V34 + U14 * U23 * U34 * V13 * V24^2 * V34 * Y1 * Y2^2 - U14 * U23 * U34 * V13 * V24^2 * V34 * Y1 * Y2 * Y3 - U14 * U23 * U34 * V13 * V24^2 * V34 * Y1 * Y2 * Y4 + U14 * U23 * U34 * V13 * V24^2 * V34 * Y1 * Y3 * Y4 - U14 * U23 * U34 * V13 * V24^2 * V34 * Y2^2 * Y4 + U14 * U23 * U34 * V13 * V24^2 * V34 * Y2 * Y3 * Y4 + U14 * U23 * U34 * V13 * V24^2 * V34 * Y2 * Y4^2 - U14 * U23 * U34 * V13 * V24^2 * V34 * Y3 * Y4^2 - U14 * U23 * U34 * V13 * V24^2 * Y1 * Y2 + U14 * U23 * U34 * V13 * V24^2 * Y1 * Y4 - U14 * U23 * U34 * V13 * V24^2 * Y2^2 + U14 * U23 * U34 * V13 * V24^2 * Y2 * Y3 + 2 * U14 * U23 * U34 * V13 * V24^2 * Y2 * Y4 - U14 * U23 * U34 * V13 * V24^2 * Y3 * Y4 - U14 * U23 * U34 * V13 * V24^2 * Y4^2 + U14 * U23 * U34 * V13 - U14 * U23 * U34 * V24^2 * V34 * Y2^2 + U14 * U23 * U34 * V24^2 * V34 * Y2 * Y3 + U14 * U23 * U34 * V24^2 * V34 * Y2 * Y4 - U14 * U23 * U34 * V24^2 * V34 * Y3 * Y4 + U14 * U23 * U34 * V24^2 * Y2 - U14 * U23 * U34 * V24^2 * Y4 + U14 * U23 * V13 * V24^2 * V34^2 * H2 * Y1 * Y2 - U14 * U23 * V13 * V24^2 * V34^2 * H2 * Y1 * Y3 - U14 * U23 * V13 * V24^2 * V34^2 * H2 * Y2 * Y4 + U14 * U23 * V13 * V24^2 * V34^2 * H2 * Y3 * Y4 + U14 * U23 * V13 * V24^2 * V34^2 * H4 * Y1 * Y2 * Y4 - U14 * U23 * V13 * V24^2 * V34^2 * H4 * Y1 * Y3 * Y4 - U14 * U23 * V13 * V24^2 * V34^2 * H4 * Y2 * Y4^2 + U14 * U23 * V13 * V24^2 * V34^2 * H4 * Y3 * Y4^2 - U14 * U23 * V13 * V24^2 * V34 * H2 * Y2 + U14 * U23 * V13 * V24^2 * V34 * H2 * Y3 - U14 * U23 * V13 * V24^2 * V34 * H4 * Y2 * Y4 + U14 * U23 * V13 * V24^2 * V34 * H4 * Y3 * Y4 - U14 * U23 * V24^2 * V34^2 * H2 * Y2 + U14 * U23 * V24^2 * V34^2 * H2 * Y3 - U14 * U23 * V24^2 * V34^2 * H4 * Y2 * Y4 + U14 * U23 * V24^2 * V34^2 * H4 * Y3 * Y4 - U14 * U24 * U34 * V13 * V23 * V24 * V34 * Y1 * Y2^2 + U14 * U24 * U34 * V13 * V23 * V24 * V34 * Y1 * Y2 * Y3 + U14 * U24 * U34 * V13 * V23 * V24 * V34 * Y1 * Y2 * Y4 - U14 * U24 * U34 * V13 * V23 * V24 * V34 * Y1 * Y3 * Y4 + U14 * U24 * U34 * V13 * V23 * V24 * V34 * Y2^2 * Y4 - U14 * U24 * U34 * V13 * V23 * V24 * V34 * Y2 * Y3 * Y4 - U14 * U24 * U34 * V13 * V23 * V24 * V34 * Y2 * Y4^2 + U14 * U24 * U34 * V13 * V23 * V24 * V34 * Y3 * Y4^2 + U14 * U24 * U34 * V13 * V23 * V24 * Y2^2 - U14 * U24 * U34 * V13 * V23 * V24 * Y2 * Y3 - U14 * U24 * U34 * V13 * V23 * V24 * Y2 * Y4 + U14 * U24 * U34 * V13 * V23 * V24 * Y3 * Y4 - U14 * U24 * U34 * V13 * V23 * Y1 + U14 * U24 * U34 * V13 * V23 * Y2 - U14 * U24 * U34 * V13 * V24 * Y2 + U14 * U24 * U34 * V13 * V24 * Y4 - U14 * U24 * U34 * V13 + U14 * U24 * U34 * V23 * V24 * V34 * Y2^2 - U14 * U24 * U34 * V23 * V24 * V34 * Y2 * Y3 - U14 * U24 * U34 * V23 * V24 * V34 * Y2 * Y4 + U14 * U24 * U34 * V23 * V24 * V34 * Y3 * Y4 + U14 * U24 * U34 * V23 - U14 * U24 * V13 * V23 * V24 * V34^2 * H2 * Y1 * Y2 + U14 * U24 * V13 * V23 * V24 * V34^2 * H2 * Y1 * Y4 + U14 * U24 * V13 * V23 * V24 * V34^2 * H2 * Y2 * Y4 - U14 * U24 * V13 * V23 * V24 * V34^2 * H2 * Y4^2 - U14 * U24 * V13 * V23 * V24 * V34^2 * H4 * Y1 * Y2 * Y3 + U14 * U24 * V13 * V23 * V24 * V34^2 * H4 * Y1 * Y3 * Y4 + U14 * U24 * V13 * V23 * V24 * V34^2 * H4 * Y2 * Y3 * Y4 - U14 * U24 * V13 * V23 * V24 * V34^2 * H4 * Y3 * Y4^2 + U14 * U24 * V13 * V23 * V24 * V34 * H2 * Y2 - U14 * U24 * V13 * V23 * V24 * V34 * H2 * Y4 + U14 * U24 * V13 * V23 * V24 * V34 * H4 * Y2 * Y3 - U14 * U24 * V13 * V23 * V24 * V34 * H4 * Y3 * Y4 + U14 * U24 * V23 * V24 * V34^2 * H2 * Y2 - U14 * U24 * V23 * V24 * V34^2 * H2 * Y4 + U14 * U24 * V23 * V24 * V34^2 * H4 * Y2 * Y3 - U14 * U24 * V23 * V24 * V34^2 * H4 * Y3 * Y4 + U14 * U34 * V13 * V23 * V24^2 * V34 * H2 * Y1 * Y3 - U14 * U34 * V13 * V23 * V24^2 * V34 * H2 * Y1 * Y4 - U14 * U34 * V13 * V23 * V24^2 * V34 * H2 * Y3 * Y4 + U14 * U34 * V13 * V23 * V24^2 * V34 * H2 * Y4^2 + U14 * U34 * V13 * V23 * V24^2 * V34 * H4 * Y1 * Y2 * Y3 - U14 * U34 * V13 * V23 * V24^2 * V34 * H4 * Y1 * Y2 * Y4 - U14 * U34 * V13 * V23 * V24^2 * V34 * H4 * Y2 * Y3 * Y4 + U14 * U34 * V13 * V23 * V24^2 * V34 * H4 * Y2 * Y4^2 + U14 * U34 * V13 * V23 * V24^2 * H2 * Y1 - U14 * U34 * V13 * V23 * V24^2 * H2 * Y3 + U14 * U34 * V13 * V23 * V24^2 * H4 * Y1 * Y2 - U14 * U34 * V13 * V23 * V24^2 * H4 * Y2 * Y3 - U14 * U34 * V13 * V23 * V24 * V34 * H2 * Y1 + U14 * U34 * V13 * V23 * V24 * V34 * H2 * Y4 - U14 * U34 * V13 * V23 * V24 * V34 * H4 * Y1 * Y2 + U14 * U34 * V13 * V23 * V24 * V34 * H4 * Y2 * Y4 + U14 * U34 * V13 * V24^2 * V34 * H2 * Y1 - U14 * U34 * V13 * V24^2 * V34 * H2 * Y4 + U14 * U34 * V13 * V24^2 * V34 * H4 * Y1 * Y2 - U14 * U34 * V13 * V24^2 * V34 * H4 * Y2 * Y4 - U14 * U34 * V23 * V24^2 * V34 * H2 * Y3 + U14 * U34 * V23 * V24^2 * V34 * H2 * Y4 - U14 * U34 * V23 * V24^2 * V34 * H4 * Y2 * Y3 + U14 * U34 * V23 * V24^2 * V34 * H4 * Y2 * Y4 - U14 * U34 * V23 * V24^2 * H2 - U14 * U34 * V23 * V24^2 * H4 * Y2 + U14 * U34 * V23 * V24 * V34 * H2 + U14 * U34 * V23 * V24 * V34 * H4 * Y2 - U14 * U34 * V24^2 * V34 * H2 - U14 * U34 * V24^2 * V34 * H4 * Y2, U12 * U14 * V24 * E4 * Y3^2 - 2 * U12 * U14 * V24 * E4 * Y3 * Y4 + U12 * U14 * V24 * E4 * Y4^2 + U12 * U14 * V24 * X3 * Y1 + U12 * U14 * V24 * X3 * Y3 - 2 * U12 * U14 * V24 * X3 * Y4 - U12 * U14 * V24 * X4 * Y1 - U12 * U14 * V24 * X4 * Y3 + 2 * U12 * U14 * V24 * X4 * Y4 - U12 * U14 * E4 * Y3 + U12 * U14 * E4 * Y4 - U12 * U14 * X3 + U12 * U14 * X4 + U12 * U24 * V14 * V24 * X3 * Y1^2 - U12 * U24 * V14 * V24 * X3 * Y1 * Y2 - U12 * U24 * V14 * V24 * X3 * Y1 * Y4 + U12 * U24 * V14 * V24 * X3 * Y2 * Y4 - U12 * U24 * V14 * V24 * X4 * Y1^2 + U12 * U24 * V14 * V24 * X4 * Y1 * Y2 + U12 * U24 * V14 * V24 * X4 * Y1 * Y4 - U12 * U24 * V14 * V24 * X4 * Y2 * Y4 - U12 * U24 * V14 * E4 * Y2 * Y3 + U12 * U24 * V14 * E4 * Y2 * Y4 + U12 * U24 * V14 * E4 * Y3 * Y4 - U12 * U24 * V14 * E4 * Y4^2 - U12 * U24 * V14 * X3 * Y2 + U12 * U24 * V14 * X3 * Y4 + U12 * U24 * V14 * X4 * Y2 - U12 * U24 * V14 * X4 * Y4 + U12 * U24 * V24 * E4 * Y2 * Y3 - U12 * U24 * V24 * E4 * Y2 * Y4 - U12 * U24 * V24 * E4 * Y3^2 + U12 * U24 * V24 * E4 * Y3 * Y4 - U12 * U24 * V24 * X3 * Y1 + U12 * U24 * V24 * X3 * Y2 - U12 * U24 * V24 * X3 * Y3 + U12 * U24 * V24 * X3 * Y4 + U12 * U24 * V24 * X4 * Y1 - U12 * U24 * V24 * X4 * Y2 + U12 * U24 * V24 * X4 * Y3 - U12 * U24 * V24 * X4 * Y4 + U12 * U24 * E4 * Y3 - U12 * U24 * E4 * Y4 + U12 * U24 * X3 - U12 * U24 * X4 + U12 * V14 * V24^2 * H4 * X2 * Y1 * Y3 - U12 * V14 * V24^2 * H4 * X2 * Y1 * Y4 - U12 * V14 * V24^2 * H4 * X2 * Y2 * Y3 + U12 * V14 * V24^2 * H4 * X2 * Y2 * Y4 - U12 * V14 * V24^2 * H4 * X3 * Y1 * Y3 + U12 * V14 * V24^2 * H4 * X3 * Y1 * Y4 + U12 * V14 * V24^2 * H4 * X3 * Y2 * Y3 - U12 * V14 * V24^2 * H4 * X3 * Y2 * Y4 + U12 * V14 * V24^2 * Y1^2 * Y3 - U12 * V14 * V24^2 * Y1^2 * Y4 - U12 * V14 * V24^2 * Y1 * Y3^2 + U12 * V14 * V24^2 * Y1 * Y4^2 - U12 * V14 * V24^2 * Y2^2 * Y3 + U12 * V14 * V24^2 * Y2^2 * Y4 + U12 * V14 * V24^2 * Y2 * Y3^2 - U12 * V14 * V24^2 * Y2 * Y4^2 + U12 * V14 * V24 * H4 * X2 * Y3 - U12 * V14 * V24 * H4 * X2 * Y4 - U12 * V14 * V24 * H4 * X3 * Y3 + U12 * V14 * V24 * H4 * X3 * Y4 + U12 * V14 * V24 * Y1 * Y3 - U12 * V14 * V24 * Y1 * Y4 + U12 * V14 * V24 * Y2 * Y3 - U12 * V14 * V24 * Y2 * Y4 - U12 * V14 * V24 * Y3^2 + U12 * V14 * V24 * Y4^2 - U12 * V24^2 * H4 * X2 * Y3 + U12 * V24^2 * H4 * X2 * Y4 + U12 * V24^2 * H4 * X3 * Y3 - U12 * V24^2 * H4 * X3 * Y4 - U12 * V24^2 * Y1 * Y3 + U12 * V24^2 * Y1 * Y4 - U12 * V24^2 * Y2 * Y3 + U12 * V24^2 * Y2 * Y4 + U12 * V24^2 * Y3^2 - U12 * V24^2 * Y4^2 - U14 * U24 * V12 * V24 * X3 * Y1^2 + U14 * U24 * V12 * V24 * X3 * Y1 * Y2 + U14 * U24 * V12 * V24 * X3 * Y1 * Y4 - U14 * U24 * V12 * V24 * X3 * Y2 * Y4 + U14 * U24 * V12 * V24 * X4 * Y1^2 - U14 * U24 * V12 * V24 * X4 * Y1 * Y2 - U14 * U24 * V12 * V24 * X4 * Y1 * Y4 + U14 * U24 * V12 * V24 * X4 * Y2 * Y4 - U14 * U24 * V24 * E4 * Y2 * Y3 + U14 * U24 * V24 * E4 * Y2 * Y4 + U14 * U24 * V24 * E4 * Y3^2 - U14 * U24 * V24 * E4 * Y3 * Y4 + U14 * U24 * V24 * X3 * Y1 - U14 * U24 * V24 * X3 * Y2 + U14 * U24 * V24 * X3 * Y3 - U14 * U24 * V24 * X3 * Y4 - U14 * U24 * V24 * X4 * Y1 + U14 * U24 * V24 * X4 * Y2 - U14 * U24 * V24 * X4 * Y3 + U14 * U24 * V24 * X4 * Y4 - U14 * U24 * E4 * Y3 + U14 * U24 * E4 * Y4 - U14 * U24 * X3 + U14 * U24 * X4 - U14 * V12 * V24^2 * H4 * X3 * Y1 * Y2 + U14 * V12 * V24^2 * H4 * X3 * Y1 * Y3 + U14 * V12 * V24^2 * H4 * X3 * Y2 * Y4 - U14 * V12 * V24^2 * H4 * X3 * Y3 * Y4 + U14 * V12 * V24^2 * H4 * X4 * Y1 * Y2 - U14 * V12 * V24^2 * H4 * X4 * Y1 * Y3 - U14 * V12 * V24^2 * H4 * X4 * Y2 * Y4 + U14 * V12 * V24^2 * H4 * X4 * Y3 * Y4 - U14 * V12 * V24^2 * Y1^2 * Y3 + U14 * V12 * V24^2 * Y1^2 * Y4 + U14 * V12 * V24^2 * Y1 * Y3^2 - U14 * V12 * V24^2 * Y1 * Y4^2 - U14 * V12 * V24^2 * Y3^2 * Y4 + U14 * V12 * V24^2 * Y3 * Y4^2 - U14 * V12 * V24 * H4 * X3 * Y3 + U14 * V12 * V24 * H4 * X3 * Y4 + U14 * V12 * V24 * H4 * X4 * Y3 - U14 * V12 * V24 * H4 * X4 * Y4 - U14 * V12 * V24 * Y3^2 + 2 * U14 * V12 * V24 * Y3 * Y4 - U14 * V12 * V24 * Y4^2 + U14 * V12 * H4 * X3 - U14 * V12 * H4 * X4 + U14 * V12 * Y3 - U14 * V12 * Y4 + U14 * V24^2 * H4 * X3 * Y2 - U14 * V24^2 * H4 * X3 * Y3 - U14 * V24^2 * H4 * X4 * Y2 + U14 * V24^2 * H4 * X4 * Y3 + U14 * V24^2 * Y1 * Y3 - U14 * V24^2 * Y1 * Y4 + U14 * V24^2 * Y2 * Y3 - U14 * V24^2 * Y2 * Y4 - U14 * V24^2 * Y3^2 + U14 * V24^2 * Y4^2 + U24 * V12 * V14 * V24 * H4 * X3 * Y1 * Y2 - U24 * V12 * V14 * V24 * H4 * X3 * Y1 * Y4 - U24 * V12 * V14 * V24 * H4 * X3 * Y2 * Y3 + U24 * V12 * V14 * V24 * H4 * X3 * Y3 * Y4 - U24 * V12 * V14 * V24 * H4 * X4 * Y1 * Y2 + U24 * V12 * V14 * V24 * H4 * X4 * Y1 * Y4 + U24 * V12 * V14 * V24 * H4 * X4 * Y2 * Y3 - U24 * V12 * V14 * V24 * H4 * X4 * Y3 * Y4 + U24 * V12 * V14 * V24 * Y2^2 * Y3 - U24 * V12 * V14 * V24 * Y2^2 * Y4 - U24 * V12 * V14 * V24 * Y2 * Y3^2 + U24 * V12 * V14 * V24 * Y2 * Y4^2 + U24 * V12 * V14 * V24 * Y3^2 * Y4 - U24 * V12 * V14 * V24 * Y3 * Y4^2 + U24 * V12 * V14 * H4 * X3 * Y2 - U24 * V12 * V14 * H4 * X3 * Y4 - U24 * V12 * V14 * H4 * X4 * Y2 + U24 * V12 * V14 * H4 * X4 * Y4 + U24 * V12 * V14 * Y2 * Y3 - U24 * V12 * V14 * Y2 * Y4 - U24 * V12 * V14 * Y3 * Y4 + U24 * V12 * V14 * Y4^2 - U24 * V12 * V24 * H4 * X3 * Y2 + U24 * V12 * V24 * H4 * X3 * Y3 + U24 * V12 * V24 * H4 * X4 * Y2 - U24 * V12 * V24 * H4 * X4 * Y3 - U24 * V12 * V24 * Y2 * Y3 + U24 * V12 * V24 * Y2 * Y4 + U24 * V12 * V24 * Y3^2 - U24 * V12 * V24 * Y3 * Y4 - U24 * V12 * H4 * X3 + U24 * V12 * H4 * X4 - U24 * V12 * Y3 + U24 * V12 * Y4 - U24 * V14 * V24 * H4 * X3 * Y3 + U24 * V14 * V24 * H4 * X3 * Y4 + U24 * V14 * V24 * H4 * X4 * Y3 - U24 * V14 * V24 * H4 * X4 * Y4 + U24 * V14 * V24 * Y2 * Y3 - U24 * V14 * V24 * Y2 * Y4 - U24 * V14 * V24 * Y3^2 + U24 * V14 * V24 * Y3 * Y4 + U24 * V14 * H4 * X3 - U24 * V14 * H4 * X4 + U24 * V14 * Y3 - U24 * V14 * Y4 + V12 * V14 * V24^2 * H4 * Y1 * Y2 * Y3 - V12 * V14 * V24^2 * H4 * Y1 * Y2 * Y4 - V12 * V14 * V24^2 * H4 * Y1 * Y3 * Y4 + V12 * V14 * V24^2 * H4 * Y1 * Y4^2 - V12 * V14 * V24^2 * H4 * Y2^2 * Y3 + V12 * V14 * V24^2 * H4 * Y2^2 * Y4 + V12 * V14 * V24^2 * H4 * Y2 * Y3 * Y4 - V12 * V14 * V24^2 * H4 * Y2 * Y4^2 - V12 * V14 * V24 * H4 * Y1 * Y3 + V12 * V14 * V24 * H4 * Y1 * Y4 + V12 * V14 * V24 * H4 * Y2 * Y3 - V12 * V14 * V24 * H4 * Y2 * Y4 - V14 * V24^2 * H4 * Y2 * Y3 + V14 * V24^2 * H4 * Y2 * Y4 + V14 * V24^2 * H4 * Y3 * Y4 - V14 * V24^2 * H4 * Y4^2 + V14 * V24 * H4 * Y3 - V14 * V24 * H4 * Y4, U12 * U14 * E4 * H2 + U12 * U14 * E4 * H4 * Y3 - U12 * U14 * Y1 + U12 * U14 * Y2 - U12 * U14 * Y3 + U12 * U14 * Y4 - 2 * U12 * U24 * V14 * Y1^2 + 2 * U12 * U24 * V14 * Y1 * Y2 + 2 * U12 * U24 * V14 * Y1 * Y4 - 2 * U12 * U24 * V14 * Y2 * Y4 - U12 * U24 * E4 * H2 - U12 * U24 * E4 * H4 * Y3 + U12 * U24 * Y1 - U12 * U24 * Y2 + U12 * U24 * Y3 - U12 * U24 * Y4 - 2 * U12 * V14 * V24 * H2 * Y1 + 2 * U12 * V14 * V24 * H2 * Y2 - 2 * U12 * V14 * V24 * H4 * Y1 * Y4 + 2 * U12 * V14 * V24 * H4 * Y2 * Y4 - 2 * U12 * V14 * H2 + U12 * V14 * H3 * H4 + U12 * V14 * H4^2 * X2 + U12 * V14 * H4 * Y2 - U12 * V14 * H4 * Y4 + 2 * U12 * V24 * H2 - U12 * V24 * H3 * H4 - U12 * V24 * H4^2 * X2 - U12 * V24 * H4 * Y1 + U12 * V24 * H4 * Y4 + 2 * U14 * U24 * V12 * Y1^2 - 2 * U14 * U24 * V12 * Y1 * Y2 - 2 * U14 * U24 * V12 * Y1 * Y4 + 2 * U14 * U24 * V12 * Y2 * Y4 + U14 * U24 * E4 * H2 + U14 * U24 * E4 * H4 * Y3 - U14 * U24 * Y1 + U14 * U24 * Y2 - U14 * U24 * Y3 + U14 * U24 * Y4 + 2 * U14 * V12 * V24 * H2 * Y1 - 2 * U14 * V12 * V24 * H2 * Y4 + 2 * U14 * V12 * V24 * H4 * Y1 * Y2 - 2 * U14 * V12 * V24 * H4 * Y2 * Y4 - 2 * U14 * V12 * H2 + U14 * V12 * H3 * H4 + U14 * V12 * H4^2 * X4 - U14 * V12 * H4 * Y2 + U14 * V12 * H4 * Y4 - 2 * U14 * V24 * H2 + U14 * V24 * H3 * H4 + U14 * V24 * H4^2 * X4 + U14 * V24 * H4 * Y1 - U14 * V24 * H4 * Y2 - 2 * U24 * V12 * V14 * H2 * Y2 + 2 * U24 * V12 * V14 * H2 * Y4 - 2 * U24 * V12 * V14 * H4 * Y1 * Y2 + 2 * U24 * V12 * V14 * H4 * Y1 * Y4 + 2 * U24 * V12 * H2 - U24 * V12 * H3 * H4 - U24 * V12 * H4^2 * X4 + U24 * V12 * H4 * Y1 - U24 * V12 * H4 * Y4 - 2 * U24 * V14 * H2 + U24 * V14 * H3 * H4 + U24 * V14 * H4^2 * X4 - U24 * V14 * H4 * Y1 + U24 * V14 * H4 * Y2 - V12 * V14 * H2 * H4 - V12 * V14 * H4^2 * Y1 + V12 * V24 * H2 * H4 + V12 * V24 * H4^2 * Y1 - V14 * V24 * H2 * H4 - V14 * V24 * H4^2 * Y1 - V14 * V24 * H4^2 * Y2 + V14 * V24 * H4^2 * Y4 + V14 * H4^2, U12 * U14 * U23 * V24 - U12 * U14 * U23 * V34 + U12 * U14 * U34 * V23 * V24 * Y3 - U12 * U14 * U34 * V23 * V24 * Y4 + U12 * U14 * U34 * V23 * V34 * Y2 - U12 * U14 * U34 * V23 * V34 * Y3 - U12 * U14 * U34 * V23 + U12 * U14 * U34 * V24 * V34 * Y3 - U12 * U14 * U34 * V24 * V34 * Y4 + U12 * U14 * U34 * V24 - U12 * U14 * U34 * V34 - U12 * U14 * V23 * V24 * V34 * H2 - U12 * U14 * V23 * V24 * V34 * H4 * Y3 + U12 * U14 * V23 * V34^2 * H2 + U12 * U14 * V23 * V34^2 * H4 * Y3 - U12 * U14 * V24 * V34^2 * H2 - U12 * U14 * V24 * V34^2 * H4 * Y3 - U12 * U23 * U24 * V14 * V24 * V34 * Y1 * Y2 + U12 * U23 * U24 * V14 * V24 * V34 * Y1 * Y4 + U12 * U23 * U24 * V14 * V24 * V34 * Y2 * Y4 - U12 * U23 * U24 * V14 * V24 * V34 * Y4^2 + U12 * U23 * U24 * V14 * V24 * Y1 - U12 * U23 * U24 * V14 * V24 * Y4 - U12 * U23 * U24 * V14 * V34 * Y1 + U12 * U23 * U24 * V14 * V34 * Y4 + U12 * U23 * U24 * V24 * V34 * Y2 - U12 * U23 * U24 * V24 * V34 * Y4 - U12 * U23 * U24 * V24 + U12 * U23 * U24 * V34 - U12 * U23 * U34 * V14 * V24^2 * V34 * Y1 * Y2^2 + U12 * U23 * U34 * V14 * V24^2 * V34 * Y1 * Y2 * Y3 + U12 * U23 * U34 * V14 * V24^2 * V34 * Y1 * Y2 * Y4 - U12 * U23 * U34 * V14 * V24^2 * V34 * Y1 * Y3 * Y4 + U12 * U23 * U34 * V14 * V24^2 * V34 * Y2^2 * Y4 - U12 * U23 * U34 * V14 * V24^2 * V34 * Y2 * Y3 * Y4 - U12 * U23 * U34 * V14 * V24^2 * V34 * Y2 * Y4^2 + U12 * U23 * U34 * V14 * V24^2 * V34 * Y3 * Y4^2 + U12 * U23 * U34 * V14 * V24^2 * Y1 * Y2 - U12 * U23 * U34 * V14 * V24^2 * Y1 * Y4 - U12 * U23 * U34 * V14 * V24^2 * Y2 * Y4 + U12 * U23 * U34 * V14 * V24^2 * Y4^2 + U12 * U23 * U34 * V24^2 * V34 * Y2^2 - U12 * U23 * U34 * V24^2 * V34 * Y2 * Y3 - U12 * U23 * U34 * V24^2 * V34 * Y2 * Y4 + U12 * U23 * U34 * V24^2 * V34 * Y3 * Y4 - U12 * U23 * U34 * V24^2 * Y2 + U12 * U23 * U34 * V24^2 * Y4 - U12 * U23 * V14 * V24^2 * V34^2 * H2 * Y1 * Y2 + U12 * U23 * V14 * V24^2 * V34^2 * H2 * Y1 * Y3 + U12 * U23 * V14 * V24^2 * V34^2 * H2 * Y2 * Y4 - U12 * U23 * V14 * V24^2 * V34^2 * H2 * Y3 * Y4 - U12 * U23 * V14 * V24^2 * V34^2 * H4 * Y1 * Y2 * Y4 + U12 * U23 * V14 * V24^2 * V34^2 * H4 * Y1 * Y3 * Y4 + U12 * U23 * V14 * V24^2 * V34^2 * H4 * Y2 * Y4^2 - U12 * U23 * V14 * V24^2 * V34^2 * H4 * Y3 * Y4^2 + U12 * U23 * V24^2 * V34^2 * H2 * Y2 - U12 * U23 * V24^2 * V34^2 * H2 * Y3 + U12 * U23 * V24^2 * V34^2 * H4 * Y2 * Y4 - U12 * U23 * V24^2 * V34^2 * H4 * Y3 * Y4 + U12 * U24 * U34 * V14 * V23 * V24 * V34 * Y1 * Y2^2 - U12 * U24 * U34 * V14 * V23 * V24 * V34 * Y1 * Y2 * Y3 - U12 * U24 * U34 * V14 * V23 * V24 * V34 * Y1 * Y2 * Y4 + U12 * U24 * U34 * V14 * V23 * V24 * V34 * Y1 * Y3 * Y4 - U12 * U24 * U34 * V14 * V23 * V24 * V34 * Y2^2 * Y4 + U12 * U24 * U34 * V14 * V23 * V24 * V34 * Y2 * Y3 * Y4 + U12 * U24 * U34 * V14 * V23 * V24 * V34 * Y2 * Y4^2 - U12 * U24 * U34 * V14 * V23 * V24 * V34 * Y3 * Y4^2 - U12 * U24 * U34 * V14 * V23 * V24 * Y1 * Y2 + U12 * U24 * U34 * V14 * V23 * V24 * Y1 * Y3 + U12 * U24 * U34 * V14 * V23 * V24 * Y2 * Y4 - U12 * U24 * U34 * V14 * V23 * V24 * Y3 * Y4 + U12 * U24 * U34 * V14 * V23 * V34 * Y1 * Y2 - U12 * U24 * U34 * V14 * V23 * V34 * Y1 * Y3 - U12 * U24 * U34 * V14 * V23 * V34 * Y2 * Y4 + U12 * U24 * U34 * V14 * V23 * V34 * Y3 * Y4 - U12 * U24 * U34 * V14 * V23 * Y1 + U12 * U24 * U34 * V14 * V23 * Y4 - U12 * U24 * U34 * V14 * V24 * V34 * Y1 * Y2 + U12 * U24 * U34 * V14 * V24 * V34 * Y1 * Y3 + U12 * U24 * U34 * V14 * V24 * V34 * Y2 * Y4 - U12 * U24 * U34 * V14 * V24 * V34 * Y3 * Y4 + U12 * U24 * U34 * V14 * V24 * Y1 - U12 * U24 * U34 * V14 * V24 * Y4 - U12 * U24 * U34 * V14 * V34 * Y1 + U12 * U24 * U34 * V14 * V34 * Y4 - U12 * U24 * U34 * V23 * V24 * V34 * Y2^2 + U12 * U24 * U34 * V23 * V24 * V34 * Y2 * Y3 + U12 * U24 * U34 * V23 * V24 * V34 * Y2 * Y4 - U12 * U24 * U34 * V23 * V24 * V34 * Y3 * Y4 + U12 * U24 * U34 * V23 * V24 * Y2 - U12 * U24 * U34 * V23 * V24 * Y3 - U12 * U24 * U34 * V23 * V34 * Y2 + U12 * U24 * U34 * V23 * V34 * Y3 + U12 * U24 * U34 * V23 + U12 * U24 * U34 * V24 * V34 * Y2 - U12 * U24 * U34 * V24 * V34 * Y3 - U12 * U24 * U34 * V24 + U12 * U24 * U34 * V34 + U12 * U24 * V14 * V23 * V24 * V34^2 * H2 * Y1 * Y2 - U12 * U24 * V14 * V23 * V24 * V34^2 * H2 * Y1 * Y4 - U12 * U24 * V14 * V23 * V24 * V34^2 * H2 * Y2 * Y4 + U12 * U24 * V14 * V23 * V24 * V34^2 * H2 * Y4^2 + U12 * U24 * V14 * V23 * V24 * V34^2 * H4 * Y1 * Y2 * Y3 - U12 * U24 * V14 * V23 * V24 * V34^2 * H4 * Y1 * Y3 * Y4 - U12 * U24 * V14 * V23 * V24 * V34^2 * H4 * Y2 * Y3 * Y4 + U12 * U24 * V14 * V23 * V24 * V34^2 * H4 * Y3 * Y4^2 - U12 * U24 * V14 * V23 * V24 * V34 * H2 * Y1 + U12 * U24 * V14 * V23 * V24 * V34 * H2 * Y4 - U12 * U24 * V14 * V23 * V24 * V34 * H4 * Y1 * Y3 + U12 * U24 * V14 * V23 * V24 * V34 * H4 * Y3 * Y4 + U12 * U24 * V14 * V23 * V34^2 * H2 * Y1 - U12 * U24 * V14 * V23 * V34^2 * H2 * Y4 + U12 * U24 * V14 * V23 * V34^2 * H4 * Y1 * Y3 - U12 * U24 * V14 * V23 * V34^2 * H4 * Y3 * Y4 - U12 * U24 * V14 * V24 * V34^2 * H2 * Y1 + U12 * U24 * V14 * V24 * V34^2 * H2 * Y4 - U12 * U24 * V14 * V24 * V34^2 * H4 * Y1 * Y3 + U12 * U24 * V14 * V24 * V34^2 * H4 * Y3 * Y4 - U12 * U24 * V23 * V24 * V34^2 * H2 * Y2 + U12 * U24 * V23 * V24 * V34^2 * H2 * Y4 - U12 * U24 * V23 * V24 * V34^2 * H4 * Y2 * Y3 + U12 * U24 * V23 * V24 * V34^2 * H4 * Y3 * Y4 + U12 * U24 * V23 * V24 * V34 * H2 + U12 * U24 * V23 * V24 * V34 * H4 * Y3 - U12 * U24 * V23 * V34^2 * H2 - U12 * U24 * V23 * V34^2 * H4 * Y3 + U12 * U24 * V24 * V34^2 * H2 + U12 * U24 * V24 * V34^2 * H4 * Y3 - U12 * U34 * V14 * V23 * V24^2 * V34 * H2 * Y1 * Y3 + U12 * U34 * V14 * V23 * V24^2 * V34 * H2 * Y1 * Y4 + U12 * U34 * V14 * V23 * V24^2 * V34 * H2 * Y3 * Y4 - U12 * U34 * V14 * V23 * V24^2 * V34 * H2 * Y4^2 - U12 * U34 * V14 * V23 * V24^2 * V34 * H4 * Y1 * Y2 * Y3 + U12 * U34 * V14 * V23 * V24^2 * V34 * H4 * Y1 * Y2 * Y4 + U12 * U34 * V14 * V23 * V24^2 * V34 * H4 * Y2 * Y3 * Y4 - U12 * U34 * V14 * V23 * V24^2 * V34 * H4 * Y2 * Y4^2 + U12 * U34 * V23 * V24^2 * V34 * H2 * Y3 - U12 * U34 * V23 * V24^2 * V34 * H2 * Y4 + U12 * U34 * V23 * V24^2 * V34 * H4 * Y2 * Y3 - U12 * U34 * V23 * V24^2 * V34 * H4 * Y2 * Y4 + U14 * U23 * U24 * V12 * V24 * V34 * Y1 * Y2 - U14 * U23 * U24 * V12 * V24 * V34 * Y1 * Y4 - U14 * U23 * U24 * V12 * V24 * V34 * Y2 * Y4 + U14 * U23 * U24 * V12 * V24 * V34 * Y4^2 - U14 * U23 * U24 * V12 * V24 * Y1 + U14 * U23 * U24 * V12 * V24 * Y4 + U14 * U23 * U24 * V12 * V34 * Y1 - U14 * U23 * U24 * V12 * V34 * Y2 - U14 * U23 * U24 * V24 * V34 * Y2 + U14 * U23 * U24 * V24 * V34 * Y4 + U14 * U23 * U24 * V24 - U14 * U23 * U24 * V34 + U14 * U23 * U34 * V12 * V24^2 * V34 * Y1 * Y2^2 - U14 * U23 * U34 * V12 * V24^2 * V34 * Y1 * Y2 * Y3 - U14 * U23 * U34 * V12 * V24^2 * V34 * Y1 * Y2 * Y4 + U14 * U23 * U34 * V12 * V24^2 * V34 * Y1 * Y3 * Y4 - U14 * U23 * U34 * V12 * V24^2 * V34 * Y2^2 * Y4 + U14 * U23 * U34 * V12 * V24^2 * V34 * Y2 * Y3 * Y4 + U14 * U23 * U34 * V12 * V24^2 * V34 * Y2 * Y4^2 - U14 * U23 * U34 * V12 * V24^2 * V34 * Y3 * Y4^2 - U14 * U23 * U34 * V12 * V24^2 * Y1 * Y2 + U14 * U23 * U34 * V12 * V24^2 * Y1 * Y4 + U14 * U23 * U34 * V12 * V24^2 * Y2 * Y4 - U14 * U23 * U34 * V12 * V24^2 * Y4^2 - U14 * U23 * U34 * V12 * V24 * V34 * Y2^2 + U14 * U23 * U34 * V12 * V24 * V34 * Y2 * Y3 + U14 * U23 * U34 * V12 * V24 * V34 * Y2 * Y4 - U14 * U23 * U34 * V12 * V24 * V34 * Y3 * Y4 + U14 * U23 * U34 * V12 * V24 * Y2 - U14 * U23 * U34 * V12 * V24 * Y4 - U14 * U23 * U34 * V24^2 * V34 * Y2^2 + U14 * U23 * U34 * V24^2 * V34 * Y2 * Y3 + U14 * U23 * U34 * V24^2 * V34 * Y2 * Y4 - U14 * U23 * U34 * V24^2 * V34 * Y3 * Y4 + U14 * U23 * U34 * V24^2 * Y2 - U14 * U23 * U34 * V24^2 * Y4 + U14 * U23 * V12 * V24^2 * V34^2 * H2 * Y1 * Y2 - U14 * U23 * V12 * V24^2 * V34^2 * H2 * Y1 * Y3 - U14 * U23 * V12 * V24^2 * V34^2 * H2 * Y2 * Y4 + U14 * U23 * V12 * V24^2 * V34^2 * H2 * Y3 * Y4 + U14 * U23 * V12 * V24^2 * V34^2 * H4 * Y1 * Y2 * Y4 - U14 * U23 * V12 * V24^2 * V34^2 * H4 * Y1 * Y3 * Y4 - U14 * U23 * V12 * V24^2 * V34^2 * H4 * Y2 * Y4^2 + U14 * U23 * V12 * V24^2 * V34^2 * H4 * Y3 * Y4^2 - U14 * U23 * V12 * V24 * V34^2 * H2 * Y2 + U14 * U23 * V12 * V24 * V34^2 * H2 * Y3 - U14 * U23 * V12 * V24 * V34^2 * H4 * Y2 * Y4 + U14 * U23 * V12 * V24 * V34^2 * H4 * Y3 * Y4 - U14 * U23 * V24^2 * V34^2 * H2 * Y2 + U14 * U23 * V24^2 * V34^2 * H2 * Y3 - U14 * U23 * V24^2 * V34^2 * H4 * Y2 * Y4 + U14 * U23 * V24^2 * V34^2 * H4 * Y3 * Y4 - U14 * U24 * U34 * V12 * V23 * V24 * V34 * Y1 * Y2^2 + U14 * U24 * U34 * V12 * V23 * V24 * V34 * Y1 * Y2 * Y3 + U14 * U24 * U34 * V12 * V23 * V24 * V34 * Y1 * Y2 * Y4 - U14 * U24 * U34 * V12 * V23 * V24 * V34 * Y1 * Y3 * Y4 + U14 * U24 * U34 * V12 * V23 * V24 * V34 * Y2^2 * Y4 - U14 * U24 * U34 * V12 * V23 * V24 * V34 * Y2 * Y3 * Y4 - U14 * U24 * U34 * V12 * V23 * V24 * V34 * Y2 * Y4^2 + U14 * U24 * U34 * V12 * V23 * V24 * V34 * Y3 * Y4^2 + U14 * U24 * U34 * V12 * V23 * V24 * Y1 * Y2 - U14 * U24 * U34 * V12 * V23 * V24 * Y1 * Y3 - U14 * U24 * U34 * V12 * V23 * V24 * Y2 * Y4 + U14 * U24 * U34 * V12 * V23 * V24 * Y3 * Y4 - U14 * U24 * U34 * V12 * V23 * V34 * Y1 * Y2 + U14 * U24 * U34 * V12 * V23 * V34 * Y1 * Y3 + U14 * U24 * U34 * V12 * V23 * V34 * Y2^2 - U14 * U24 * U34 * V12 * V23 * V34 * Y2 * Y3 + U14 * U24 * U34 * V12 * V23 * Y1 - U14 * U24 * U34 * V12 * V23 * Y2 + U14 * U24 * U34 * V12 * V24 * V34 * Y1 * Y2 - U14 * U24 * U34 * V12 * V24 * V34 * Y1 * Y3 - U14 * U24 * U34 * V12 * V24 * V34 * Y2 * Y4 + U14 * U24 * U34 * V12 * V24 * V34 * Y3 * Y4 - U14 * U24 * U34 * V12 * V24 * Y1 + U14 * U24 * U34 * V12 * V24 * Y4 + U14 * U24 * U34 * V12 * V34 * Y1 - U14 * U24 * U34 * V12 * V34 * Y2 + U14 * U24 * U34 * V23 * V24 * V34 * Y2^2 - U14 * U24 * U34 * V23 * V24 * V34 * Y2 * Y3 - U14 * U24 * U34 * V23 * V24 * V34 * Y2 * Y4 + U14 * U24 * U34 * V23 * V24 * V34 * Y3 * Y4 - U14 * U24 * U34 * V23 * V24 * Y2 + U14 * U24 * U34 * V23 * V24 * Y3 + U14 * U24 * U34 * V23 * V34 * Y2 - U14 * U24 * U34 * V23 * V34 * Y3 - U14 * U24 * U34 * V23 - U14 * U24 * U34 * V24 * V34 * Y2 + U14 * U24 * U34 * V24 * V34 * Y3 + U14 * U24 * U34 * V24 - U14 * U24 * U34 * V34 - U14 * U24 * V12 * V23 * V24 * V34^2 * H2 * Y1 * Y2 + U14 * U24 * V12 * V23 * V24 * V34^2 * H2 * Y1 * Y4 + U14 * U24 * V12 * V23 * V24 * V34^2 * H2 * Y2 * Y4 - U14 * U24 * V12 * V23 * V24 * V34^2 * H2 * Y4^2 - U14 * U24 * V12 * V23 * V24 * V34^2 * H4 * Y1 * Y2 * Y3 + U14 * U24 * V12 * V23 * V24 * V34^2 * H4 * Y1 * Y3 * Y4 + U14 * U24 * V12 * V23 * V24 * V34^2 * H4 * Y2 * Y3 * Y4 - U14 * U24 * V12 * V23 * V24 * V34^2 * H4 * Y3 * Y4^2 + U14 * U24 * V12 * V23 * V24 * V34 * H2 * Y1 - U14 * U24 * V12 * V23 * V24 * V34 * H2 * Y4 + U14 * U24 * V12 * V23 * V24 * V34 * H4 * Y1 * Y3 - U14 * U24 * V12 * V23 * V24 * V34 * H4 * Y3 * Y4 - U14 * U24 * V12 * V23 * V34^2 * H2 * Y1 + U14 * U24 * V12 * V23 * V34^2 * H2 * Y2 - U14 * U24 * V12 * V23 * V34^2 * H4 * Y1 * Y3 + U14 * U24 * V12 * V23 * V34^2 * H4 * Y2 * Y3 + U14 * U24 * V12 * V24 * V34^2 * H2 * Y1 - U14 * U24 * V12 * V24 * V34^2 * H2 * Y4 + U14 * U24 * V12 * V24 * V34^2 * H4 * Y1 * Y3 - U14 * U24 * V12 * V24 * V34^2 * H4 * Y3 * Y4 + U14 * U24 * V23 * V24 * V34^2 * H2 * Y2 - U14 * U24 * V23 * V24 * V34^2 * H2 * Y4 + U14 * U24 * V23 * V24 * V34^2 * H4 * Y2 * Y3 - U14 * U24 * V23 * V24 * V34^2 * H4 * Y3 * Y4 - U14 * U24 * V23 * V24 * V34 * H2 - U14 * U24 * V23 * V24 * V34 * H4 * Y3 + U14 * U24 * V23 * V34^2 * H2 + U14 * U24 * V23 * V34^2 * H4 * Y3 - U14 * U24 * V24 * V34^2 * H2 - U14 * U24 * V24 * V34^2 * H4 * Y3 + U14 * U34 * V12 * V23 * V24^2 * V34 * H2 * Y1 * Y3 - U14 * U34 * V12 * V23 * V24^2 * V34 * H2 * Y1 * Y4 - U14 * U34 * V12 * V23 * V24^2 * V34 * H2 * Y3 * Y4 + U14 * U34 * V12 * V23 * V24^2 * V34 * H2 * Y4^2 + U14 * U34 * V12 * V23 * V24^2 * V34 * H4 * Y1 * Y2 * Y3 - U14 * U34 * V12 * V23 * V24^2 * V34 * H4 * Y1 * Y2 * Y4 - U14 * U34 * V12 * V23 * V24^2 * V34 * H4 * Y2 * Y3 * Y4 + U14 * U34 * V12 * V23 * V24^2 * V34 * H4 * Y2 * Y4^2 - U14 * U34 * V12 * V23 * V24 * V34 * H2 * Y3 + U14 * U34 * V12 * V23 * V24 * V34 * H2 * Y4 - U14 * U34 * V12 * V23 * V24 * V34 * H4 * Y2 * Y3 + U14 * U34 * V12 * V23 * V24 * V34 * H4 * Y2 * Y4 - U14 * U34 * V23 * V24^2 * V34 * H2 * Y3 + U14 * U34 * V23 * V24^2 * V34 * H2 * Y4 - U14 * U34 * V23 * V24^2 * V34 * H4 * Y2 * Y3 + U14 * U34 * V23 * V24^2 * V34 * H4 * Y2 * Y4, U12 * U13 * V23 * E4 * Y3^2 - 2 * U12 * U13 * V23 * E4 * Y3 * Y4 + U12 * U13 * V23 * E4 * Y4^2 - U12 * U13 * V23 * X3 * Y1 + 2 * U12 * U13 * V23 * X3 * Y3 - U12 * U13 * V23 * X3 * Y4 + U12 * U13 * V23 * X4 * Y1 - 2 * U12 * U13 * V23 * X4 * Y3 + U12 * U13 * V23 * X4 * Y4 + U12 * U13 * E4 * Y3 - U12 * U13 * E4 * Y4 + U12 * U13 * X3 - U12 * U13 * X4 - U12 * U23 * V13 * V23 * X3 * Y1^2 + U12 * U23 * V13 * V23 * X3 * Y1 * Y2 + U12 * U23 * V13 * V23 * X3 * Y1 * Y3 - U12 * U23 * V13 * V23 * X3 * Y2 * Y3 + U12 * U23 * V13 * V23 * X4 * Y1^2 - U12 * U23 * V13 * V23 * X4 * Y1 * Y2 - U12 * U23 * V13 * V23 * X4 * Y1 * Y3 + U12 * U23 * V13 * V23 * X4 * Y2 * Y3 + U12 * U23 * V13 * E4 * Y2 * Y3 - U12 * U23 * V13 * E4 * Y2 * Y4 - U12 * U23 * V13 * E4 * Y3^2 + U12 * U23 * V13 * E4 * Y3 * Y4 + U12 * U23 * V13 * X3 * Y2 - U12 * U23 * V13 * X3 * Y3 - U12 * U23 * V13 * X4 * Y2 + U12 * U23 * V13 * X4 * Y3 - U12 * U23 * V23 * E4 * Y2 * Y3 + U12 * U23 * V23 * E4 * Y2 * Y4 + U12 * U23 * V23 * E4 * Y3 * Y4 - U12 * U23 * V23 * E4 * Y4^2 + U12 * U23 * V23 * X3 * Y1 - U12 * U23 * V23 * X3 * Y2 - U12 * U23 * V23 * X3 * Y3 + U12 * U23 * V23 * X3 * Y4 - U12 * U23 * V23 * X4 * Y1 + U12 * U23 * V23 * X4 * Y2 + U12 * U23 * V23 * X4 * Y3 - U12 * U23 * V23 * X4 * Y4 - U12 * U23 * E4 * Y3 + U12 * U23 * E4 * Y4 - U12 * U23 * X3 + U12 * U23 * X4 - U12 * V13 * V23^2 * H4 * X2 * Y1 * Y3 + U12 * V13 * V23^2 * H4 * X2 * Y1 * Y4 + U12 * V13 * V23^2 * H4 * X2 * Y2 * Y3 - U12 * V13 * V23^2 * H4 * X2 * Y2 * Y4 + U12 * V13 * V23^2 * H4 * X4 * Y1 * Y3 - U12 * V13 * V23^2 * H4 * X4 * Y1 * Y4 - U12 * V13 * V23^2 * H4 * X4 * Y2 * Y3 + U12 * V13 * V23^2 * H4 * X4 * Y2 * Y4 - U12 * V13 * V23^2 * Y1^2 * Y3 + U12 * V13 * V23^2 * Y1^2 * Y4 + U12 * V13 * V23^2 * Y1 * Y3^2 - U12 * V13 * V23^2 * Y1 * Y4^2 + U12 * V13 * V23^2 * Y2^2 * Y3 - U12 * V13 * V23^2 * Y2^2 * Y4 - U12 * V13 * V23^2 * Y2 * Y3^2 + U12 * V13 * V23^2 * Y2 * Y4^2 - U12 * V13 * V23 * H4 * X2 * Y3 + U12 * V13 * V23 * H4 * X2 * Y4 + U12 * V13 * V23 * H4 * X4 * Y3 - U12 * V13 * V23 * H4 * X4 * Y4 - U12 * V13 * V23 * Y1 * Y3 + U12 * V13 * V23 * Y1 * Y4 - U12 * V13 * V23 * Y2 * Y3 + U12 * V13 * V23 * Y2 * Y4 + U12 * V13 * V23 * Y3^2 - U12 * V13 * V23 * Y4^2 + U12 * V23^2 * H4 * X2 * Y3 - U12 * V23^2 * H4 * X2 * Y4 - U12 * V23^2 * H4 * X4 * Y3 + U12 * V23^2 * H4 * X4 * Y4 + U12 * V23^2 * Y1 * Y3 - U12 * V23^2 * Y1 * Y4 + U12 * V23^2 * Y2 * Y3 - U12 * V23^2 * Y2 * Y4 - U12 * V23^2 * Y3^2 + U12 * V23^2 * Y4^2 + U13 * U23 * V12 * V23 * X3 * Y1^2 - U13 * U23 * V12 * V23 * X3 * Y1 * Y2 - U13 * U23 * V12 * V23 * X3 * Y1 * Y3 + U13 * U23 * V12 * V23 * X3 * Y2 * Y3 - U13 * U23 * V12 * V23 * X4 * Y1^2 + U13 * U23 * V12 * V23 * X4 * Y1 * Y2 + U13 * U23 * V12 * V23 * X4 * Y1 * Y3 - U13 * U23 * V12 * V23 * X4 * Y2 * Y3 + U13 * U23 * V23 * E4 * Y2 * Y3 - U13 * U23 * V23 * E4 * Y2 * Y4 - U13 * U23 * V23 * E4 * Y3 * Y4 + U13 * U23 * V23 * E4 * Y4^2 - U13 * U23 * V23 * X3 * Y1 + U13 * U23 * V23 * X3 * Y2 + U13 * U23 * V23 * X3 * Y3 - U13 * U23 * V23 * X3 * Y4 + U13 * U23 * V23 * X4 * Y1 - U13 * U23 * V23 * X4 * Y2 - U13 * U23 * V23 * X4 * Y3 + U13 * U23 * V23 * X4 * Y4 + U13 * U23 * E4 * Y3 - U13 * U23 * E4 * Y4 + U13 * U23 * X3 - U13 * U23 * X4 + U13 * V12 * V23^2 * H4 * X3 * Y1 * Y2 - U13 * V12 * V23^2 * H4 * X3 * Y1 * Y4 - U13 * V12 * V23^2 * H4 * X3 * Y2 * Y3 + U13 * V12 * V23^2 * H4 * X3 * Y3 * Y4 - U13 * V12 * V23^2 * H4 * X4 * Y1 * Y2 + U13 * V12 * V23^2 * H4 * X4 * Y1 * Y4 + U13 * V12 * V23^2 * H4 * X4 * Y2 * Y3 - U13 * V12 * V23^2 * H4 * X4 * Y3 * Y4 + U13 * V12 * V23^2 * Y1^2 * Y3 - U13 * V12 * V23^2 * Y1^2 * Y4 - U13 * V12 * V23^2 * Y1 * Y3^2 + U13 * V12 * V23^2 * Y1 * Y4^2 + U13 * V12 * V23^2 * Y3^2 * Y4 - U13 * V12 * V23^2 * Y3 * Y4^2 - U13 * V12 * V23 * H4 * X3 * Y3 + U13 * V12 * V23 * H4 * X3 * Y4 + U13 * V12 * V23 * H4 * X4 * Y3 - U13 * V12 * V23 * H4 * X4 * Y4 - U13 * V12 * V23 * Y3^2 + 2 * U13 * V12 * V23 * Y3 * Y4 - U13 * V12 * V23 * Y4^2 - U13 * V12 * H4 * X3 + U13 * V12 * H4 * X4 - U13 * V12 * Y3 + U13 * V12 * Y4 - U13 * V23^2 * H4 * X3 * Y2 + U13 * V23^2 * H4 * X3 * Y4 + U13 * V23^2 * H4 * X4 * Y2 - U13 * V23^2 * H4 * X4 * Y4 - U13 * V23^2 * Y1 * Y3 + U13 * V23^2 * Y1 * Y4 - U13 * V23^2 * Y2 * Y3 + U13 * V23^2 * Y2 * Y4 + U13 * V23^2 * Y3^2 - U13 * V23^2 * Y4^2 - U23 * V12 * V13 * V23 * H4 * X3 * Y1 * Y2 + U23 * V12 * V13 * V23 * H4 * X3 * Y1 * Y3 + U23 * V12 * V13 * V23 * H4 * X3 * Y2 * Y4 - U23 * V12 * V13 * V23 * H4 * X3 * Y3 * Y4 + U23 * V12 * V13 * V23 * H4 * X4 * Y1 * Y2 - U23 * V12 * V13 * V23 * H4 * X4 * Y1 * Y3 - U23 * V12 * V13 * V23 * H4 * X4 * Y2 * Y4 + U23 * V12 * V13 * V23 * H4 * X4 * Y3 * Y4 - U23 * V12 * V13 * V23 * Y2^2 * Y3 + U23 * V12 * V13 * V23 * Y2^2 * Y4 + U23 * V12 * V13 * V23 * Y2 * Y3^2 - U23 * V12 * V13 * V23 * Y2 * Y4^2 - U23 * V12 * V13 * V23 * Y3^2 * Y4 + U23 * V12 * V13 * V23 * Y3 * Y4^2 - U23 * V12 * V13 * H4 * X3 * Y2 + U23 * V12 * V13 * H4 * X3 * Y3 + U23 * V12 * V13 * H4 * X4 * Y2 - U23 * V12 * V13 * H4 * X4 * Y3 - U23 * V12 * V13 * Y2 * Y3 + U23 * V12 * V13 * Y2 * Y4 + U23 * V12 * V13 * Y3^2 - U23 * V12 * V13 * Y3 * Y4 + U23 * V12 * V23 * H4 * X3 * Y2 - U23 * V12 * V23 * H4 * X3 * Y4 - U23 * V12 * V23 * H4 * X4 * Y2 + U23 * V12 * V23 * H4 * X4 * Y4 + U23 * V12 * V23 * Y2 * Y3 - U23 * V12 * V23 * Y2 * Y4 - U23 * V12 * V23 * Y3 * Y4 + U23 * V12 * V23 * Y4^2 + U23 * V12 * H4 * X3 - U23 * V12 * H4 * X4 + U23 * V12 * Y3 - U23 * V12 * Y4 - U23 * V13 * V23 * H4 * X3 * Y3 + U23 * V13 * V23 * H4 * X3 * Y4 + U23 * V13 * V23 * H4 * X4 * Y3 - U23 * V13 * V23 * H4 * X4 * Y4 - U23 * V13 * V23 * Y2 * Y3 + U23 * V13 * V23 * Y2 * Y4 + U23 * V13 * V23 * Y3 * Y4 - U23 * V13 * V23 * Y4^2 - U23 * V13 * H4 * X3 + U23 * V13 * H4 * X4 - U23 * V13 * Y3 + U23 * V13 * Y4 - V12 * V13 * V23^2 * H4 * Y1 * Y2 * Y3 + V12 * V13 * V23^2 * H4 * Y1 * Y2 * Y4 + V12 * V13 * V23^2 * H4 * Y1 * Y3^2 - V12 * V13 * V23^2 * H4 * Y1 * Y3 * Y4 + V12 * V13 * V23^2 * H4 * Y2^2 * Y3 - V12 * V13 * V23^2 * H4 * Y2^2 * Y4 - V12 * V13 * V23^2 * H4 * Y2 * Y3^2 + V12 * V13 * V23^2 * H4 * Y2 * Y3 * Y4 + V12 * V13 * V23 * H4 * Y1 * Y3 - V12 * V13 * V23 * H4 * Y1 * Y4 - V12 * V13 * V23 * H4 * Y2 * Y3 + V12 * V13 * V23 * H4 * Y2 * Y4 + V13 * V23^2 * H4 * Y2 * Y3 - V13 * V23^2 * H4 * Y2 * Y4 - V13 * V23^2 * H4 * Y3^2 + V13 * V23^2 * H4 * Y3 * Y4 - V13 * V23 * H4 * Y3 + V13 * V23 * H4 * Y4, U12 * U13 * E4 * H2 + U12 * U13 * E4 * H4 * Y4 - U12 * U13 * Y1 + U12 * U13 * Y2 + U12 * U13 * Y3 - U12 * U13 * Y4 - 2 * U12 * U23 * V13 * Y1^2 + 2 * U12 * U23 * V13 * Y1 * Y2 + 2 * U12 * U23 * V13 * Y1 * Y3 - 2 * U12 * U23 * V13 * Y2 * Y3 - U12 * U23 * E4 * H2 - U12 * U23 * E4 * H4 * Y4 + U12 * U23 * Y1 - U12 * U23 * Y2 - U12 * U23 * Y3 + U12 * U23 * Y4 - 2 * U12 * V13 * V23 * H2 * Y1 + 2 * U12 * V13 * V23 * H2 * Y2 - 2 * U12 * V13 * V23 * H4 * Y1 * Y3 + 2 * U12 * V13 * V23 * H4 * Y2 * Y3 - 2 * U12 * V13 * H2 + U12 * V13 * H3 * H4 + U12 * V13 * H4^2 * X2 + U12 * V13 * H4 * Y2 - U12 * V13 * H4 * Y3 + 2 * U12 * V23 * H2 - U12 * V23 * H3 * H4 - U12 * V23 * H4^2 * X2 - U12 * V23 * H4 * Y1 + U12 * V23 * H4 * Y3 + 2 * U13 * U23 * V12 * Y1^2 - 2 * U13 * U23 * V12 * Y1 * Y2 - 2 * U13 * U23 * V12 * Y1 * Y3 + 2 * U13 * U23 * V12 * Y2 * Y3 + U13 * U23 * E4 * H2 + U13 * U23 * E4 * H4 * Y4 - U13 * U23 * Y1 + U13 * U23 * Y2 + U13 * U23 * Y3 - U13 * U23 * Y4 + 2 * U13 * V12 * V23 * H2 * Y1 - 2 * U13 * V12 * V23 * H2 * Y3 + 2 * U13 * V12 * V23 * H4 * Y1 * Y2 - 2 * U13 * V12 * V23 * H4 * Y2 * Y3 - 2 * U13 * V12 * H2 + U13 * V12 * H3 * H4 + U13 * V12 * H4^2 * X3 - U13 * V12 * H4 * Y2 + U13 * V12 * H4 * Y3 - 2 * U13 * V23 * H2 + U13 * V23 * H3 * H4 + U13 * V23 * H4^2 * X3 + U13 * V23 * H4 * Y1 - U13 * V23 * H4 * Y2 - 2 * U23 * V12 * V13 * H2 * Y2 + 2 * U23 * V12 * V13 * H2 * Y3 - 2 * U23 * V12 * V13 * H4 * Y1 * Y2 + 2 * U23 * V12 * V13 * H4 * Y1 * Y3 + 2 * U23 * V12 * H2 - U23 * V12 * H3 * H4 - U23 * V12 * H4^2 * X3 + U23 * V12 * H4 * Y1 - U23 * V12 * H4 * Y3 - 2 * U23 * V13 * H2 + U23 * V13 * H3 * H4 + U23 * V13 * H4^2 * X3 - U23 * V13 * H4 * Y1 + U23 * V13 * H4 * Y2 - V12 * V13 * H2 * H4 - V12 * V13 * H4^2 * Y1 + V12 * V23 * H2 * H4 + V12 * V23 * H4^2 * Y1 - V13 * V23 * H2 * H4 - V13 * V23 * H4^2 * Y1 - V13 * V23 * H4^2 * Y2 + V13 * V23 * H4^2 * Y3 + V13 * H4^2, U12 * U13 * U24 * V23 + U12 * U13 * U24 * V34 + U12 * U13 * U34 * V23 * V24 * Y3 - U12 * U13 * U34 * V23 * V24 * Y4 - U12 * U13 * U34 * V23 * V34 * Y3 + U12 * U13 * U34 * V23 * V34 * Y4 - U12 * U13 * U34 * V23 + U12 * U13 * U34 * V24 * V34 * Y2 - U12 * U13 * U34 * V24 * V34 * Y4 + U12 * U13 * U34 * V24 - U12 * U13 * U34 * V34 + U12 * U13 * V23 * V24 * V34 * H2 + U12 * U13 * V23 * V24 * V34 * H4 * Y4 - U12 * U13 * V23 * V34^2 * H2 - U12 * U13 * V23 * V34^2 * H4 * Y4 + U12 * U13 * V24 * V34^2 * H2 + U12 * U13 * V24 * V34^2 * H4 * Y4 + U12 * U23 * U24 * V13 * V23 * V34 * Y1 * Y2 - U12 * U23 * U24 * V13 * V23 * V34 * Y1 * Y4 - U12 * U23 * U24 * V13 * V23 * V34 * Y2 * Y4 + U12 * U23 * U24 * V13 * V23 * V34 * Y4^2 - U12 * U23 * U24 * V13 * V23 * Y2 + U12 * U23 * U24 * V13 * V23 * Y4 + U12 * U23 * U24 * V13 * V34 * Y1 - U12 * U23 * U24 * V13 * V34 * Y4 - U12 * U23 * U24 * V13 - U12 * U23 * U24 * V23 * V34 * Y2 + U12 * U23 * U24 * V23 * V34 * Y4 - U12 * U23 * U24 * V34 + U12 * U23 * U34 * V13 * V23 * V24 * V34 * Y1 * Y2^2 - U12 * U23 * U34 * V13 * V23 * V24 * V34 * Y1 * Y2 * Y3 - U12 * U23 * U34 * V13 * V23 * V24 * V34 * Y1 * Y2 * Y4 + U12 * U23 * U34 * V13 * V23 * V24 * V34 * Y1 * Y3 * Y4 - U12 * U23 * U34 * V13 * V23 * V24 * V34 * Y2^2 * Y4 + U12 * U23 * U34 * V13 * V23 * V24 * V34 * Y2 * Y3 * Y4 + U12 * U23 * U34 * V13 * V23 * V24 * V34 * Y2 * Y4^2 - U12 * U23 * U34 * V13 * V23 * V24 * V34 * Y3 * Y4^2 - U12 * U23 * U34 * V13 * V23 * V24 * Y2^2 + 2 * U12 * U23 * U34 * V13 * V23 * V24 * Y2 * Y4 - U12 * U23 * U34 * V13 * V23 * V24 * Y4^2 - U12 * U23 * U34 * V13 * V23 * V34 * Y1 * Y2 + U12 * U23 * U34 * V13 * V23 * V34 * Y1 * Y4 + U12 * U23 * U34 * V13 * V23 * V34 * Y2 * Y3 - U12 * U23 * U34 * V13 * V23 * V34 * Y3 * Y4 + U12 * U23 * U34 * V13 * V23 * Y2 - U12 * U23 * U34 * V13 * V23 * Y4 + U12 * U23 * U34 * V13 * V24 * V34 * Y1 * Y2 - U12 * U23 * U34 * V13 * V24 * V34 * Y1 * Y4 - U12 * U23 * U34 * V13 * V24 * V34 * Y2 * Y3 + U12 * U23 * U34 * V13 * V24 * V34 * Y3 * Y4 + U12 * U23 * U34 * V13 * V24 * Y1 - U12 * U23 * U34 * V13 * V24 * Y2 - U12 * U23 * U34 * V13 * V24 * Y3 + U12 * U23 * U34 * V13 * V24 * Y4 - U12 * U23 * U34 * V13 * V34 * Y1 + U12 * U23 * U34 * V13 * V34 * Y3 + U12 * U23 * U34 * V13 - U12 * U23 * U34 * V23 * V24 * V34 * Y2^2 + U12 * U23 * U34 * V23 * V24 * V34 * Y2 * Y3 + U12 * U23 * U34 * V23 * V24 * V34 * Y2 * Y4 - U12 * U23 * U34 * V23 * V24 * V34 * Y3 * Y4 + U12 * U23 * U34 * V23 * V34 * Y2 - U12 * U23 * U34 * V23 * V34 * Y4 - U12 * U23 * U34 * V24 * V34 * Y2 + U12 * U23 * U34 * V24 * V34 * Y4 - U12 * U23 * U34 * V24 + U12 * U23 * U34 * V34 + U12 * U23 * V13 * V23 * V24 * V34^2 * H2 * Y1 * Y2 - U12 * U23 * V13 * V23 * V24 * V34^2 * H2 * Y1 * Y3 - U12 * U23 * V13 * V23 * V24 * V34^2 * H2 * Y2 * Y4 + U12 * U23 * V13 * V23 * V24 * V34^2 * H2 * Y3 * Y4 + U12 * U23 * V13 * V23 * V24 * V34^2 * H4 * Y1 * Y2 * Y4 - U12 * U23 * V13 * V23 * V24 * V34^2 * H4 * Y1 * Y3 * Y4 - U12 * U23 * V13 * V23 * V24 * V34^2 * H4 * Y2 * Y4^2 + U12 * U23 * V13 * V23 * V24 * V34^2 * H4 * Y3 * Y4^2 + U12 * U23 * V13 * V23 * V24 * V34 * H2 * Y1 - U12 * U23 * V13 * V23 * V24 * V34 * H2 * Y2 + U12 * U23 * V13 * V23 * V24 * V34 * H4 * Y1 * Y4 - U12 * U23 * V13 * V23 * V24 * V34 * H4 * Y2 * Y4 - U12 * U23 * V13 * V23 * V34^2 * H2 * Y1 + U12 * U23 * V13 * V23 * V34^2 * H2 * Y3 - U12 * U23 * V13 * V23 * V34^2 * H4 * Y1 * Y4 + U12 * U23 * V13 * V23 * V34^2 * H4 * Y3 * Y4 + U12 * U23 * V13 * V24 * V34^2 * H2 * Y1 - U12 * U23 * V13 * V24 * V34^2 * H2 * Y3 + U12 * U23 * V13 * V24 * V34^2 * H4 * Y1 * Y4 - U12 * U23 * V13 * V24 * V34^2 * H4 * Y3 * Y4 - U12 * U23 * V23 * V24 * V34^2 * H2 * Y2 + U12 * U23 * V23 * V24 * V34^2 * H2 * Y3 - U12 * U23 * V23 * V24 * V34^2 * H4 * Y2 * Y4 + U12 * U23 * V23 * V24 * V34^2 * H4 * Y3 * Y4 - U12 * U23 * V23 * V24 * V34 * H2 - U12 * U23 * V23 * V24 * V34 * H4 * Y4 + U12 * U23 * V23 * V34^2 * H2 + U12 * U23 * V23 * V34^2 * H4 * Y4 - U12 * U23 * V24 * V34^2 * H2 - U12 * U23 * V24 * V34^2 * H4 * Y4 - U12 * U24 * U34 * V13 * V23^2 * V34 * Y1 * Y2^2 + U12 * U24 * U34 * V13 * V23^2 * V34 * Y1 * Y2 * Y3 + U12 * U24 * U34 * V13 * V23^2 * V34 * Y1 * Y2 * Y4 - U12 * U24 * U34 * V13 * V23^2 * V34 * Y1 * Y3 * Y4 + U12 * U24 * U34 * V13 * V23^2 * V34 * Y2^2 * Y4 - U12 * U24 * U34 * V13 * V23^2 * V34 * Y2 * Y3 * Y4 - U12 * U24 * U34 * V13 * V23^2 * V34 * Y2 * Y4^2 + U12 * U24 * U34 * V13 * V23^2 * V34 * Y3 * Y4^2 + U12 * U24 * U34 * V13 * V23^2 * Y2^2 - U12 * U24 * U34 * V13 * V23^2 * Y2 * Y3 - U12 * U24 * U34 * V13 * V23^2 * Y2 * Y4 + U12 * U24 * U34 * V13 * V23^2 * Y3 * Y4 - U12 * U24 * U34 * V13 * V23 * Y1 + U12 * U24 * U34 * V13 * V23 * Y4 - U12 * U24 * U34 * V13 + U12 * U24 * U34 * V23^2 * V34 * Y2^2 - U12 * U24 * U34 * V23^2 * V34 * Y2 * Y3 - U12 * U24 * U34 * V23^2 * V34 * Y2 * Y4 + U12 * U24 * U34 * V23^2 * V34 * Y3 * Y4 + U12 * U24 * U34 * V23 - U12 * U24 * V13 * V23^2 * V34^2 * H2 * Y1 * Y2 + U12 * U24 * V13 * V23^2 * V34^2 * H2 * Y1 * Y4 + U12 * U24 * V13 * V23^2 * V34^2 * H2 * Y2 * Y4 - U12 * U24 * V13 * V23^2 * V34^2 * H2 * Y4^2 - U12 * U24 * V13 * V23^2 * V34^2 * H4 * Y1 * Y2 * Y3 + U12 * U24 * V13 * V23^2 * V34^2 * H4 * Y1 * Y3 * Y4 + U12 * U24 * V13 * V23^2 * V34^2 * H4 * Y2 * Y3 * Y4 - U12 * U24 * V13 * V23^2 * V34^2 * H4 * Y3 * Y4^2 + U12 * U24 * V13 * V23^2 * V34 * H2 * Y2 - U12 * U24 * V13 * V23^2 * V34 * H2 * Y4 + U12 * U24 * V13 * V23^2 * V34 * H4 * Y2 * Y3 - U12 * U24 * V13 * V23^2 * V34 * H4 * Y3 * Y4 + U12 * U24 * V23^2 * V34^2 * H2 * Y2 - U12 * U24 * V23^2 * V34^2 * H2 * Y4 + U12 * U24 * V23^2 * V34^2 * H4 * Y2 * Y3 - U12 * U24 * V23^2 * V34^2 * H4 * Y3 * Y4 + U12 * U34 * V13 * V23^2 * V24 * V34 * H2 * Y1 * Y3 - U12 * U34 * V13 * V23^2 * V24 * V34 * H2 * Y1 * Y4 - U12 * U34 * V13 * V23^2 * V24 * V34 * H2 * Y3 * Y4 + U12 * U34 * V13 * V23^2 * V24 * V34 * H2 * Y4^2 + U12 * U34 * V13 * V23^2 * V24 * V34 * H4 * Y1 * Y2 * Y3 - U12 * U34 * V13 * V23^2 * V24 * V34 * H4 * Y1 * Y2 * Y4 - U12 * U34 * V13 * V23^2 * V24 * V34 * H4 * Y2 * Y3 * Y4 + U12 * U34 * V13 * V23^2 * V24 * V34 * H4 * Y2 * Y4^2 - U12 * U34 * V13 * V23^2 * V34 * H2 * Y3 + U12 * U34 * V13 * V23^2 * V34 * H2 * Y4 - U12 * U34 * V13 * V23^2 * V34 * H4 * Y2 * Y3 + U12 * U34 * V13 * V23^2 * V34 * H4 * Y2 * Y4 + U12 * U34 * V13 * V23 * V24 * V34 * H2 * Y3 - U12 * U34 * V13 * V23 * V24 * V34 * H2 * Y4 + U12 * U34 * V13 * V23 * V24 * V34 * H4 * Y2 * Y3 - U12 * U34 * V13 * V23 * V24 * V34 * H4 * Y2 * Y4 - U12 * U34 * V23^2 * V24 * V34 * H2 * Y3 + U12 * U34 * V23^2 * V24 * V34 * H2 * Y4 - U12 * U34 * V23^2 * V24 * V34 * H4 * Y2 * Y3 + U12 * U34 * V23^2 * V24 * V34 * H4 * Y2 * Y4 - U13 * U23 * U24 * V12 * V23 * V34 * Y1 * Y2 + U13 * U23 * U24 * V12 * V23 * V34 * Y1 * Y4 + U13 * U23 * U24 * V12 * V23 * V34 * Y2 * Y4 - U13 * U23 * U24 * V12 * V23 * V34 * Y4^2 + U13 * U23 * U24 * V12 * V23 * Y2 - U13 * U23 * U24 * V12 * V23 * Y4 - U13 * U23 * U24 * V12 * V34 * Y1 + U13 * U23 * U24 * V12 * V34 * Y2 + U13 * U23 * U24 * V23 * V34 * Y2 - U13 * U23 * U24 * V23 * V34 * Y4 + U13 * U23 * U24 * V34 - U13 * U23 * U34 * V12 * V23 * V24 * V34 * Y1 * Y2^2 + U13 * U23 * U34 * V12 * V23 * V24 * V34 * Y1 * Y2 * Y3 + U13 * U23 * U34 * V12 * V23 * V24 * V34 * Y1 * Y2 * Y4 - U13 * U23 * U34 * V12 * V23 * V24 * V34 * Y1 * Y3 * Y4 + U13 * U23 * U34 * V12 * V23 * V24 * V34 * Y2^2 * Y4 - U13 * U23 * U34 * V12 * V23 * V24 * V34 * Y2 * Y3 * Y4 - U13 * U23 * U34 * V12 * V23 * V24 * V34 * Y2 * Y4^2 + U13 * U23 * U34 * V12 * V23 * V24 * V34 * Y3 * Y4^2 + U13 * U23 * U34 * V12 * V23 * V24 * Y2^2 - 2 * U13 * U23 * U34 * V12 * V23 * V24 * Y2 * Y4 + U13 * U23 * U34 * V12 * V23 * V24 * Y4^2 + U13 * U23 * U34 * V12 * V23 * V34 * Y1 * Y2 - U13 * U23 * U34 * V12 * V23 * V34 * Y1 * Y4 - U13 * U23 * U34 * V12 * V23 * V34 * Y2 * Y3 + U13 * U23 * U34 * V12 * V23 * V34 * Y3 * Y4 - U13 * U23 * U34 * V12 * V23 * Y2 + U13 * U23 * U34 * V12 * V23 * Y4 - U13 * U23 * U34 * V12 * V24 * V34 * Y1 * Y2 + U13 * U23 * U34 * V12 * V24 * V34 * Y1 * Y4 + U13 * U23 * U34 * V12 * V24 * V34 * Y2^2 - U13 * U23 * U34 * V12 * V24 * V34 * Y2 * Y4 - U13 * U23 * U34 * V12 * V24 * Y1 + U13 * U23 * U34 * V12 * V24 * Y2 + U13 * U23 * U34 * V12 * V34 * Y1 - U13 * U23 * U34 * V12 * V34 * Y2 + U13 * U23 * U34 * V23 * V24 * V34 * Y2^2 - U13 * U23 * U34 * V23 * V24 * V34 * Y2 * Y3 - U13 * U23 * U34 * V23 * V24 * V34 * Y2 * Y4 + U13 * U23 * U34 * V23 * V24 * V34 * Y3 * Y4 - U13 * U23 * U34 * V23 * V34 * Y2 + U13 * U23 * U34 * V23 * V34 * Y4 + U13 * U23 * U34 * V24 * V34 * Y2 - U13 * U23 * U34 * V24 * V34 * Y4 + U13 * U23 * U34 * V24 - U13 * U23 * U34 * V34 - U13 * U23 * V12 * V23 * V24 * V34^2 * H2 * Y1 * Y2 + U13 * U23 * V12 * V23 * V24 * V34^2 * H2 * Y1 * Y3 + U13 * U23 * V12 * V23 * V24 * V34^2 * H2 * Y2 * Y4 - U13 * U23 * V12 * V23 * V24 * V34^2 * H2 * Y3 * Y4 - U13 * U23 * V12 * V23 * V24 * V34^2 * H4 * Y1 * Y2 * Y4 + U13 * U23 * V12 * V23 * V24 * V34^2 * H4 * Y1 * Y3 * Y4 + U13 * U23 * V12 * V23 * V24 * V34^2 * H4 * Y2 * Y4^2 - U13 * U23 * V12 * V23 * V24 * V34^2 * H4 * Y3 * Y4^2 - U13 * U23 * V12 * V23 * V24 * V34 * H2 * Y1 + U13 * U23 * V12 * V23 * V24 * V34 * H2 * Y2 - U13 * U23 * V12 * V23 * V24 * V34 * H4 * Y1 * Y4 + U13 * U23 * V12 * V23 * V24 * V34 * H4 * Y2 * Y4 + U13 * U23 * V12 * V23 * V34^2 * H2 * Y1 - U13 * U23 * V12 * V23 * V34^2 * H2 * Y3 + U13 * U23 * V12 * V23 * V34^2 * H4 * Y1 * Y4 - U13 * U23 * V12 * V23 * V34^2 * H4 * Y3 * Y4 - U13 * U23 * V12 * V24 * V34^2 * H2 * Y1 + U13 * U23 * V12 * V24 * V34^2 * H2 * Y2 - U13 * U23 * V12 * V24 * V34^2 * H4 * Y1 * Y4 + U13 * U23 * V12 * V24 * V34^2 * H4 * Y2 * Y4 + U13 * U23 * V23 * V24 * V34^2 * H2 * Y2 - U13 * U23 * V23 * V24 * V34^2 * H2 * Y3 + U13 * U23 * V23 * V24 * V34^2 * H4 * Y2 * Y4 - U13 * U23 * V23 * V24 * V34^2 * H4 * Y3 * Y4 + U13 * U23 * V23 * V24 * V34 * H2 + U13 * U23 * V23 * V24 * V34 * H4 * Y4 - U13 * U23 * V23 * V34^2 * H2 - U13 * U23 * V23 * V34^2 * H4 * Y4 + U13 * U23 * V24 * V34^2 * H2 + U13 * U23 * V24 * V34^2 * H4 * Y4 + U13 * U24 * U34 * V12 * V23^2 * V34 * Y1 * Y2^2 - U13 * U24 * U34 * V12 * V23^2 * V34 * Y1 * Y2 * Y3 - U13 * U24 * U34 * V12 * V23^2 * V34 * Y1 * Y2 * Y4 + U13 * U24 * U34 * V12 * V23^2 * V34 * Y1 * Y3 * Y4 - U13 * U24 * U34 * V12 * V23^2 * V34 * Y2^2 * Y4 + U13 * U24 * U34 * V12 * V23^2 * V34 * Y2 * Y3 * Y4 + U13 * U24 * U34 * V12 * V23^2 * V34 * Y2 * Y4^2 - U13 * U24 * U34 * V12 * V23^2 * V34 * Y3 * Y4^2 - U13 * U24 * U34 * V12 * V23^2 * Y2^2 + U13 * U24 * U34 * V12 * V23^2 * Y2 * Y3 + U13 * U24 * U34 * V12 * V23^2 * Y2 * Y4 - U13 * U24 * U34 * V12 * V23^2 * Y3 * Y4 - U13 * U24 * U34 * V12 * V23 * V34 * Y2^2 + U13 * U24 * U34 * V12 * V23 * V34 * Y2 * Y3 + U13 * U24 * U34 * V12 * V23 * V34 * Y2 * Y4 - U13 * U24 * U34 * V12 * V23 * V34 * Y3 * Y4 + U13 * U24 * U34 * V12 * V23 * Y1 - U13 * U24 * U34 * V12 * V23 * Y4 - U13 * U24 * U34 * V23^2 * V34 * Y2^2 + U13 * U24 * U34 * V23^2 * V34 * Y2 * Y3 + U13 * U24 * U34 * V23^2 * V34 * Y2 * Y4 - U13 * U24 * U34 * V23^2 * V34 * Y3 * Y4 - U13 * U24 * U34 * V23 + U13 * U24 * V12 * V23^2 * V34^2 * H2 * Y1 * Y2 - U13 * U24 * V12 * V23^2 * V34^2 * H2 * Y1 * Y4 - U13 * U24 * V12 * V23^2 * V34^2 * H2 * Y2 * Y4 + U13 * U24 * V12 * V23^2 * V34^2 * H2 * Y4^2 + U13 * U24 * V12 * V23^2 * V34^2 * H4 * Y1 * Y2 * Y3 - U13 * U24 * V12 * V23^2 * V34^2 * H4 * Y1 * Y3 * Y4 - U13 * U24 * V12 * V23^2 * V34^2 * H4 * Y2 * Y3 * Y4 + U13 * U24 * V12 * V23^2 * V34^2 * H4 * Y3 * Y4^2 - U13 * U24 * V12 * V23^2 * V34 * H2 * Y2 + U13 * U24 * V12 * V23^2 * V34 * H2 * Y4 - U13 * U24 * V12 * V23^2 * V34 * H4 * Y2 * Y3 + U13 * U24 * V12 * V23^2 * V34 * H4 * Y3 * Y4 - U13 * U24 * V12 * V23 * V34^2 * H2 * Y2 + U13 * U24 * V12 * V23 * V34^2 * H2 * Y4 - U13 * U24 * V12 * V23 * V34^2 * H4 * Y2 * Y3 + U13 * U24 * V12 * V23 * V34^2 * H4 * Y3 * Y4 - U13 * U24 * V23^2 * V34^2 * H2 * Y2 + U13 * U24 * V23^2 * V34^2 * H2 * Y4 - U13 * U24 * V23^2 * V34^2 * H4 * Y2 * Y3 + U13 * U24 * V23^2 * V34^2 * H4 * Y3 * Y4 - U13 * U34 * V12 * V23^2 * V24 * V34 * H2 * Y1 * Y3 + U13 * U34 * V12 * V23^2 * V24 * V34 * H2 * Y1 * Y4 + U13 * U34 * V12 * V23^2 * V24 * V34 * H2 * Y3 * Y4 - U13 * U34 * V12 * V23^2 * V24 * V34 * H2 * Y4^2 - U13 * U34 * V12 * V23^2 * V24 * V34 * H4 * Y1 * Y2 * Y3 + U13 * U34 * V12 * V23^2 * V24 * V34 * H4 * Y1 * Y2 * Y4 + U13 * U34 * V12 * V23^2 * V24 * V34 * H4 * Y2 * Y3 * Y4 - U13 * U34 * V12 * V23^2 * V24 * V34 * H4 * Y2 * Y4^2 + U13 * U34 * V12 * V23^2 * V34 * H2 * Y3 - U13 * U34 * V12 * V23^2 * V34 * H2 * Y4 + U13 * U34 * V12 * V23^2 * V34 * H4 * Y2 * Y3 - U13 * U34 * V12 * V23^2 * V34 * H4 * Y2 * Y4 + U13 * U34 * V23^2 * V24 * V34 * H2 * Y3 - U13 * U34 * V23^2 * V24 * V34 * H2 * Y4 + U13 * U34 * V23^2 * V24 * V34 * H4 * Y2 * Y3 - U13 * U34 * V23^2 * V24 * V34 * H4 * Y2 * Y4, E3 * E4 * H4^3 - E3 * H4^2 - 2 * E4^2 * H2 * H4 - E4^2 * H3 * H4^2 - E4^2 * H4^2 * Y1 - E4^2 * H4^2 * Y2 - E4^2 * H4^2 * Y3 - E4^2 * H4^2 * Y4 + 2 * E4 * H2 + 5 * E4 * H3 * H4 + E4 * H4^2 * X1 + E4 * H4^2 * X2 + E4 * H4^2 * X3 + E4 * H4^2 * X4 + 3 * E4 * H4 * Y1 + 3 * E4 * H4 * Y2 + 3 * E4 * H4 * Y3 + 3 * E4 * H4 * Y4 - 4 * H3 - H4 * X1 - H4 * X2 - H4 * X3 - H4 * X4 - 2 * Y1 - 2 * Y2 - 2 * Y3 - 2 * Y4, U12 * U13 * U14 + U12 * U13 * U24 * V14 * Y1 - U12 * U13 * U24 * V14 * Y4 - U12 * U13 * U24 + U12 * U13 * U34 * V14 * V24 * Y1 * Y2 - U12 * U13 * U34 * V14 * V24 * Y1 * Y4 - U12 * U13 * U34 * V14 * V24 * Y2 * Y4 + U12 * U13 * U34 * V14 * V24 * Y4^2 - U12 * U13 * U34 * V24 * Y2 + U12 * U13 * U34 * V24 * Y4 + U12 * U13 * V14 * V24 * V34 * H2 * Y1 - U12 * U13 * V14 * V24 * V34 * H2 * Y4 + U12 * U13 * V14 * V24 * V34 * H4 * Y1 * Y4 - U12 * U13 * V14 * V24 * V34 * H4 * Y4^2 - U12 * U13 * V24 * V34 * H2 - U12 * U13 * V24 * V34 * H4 * Y4 + U12 * U14 * U23 * V13 * Y1 - U12 * U14 * U23 * V13 * Y3 - U12 * U14 * U23 - U12 * U14 * U34 * V13 * V23 * Y1 * Y2 + U12 * U14 * U34 * V13 * V23 * Y1 * Y3 + U12 * U14 * U34 * V13 * V23 * Y2 * Y4 - U12 * U14 * U34 * V13 * V23 * Y3 * Y4 + U12 * U14 * U34 * V23 * Y2 - U12 * U14 * U34 * V23 * Y3 - U12 * U14 * V13 * V23 * V34 * H2 * Y1 + U12 * U14 * V13 * V23 * V34 * H2 * Y4 - U12 * U14 * V13 * V23 * V34 * H4 * Y1 * Y3 + U12 * U14 * V13 * V23 * V34 * H4 * Y3 * Y4 + U12 * U14 * V13 * V23 * H2 + U12 * U14 * V13 * V23 * H4 * Y3 + U12 * U14 * V23 * V34 * H2 + U12 * U14 * V23 * V34 * H4 * Y3 - U12 * U23 * U24 * V13 * Y1 + U12 * U23 * U24 * V13 * Y3 - U12 * U23 * U24 * V14 * Y1 + U12 * U23 * U24 * V14 * Y4 + U12 * U23 * U24 + U12 * U23 * U34 * V13 * V14 * Y1^2 - U12 * U23 * U34 * V13 * V14 * Y1 * Y3 - U12 * U23 * U34 * V13 * V14 * Y1 * Y4 + U12 * U23 * U34 * V13 * V14 * Y3 * Y4 - U12 * U23 * U34 * V13 * V24 * Y1 * Y2 + U12 * U23 * U34 * V13 * V24 * Y1 * Y4 + U12 * U23 * U34 * V13 * V24 * Y2 * Y3 - U12 * U23 * U34 * V13 * V24 * Y3 * Y4 - U12 * U23 * U34 * V14 * V24 * Y1 * Y2 + U12 * U23 * U34 * V14 * V24 * Y1 * Y4 + U12 * U23 * U34 * V14 * V24 * Y2 * Y4 - U12 * U23 * U34 * V14 * V24 * Y4^2 + U12 * U23 * U34 * V24 * Y2 - U12 * U23 * U34 * V24 * Y4 + U12 * U23 * V13 * V14 * V24 * V34 * H2 * Y1^2 - U12 * U23 * V13 * V14 * V24 * V34 * H2 * Y1 * Y2 - U12 * U23 * V13 * V14 * V24 * V34 * H2 * Y1 * Y3 + U12 * U23 * V13 * V14 * V24 * V34 * H2 * Y2 * Y3 + U12 * U23 * V13 * V14 * V24 * V34 * H4 * Y1^2 * Y4 - U12 * U23 * V13 * V14 * V24 * V34 * H4 * Y1 * Y2 * Y4 - U12 * U23 * V13 * V14 * V24 * V34 * H4 * Y1 * Y3 * Y4 + U12 * U23 * V13 * V14 * V24 * V34 * H4 * Y2 * Y3 * Y4 + U12 * U23 * V13 * V14 * V34 * H2 * Y1 - U12 * U23 * V13 * V14 * V34 * H2 * Y3 + U12 * U23 * V13 * V14 * V34 * H4 * Y1 * Y4 - U12 * U23 * V13 * V14 * V34 * H4 * Y3 * Y4 - U12 * U23 * V13 * V24 * V34 * H2 * Y1 + U12 * U23 * V13 * V24 * V34 * H2 * Y3 - U12 * U23 * V13 * V24 * V34 * H4 * Y1 * Y4 + U12 * U23 * V13 * V24 * V34 * H4 * Y3 * Y4 - U12 * U23 * V14 * V24 * V34 * H2 * Y1 + U12 * U23 * V14 * V24 * V34 * H2 * Y4 - U12 * U23 * V14 * V24 * V34 * H4 * Y1 * Y4 + U12 * U23 * V14 * V24 * V34 * H4 * Y4^2 + U12 * U23 * V24 * V34 * H2 + U12 * U23 * V24 * V34 * H4 * Y4 - U12 * U24 * U34 * V13 * V14 * V23 * Y1 * Y2 * Y3 + U12 * U24 * U34 * V13 * V14 * V23 * Y1 * Y2 * Y4 + U12 * U24 * U34 * V13 * V14 * V23 * Y1 * Y3^2 - U12 * U24 * U34 * V13 * V14 * V23 * Y1 * Y3 * Y4 + U12 * U24 * U34 * V13 * V14 * V23 * Y2 * Y3 * Y4 - U12 * U24 * U34 * V13 * V14 * V23 * Y2 * Y4^2 - U12 * U24 * U34 * V13 * V14 * V23 * Y3^2 * Y4 + U12 * U24 * U34 * V13 * V14 * V23 * Y3 * Y4^2 - U12 * U24 * U34 * V13 * V14 * Y1^2 + U12 * U24 * U34 * V13 * V14 * Y1 * Y3 + U12 * U24 * U34 * V13 * V14 * Y1 * Y4 - U12 * U24 * U34 * V13 * V14 * Y3 * Y4 + U12 * U24 * U34 * V13 * V23 * Y1 * Y2 - U12 * U24 * U34 * V13 * V23 * Y1 * Y3 - U12 * U24 * U34 * V13 * V23 * Y2 * Y4 + U12 * U24 * U34 * V13 * V23 * Y3 * Y4 + U12 * U24 * U34 * V14 * V23 * Y1 * Y2 - U12 * U24 * U34 * V14 * V23 * Y1 * Y3 - U12 * U24 * U34 * V14 * V23 * Y2 * Y4 + U12 * U24 * U34 * V14 * V23 * Y3 * Y4 - U12 * U24 * U34 * V23 * Y2 + U12 * U24 * U34 * V23 * Y3 - U12 * U24 * V13 * V14 * V23 * V34 * H2 * Y1^2 + U12 * U24 * V13 * V14 * V23 * V34 * H2 * Y1 * Y2 - U12 * U24 * V13 * V14 * V23 * V34 * H2 * Y1 * Y3 + 2 * U12 * U24 * V13 * V14 * V23 * V34 * H2 * Y1 * Y4 - U12 * U24 * V13 * V14 * V23 * V34 * H2 * Y2 * Y4 + U12 * U24 * V13 * V14 * V23 * V34 * H2 * Y3 * Y4 - U12 * U24 * V13 * V14 * V23 * V34 * H2 * Y4^2 - U12 * U24 * V13 * V14 * V23 * V34 * H4 * Y1^2 * Y3 + U12 * U24 * V13 * V14 * V23 * V34 * H4 * Y1 * Y2 * Y3 - U12 * U24 * V13 * V14 * V23 * V34 * H4 * Y1 * Y3^2 + 2 * U12 * U24 * V13 * V14 * V23 * V34 * H4 * Y1 * Y3 * Y4 - U12 * U24 * V13 * V14 * V23 * V34 * H4 * Y2 * Y3 * Y4 + U12 * U24 * V13 * V14 * V23 * V34 * H4 * Y3^2 * Y4 - U12 * U24 * V13 * V14 * V23 * V34 * H4 * Y3 * Y4^2 + U12 * U24 * V13 * V14 * V23 * H2 * Y1 - U12 * U24 * V13 * V14 * V23 * H2 * Y4 + U12 * U24 * V13 * V14 * V23 * H4 * Y1 * Y3 - U12 * U24 * V13 * V14 * V23 * H4 * Y3 * Y4 - U12 * U24 * V13 * V14 * V34 * H2 * Y1 + U12 * U24 * V13 * V14 * V34 * H2 * Y4 - U12 * U24 * V13 * V14 * V34 * H4 * Y1 * Y3 + U12 * U24 * V13 * V14 * V34 * H4 * Y3 * Y4 + U12 * U24 * V13 * V23 * V34 * H2 * Y1 - U12 * U24 * V13 * V23 * V34 * H2 * Y4 + U12 * U24 * V13 * V23 * V34 * H4 * Y1 * Y3 - U12 * U24 * V13 * V23 * V34 * H4 * Y3 * Y4 - U12 * U24 * V13 * V23 * H2 - U12 * U24 * V13 * V23 * H4 * Y3 + U12 * U24 * V14 * V23 * V34 * H2 * Y1 - U12 * U24 * V14 * V23 * V34 * H2 * Y4 + U12 * U24 * V14 * V23 * V34 * H4 * Y1 * Y3 - U12 * U24 * V14 * V23 * V34 * H4 * Y3 * Y4 - U12 * U24 * V23 * V34 * H2 - U12 * U24 * V23 * V34 * H4 * Y3 + U12 * U34 * V13 * V14 * V23 * V24 * H2 * Y1 * Y3 - U12 * U34 * V13 * V14 * V23 * V24 * H2 * Y1 * Y4 - U12 * U34 * V13 * V14 * V23 * V24 * H2 * Y3 * Y4 + U12 * U34 * V13 * V14 * V23 * V24 * H2 * Y4^2 + U12 * U34 * V13 * V14 * V23 * V24 * H4 * Y1 * Y2 * Y3 - U12 * U34 * V13 * V14 * V23 * V24 * H4 * Y1 * Y2 * Y4 - U12 * U34 * V13 * V14 * V23 * V24 * H4 * Y2 * Y3 * Y4 + U12 * U34 * V13 * V14 * V23 * V24 * H4 * Y2 * Y4^2 - U12 * U34 * V13 * V23 * V24 * H2 * Y3 + U12 * U34 * V13 * V23 * V24 * H2 * Y4 - U12 * U34 * V13 * V23 * V24 * H4 * Y2 * Y3 + U12 * U34 * V13 * V23 * V24 * H4 * Y2 * Y4 - U13 * U14 * U23 * V12 * Y1 + U13 * U14 * U23 * V12 * Y3 + U13 * U14 * U23 - U13 * U14 * U24 * V12 * V23 * Y1 * Y2 + U13 * U14 * U24 * V12 * V23 * Y1 * Y3 + U13 * U14 * U24 * V12 * V23 * Y2 * Y3 - U13 * U14 * U24 * V12 * V23 * Y3^2 + U13 * U14 * U24 * V12 * Y2 - U13 * U14 * U24 * V12 * Y3 + U13 * U14 * U24 * V23 * Y2 - U13 * U14 * U24 * V23 * Y3 + U13 * U14 * V12 * V23 * V24 * H2 * Y1 - U13 * U14 * V12 * V23 * V24 * H2 * Y3 + U13 * U14 * V12 * V23 * V24 * H4 * Y1 * Y2 - U13 * U14 * V12 * V23 * V24 * H4 * Y2 * Y3 - U13 * U14 * V12 * V24 * H2 - U13 * U14 * V12 * V24 * H4 * Y2 - U13 * U14 * V23 * V24 * H2 - U13 * U14 * V23 * V24 * H4 * Y2 + U13 * U23 * U24 * V12 * Y1 - U13 * U23 * U24 * V12 * Y3 + U13 * U23 * U24 * V14 * Y1 - U13 * U23 * U24 * V14 * Y4 - U13 * U23 * U24 - U13 * U23 * U34 * V12 * V14 * Y1^2 + U13 * U23 * U34 * V12 * V14 * Y1 * Y3 + U13 * U23 * U34 * V12 * V14 * Y1 * Y4 - U13 * U23 * U34 * V12 * V14 * Y3 * Y4 + U13 * U23 * U34 * V12 * V24 * Y1 * Y2 - U13 * U23 * U34 * V12 * V24 * Y1 * Y4 - U13 * U23 * U34 * V12 * V24 * Y2 * Y3 + U13 * U23 * U34 * V12 * V24 * Y3 * Y4 + U13 * U23 * U34 * V14 * V24 * Y1 * Y2 - U13 * U23 * U34 * V14 * V24 * Y1 * Y4 - U13 * U23 * U34 * V14 * V24 * Y2 * Y4 + U13 * U23 * U34 * V14 * V24 * Y4^2 - U13 * U23 * U34 * V24 * Y2 + U13 * U23 * U34 * V24 * Y4 - U13 * U23 * V12 * V14 * V24 * V34 * H2 * Y1^2 + U13 * U23 * V12 * V14 * V24 * V34 * H2 * Y1 * Y2 + U13 * U23 * V12 * V14 * V24 * V34 * H2 * Y1 * Y3 - U13 * U23 * V12 * V14 * V24 * V34 * H2 * Y2 * Y3 - U13 * U23 * V12 * V14 * V24 * V34 * H4 * Y1^2 * Y4 + U13 * U23 * V12 * V14 * V24 * V34 * H4 * Y1 * Y2 * Y4 + U13 * U23 * V12 * V14 * V24 * V34 * H4 * Y1 * Y3 * Y4 - U13 * U23 * V12 * V14 * V24 * V34 * H4 * Y2 * Y3 * Y4 - U13 * U23 * V12 * V14 * V34 * H2 * Y1 + U13 * U23 * V12 * V14 * V34 * H2 * Y3 - U13 * U23 * V12 * V14 * V34 * H4 * Y1 * Y4 + U13 * U23 * V12 * V14 * V34 * H4 * Y3 * Y4 + U13 * U23 * V12 * V24 * V34 * H2 * Y1 - U13 * U23 * V12 * V24 * V34 * H2 * Y3 + U13 * U23 * V12 * V24 * V34 * H4 * Y1 * Y4 - U13 * U23 * V12 * V24 * V34 * H4 * Y3 * Y4 + U13 * U23 * V14 * V24 * V34 * H2 * Y1 - U13 * U23 * V14 * V24 * V34 * H2 * Y4 + U13 * U23 * V14 * V24 * V34 * H4 * Y1 * Y4 - U13 * U23 * V14 * V24 * V34 * H4 * Y4^2 - U13 * U23 * V24 * V34 * H2 - U13 * U23 * V24 * V34 * H4 * Y4 - U13 * U24 * U34 * V12 * V14 * V23 * Y1 * Y2^2 + U13 * U24 * U34 * V12 * V14 * V23 * Y1 * Y2 * Y3 + U13 * U24 * U34 * V12 * V14 * V23 * Y1 * Y2 * Y4 - U13 * U24 * U34 * V12 * V14 * V23 * Y1 * Y3 * Y4 + U13 * U24 * U34 * V12 * V14 * V23 * Y2^2 * Y4 - U13 * U24 * U34 * V12 * V14 * V23 * Y2 * Y3 * Y4 - U13 * U24 * U34 * V12 * V14 * V23 * Y2 * Y4^2 + U13 * U24 * U34 * V12 * V14 * V23 * Y3 * Y4^2 + U13 * U24 * U34 * V12 * V14 * Y1^2 - U13 * U24 * U34 * V12 * V14 * Y1 * Y3 - U13 * U24 * U34 * V12 * V14 * Y1 * Y4 + U13 * U24 * U34 * V12 * V14 * Y3 * Y4 - U13 * U24 * V12 * V14 * V23 * V34 * H2 * Y1 * Y2 + U13 * U24 * V12 * V14 * V23 * V34 * H2 * Y1 * Y4 + U13 * U24 * V12 * V14 * V23 * V34 * H2 * Y2 * Y4 - U13 * U24 * V12 * V14 * V23 * V34 * H2 * Y4^2 - U13 * U24 * V12 * V14 * V23 * V34 * H4 * Y1 * Y2 * Y3 + U13 * U24 * V12 * V14 * V23 * V34 * H4 * Y1 * Y3 * Y4 + U13 * U24 * V12 * V14 * V23 * V34 * H4 * Y2 * Y3 * Y4 - U13 * U24 * V12 * V14 * V23 * V34 * H4 * Y3 * Y4^2 + U13 * U24 * V12 * V14 * V23 * H2 * Y1 + U13 * U24 * V12 * V14 * V23 * H2 * Y2 - U13 * U24 * V12 * V14 * V23 * H2 * Y3 - U13 * U24 * V12 * V14 * V23 * H2 * Y4 + U13 * U24 * V12 * V14 * V23 * H4 * Y1 * Y2 - U13 * U24 * V12 * V14 * V23 * H4 * Y3 * Y4 + U13 * U24 * V12 * V14 * V34 * H2 * Y1 - U13 * U24 * V12 * V14 * V34 * H2 * Y3 + U13 * U24 * V12 * V14 * V34 * H4 * Y1 * Y4 - U13 * U24 * V12 * V14 * V34 * H4 * Y3 * Y4 + U13 * U34 * V12 * V14 * V23 * V24 * H2 * Y1^2 + U13 * U34 * V12 * V14 * V23 * V24 * H2 * Y1 * Y2 - U13 * U34 * V12 * V14 * V23 * V24 * H2 * Y1 * Y3 - 2 * U13 * U34 * V12 * V14 * V23 * V24 * H2 * Y1 * Y4 - U13 * U34 * V12 * V14 * V23 * V24 * H2 * Y2 * Y4 + U13 * U34 * V12 * V14 * V23 * V24 * H2 * Y3 * Y4 + U13 * U34 * V12 * V14 * V23 * V24 * H2 * Y4^2 + U13 * U34 * V12 * V14 * V23 * V24 * H4 * Y1^2 * Y2 + U13 * U34 * V12 * V14 * V23 * V24 * H4 * Y1 * Y2^2 - U13 * U34 * V12 * V14 * V23 * V24 * H4 * Y1 * Y2 * Y3 - 2 * U13 * U34 * V12 * V14 * V23 * V24 * H4 * Y1 * Y2 * Y4 - U13 * U34 * V12 * V14 * V23 * V24 * H4 * Y2^2 * Y4 + U13 * U34 * V12 * V14 * V23 * V24 * H4 * Y2 * Y3 * Y4 + U13 * U34 * V12 * V14 * V23 * V24 * H4 * Y2 * Y4^2 - U13 * U34 * V12 * V14 * V23 * H2 * Y1 + U13 * U34 * V12 * V14 * V23 * H2 * Y4 - U13 * U34 * V12 * V14 * V23 * H4 * Y1 * Y2 + U13 * U34 * V12 * V14 * V23 * H4 * Y2 * Y4 - U13 * U34 * V12 * V14 * V24 * H2 * Y1 + U13 * U34 * V12 * V14 * V24 * H2 * Y4 - U13 * U34 * V12 * V14 * V24 * H4 * Y1 * Y2 + U13 * U34 * V12 * V14 * V24 * H4 * Y2 * Y4 - U13 * U34 * V12 * V23 * V24 * H2 * Y1 + U13 * U34 * V12 * V23 * V24 * H2 * Y3 - U13 * U34 * V12 * V23 * V24 * H4 * Y1 * Y2 + U13 * U34 * V12 * V23 * V24 * H4 * Y2 * Y3 + U13 * U34 * V12 * V24 * H2 + U13 * U34 * V12 * V24 * H4 * Y2 - U13 * U34 * V14 * V23 * V24 * H2 * Y1 + U13 * U34 * V14 * V23 * V24 * H2 * Y4 - U13 * U34 * V14 * V23 * V24 * H4 * Y1 * Y2 + U13 * U34 * V14 * V23 * V24 * H4 * Y2 * Y4 + U13 * U34 * V23 * V24 * H2 + U13 * U34 * V23 * V24 * H4 * Y2 + U14 * U23 * U24 * V12 * V13 * Y1 * Y2 - U14 * U23 * U24 * V12 * V13 * Y1 * Y3 - U14 * U23 * U24 * V12 * V13 * Y2 * Y3 + U14 * U23 * U24 * V12 * V13 * Y3^2 - U14 * U23 * U24 * V12 * Y2 + U14 * U23 * U24 * V12 * Y3 + U14 * U23 * U34 * V12 * V13 * V24 * Y1 * Y2^2 - U14 * U23 * U34 * V12 * V13 * V24 * Y1 * Y2 * Y3 - U14 * U23 * U34 * V12 * V13 * V24 * Y1 * Y2 * Y4 + U14 * U23 * U34 * V12 * V13 * V24 * Y1 * Y3 * Y4 - U14 * U23 * U34 * V12 * V13 * V24 * Y2^2 * Y4 + U14 * U23 * U34 * V12 * V13 * V24 * Y2 * Y3 * Y4 + U14 * U23 * U34 * V12 * V13 * V24 * Y2 * Y4^2 - U14 * U23 * U34 * V12 * V13 * V24 * Y3 * Y4^2 - U14 * U23 * U34 * V12 * V24 * Y2^2 + U14 * U23 * U34 * V12 * V24 * Y2 * Y3 + U14 * U23 * U34 * V12 * V24 * Y2 * Y4 - U14 * U23 * U34 * V12 * V24 * Y3 * Y4 + U14 * U23 * V12 * V13 * V24 * V34 * H2 * Y1 * Y2 - U14 * U23 * V12 * V13 * V24 * V34 * H2 * Y1 * Y3 - U14 * U23 * V12 * V13 * V24 * V34 * H2 * Y2 * Y4 + U14 * U23 * V12 * V13 * V24 * V34 * H2 * Y3 * Y4 + U14 * U23 * V12 * V13 * V24 * V34 * H4 * Y1 * Y2 * Y4 - U14 * U23 * V12 * V13 * V24 * V34 * H4 * Y1 * Y3 * Y4 - U14 * U23 * V12 * V13 * V24 * V34 * H4 * Y2 * Y4^2 + U14 * U23 * V12 * V13 * V24 * V34 * H4 * Y3 * Y4^2 - U14 * U23 * V12 * V13 * V24 * H2 * Y2 + U14 * U23 * V12 * V13 * V24 * H2 * Y3 - U14 * U23 * V12 * V13 * V24 * H4 * Y2 * Y4 + U14 * U23 * V12 * V13 * V24 * H4 * Y3 * Y4 - U14 * U23 * V12 * V24 * V34 * H2 * Y2 + U14 * U23 * V12 * V24 * V34 * H2 * Y3 - U14 * U23 * V12 * V24 * V34 * H4 * Y2 * Y4 + U14 * U23 * V12 * V24 * V34 * H4 * Y3 * Y4 + U14 * U24 * U34 * V12 * V13 * V23 * Y1 * Y2 * Y3 - U14 * U24 * U34 * V12 * V13 * V23 * Y1 * Y2 * Y4 - U14 * U24 * U34 * V12 * V13 * V23 * Y1 * Y3^2 + U14 * U24 * U34 * V12 * V13 * V23 * Y1 * Y3 * Y4 - U14 * U24 * U34 * V12 * V13 * V23 * Y2 * Y3 * Y4 + U14 * U24 * U34 * V12 * V13 * V23 * Y2 * Y4^2 + U14 * U24 * U34 * V12 * V13 * V23 * Y3^2 * Y4 - U14 * U24 * U34 * V12 * V13 * V23 * Y3 * Y4^2 - U14 * U24 * U34 * V12 * V23 * Y1 * Y2 + U14 * U24 * U34 * V12 * V23 * Y1 * Y3 + U14 * U24 * U34 * V12 * V23 * Y2^2 - U14 * U24 * U34 * V12 * V23 * Y2 * Y3 - U14 * U24 * U34 * V13 * V23 * Y1 * Y2 + U14 * U24 * U34 * V13 * V23 * Y1 * Y3 + U14 * U24 * U34 * V13 * V23 * Y2 * Y4 - U14 * U24 * U34 * V13 * V23 * Y3 * Y4 + U14 * U24 * U34 * V23 * Y2 - U14 * U24 * U34 * V23 * Y3 + U14 * U24 * V12 * V13 * V23 * V34 * H2 * Y1^2 - U14 * U24 * V12 * V13 * V23 * V34 * H2 * Y1 * Y2 + U14 * U24 * V12 * V13 * V23 * V34 * H2 * Y1 * Y3 - 2 * U14 * U24 * V12 * V13 * V23 * V34 * H2 * Y1 * Y4 + U14 * U24 * V12 * V13 * V23 * V34 * H2 * Y2 * Y4 - U14 * U24 * V12 * V13 * V23 * V34 * H2 * Y3 * Y4 + U14 * U24 * V12 * V13 * V23 * V34 * H2 * Y4^2 + U14 * U24 * V12 * V13 * V23 * V34 * H4 * Y1^2 * Y3 - U14 * U24 * V12 * V13 * V23 * V34 * H4 * Y1 * Y2 * Y3 + U14 * U24 * V12 * V13 * V23 * V34 * H4 * Y1 * Y3^2 - 2 * U14 * U24 * V12 * V13 * V23 * V34 * H4 * Y1 * Y3 * Y4 + U14 * U24 * V12 * V13 * V23 * V34 * H4 * Y2 * Y3 * Y4 - U14 * U24 * V12 * V13 * V23 * V34 * H4 * Y3^2 * Y4 + U14 * U24 * V12 * V13 * V23 * V34 * H4 * Y3 * Y4^2 - 2 * U14 * U24 * V12 * V13 * V23 * H2 * Y1 + U14 * U24 * V12 * V13 * V23 * H2 * Y2 + U14 * U24 * V12 * V13 * V23 * H2 * Y4 - 2 * U14 * U24 * V12 * V13 * V23 * H4 * Y1 * Y3 + U14 * U24 * V12 * V13 * V23 * H4 * Y2 * Y3 + U14 * U24 * V12 * V13 * V23 * H4 * Y3 * Y4 - U14 * U24 * V12 * V23 * V34 * H2 * Y1 + U14 * U24 * V12 * V23 * V34 * H2 * Y2 - U14 * U24 * V12 * V23 * V34 * H4 * Y1 * Y3 + U14 * U24 * V12 * V23 * V34 * H4 * Y2 * Y3 - U14 * U24 * V13 * V23 * V34 * H2 * Y1 + U14 * U24 * V13 * V23 * V34 * H2 * Y4 - U14 * U24 * V13 * V23 * V34 * H4 * Y1 * Y3 + U14 * U24 * V13 * V23 * V34 * H4 * Y3 * Y4 + U14 * U24 * V13 * V23 * H2 + U14 * U24 * V13 * V23 * H4 * Y3 + U14 * U24 * V23 * V34 * H2 + U14 * U24 * V23 * V34 * H4 * Y3 - U14 * U34 * V12 * V13 * V23 * V24 * H2 * Y1^2 - U14 * U34 * V12 * V13 * V23 * V24 * H2 * Y1 * Y2 + U14 * U34 * V12 * V13 * V23 * V24 * H2 * Y1 * Y3 + 2 * U14 * U34 * V12 * V13 * V23 * V24 * H2 * Y1 * Y4 + U14 * U34 * V12 * V13 * V23 * V24 * H2 * Y2 * Y4 - U14 * U34 * V12 * V13 * V23 * V24 * H2 * Y3 * Y4 - U14 * U34 * V12 * V13 * V23 * V24 * H2 * Y4^2 - U14 * U34 * V12 * V13 * V23 * V24 * H4 * Y1^2 * Y2 - U14 * U34 * V12 * V13 * V23 * V24 * H4 * Y1 * Y2^2 + U14 * U34 * V12 * V13 * V23 * V24 * H4 * Y1 * Y2 * Y3 + 2 * U14 * U34 * V12 * V13 * V23 * V24 * H4 * Y1 * Y2 * Y4 + U14 * U34 * V12 * V13 * V23 * V24 * H4 * Y2^2 * Y4 - U14 * U34 * V12 * V13 * V23 * V24 * H4 * Y2 * Y3 * Y4 - U14 * U34 * V12 * V13 * V23 * V24 * H4 * Y2 * Y4^2 + U14 * U34 * V12 * V13 * V23 * H2 * Y1 - U14 * U34 * V12 * V13 * V23 * H2 * Y4 + U14 * U34 * V12 * V13 * V23 * H4 * Y1 * Y2 - U14 * U34 * V12 * V13 * V23 * H4 * Y2 * Y4 + U14 * U34 * V12 * V13 * V24 * H2 * Y1 - U14 * U34 * V12 * V13 * V24 * H2 * Y4 + U14 * U34 * V12 * V13 * V24 * H4 * Y1 * Y2 - U14 * U34 * V12 * V13 * V24 * H4 * Y2 * Y4 + U14 * U34 * V12 * V23 * V24 * H2 * Y1 - U14 * U34 * V12 * V23 * V24 * H2 * Y3 + U14 * U34 * V12 * V23 * V24 * H4 * Y1 * Y2 - U14 * U34 * V12 * V23 * V24 * H4 * Y2 * Y3 - U14 * U34 * V12 * V24 * H2 - U14 * U34 * V12 * V24 * H4 * Y2 + U14 * U34 * V13 * V23 * V24 * H2 * Y1 - U14 * U34 * V13 * V23 * V24 * H2 * Y4 + U14 * U34 * V13 * V23 * V24 * H4 * Y1 * Y2 - U14 * U34 * V13 * V23 * V24 * H4 * Y2 * Y4 - U14 * U34 * V23 * V24 * H2 - U14 * U34 * V23 * V24 * H4 * Y2 - U23 * U24 * V12 * V13 * V14 * H2 * Y2 + U23 * U24 * V12 * V13 * V14 * H2 * Y3 - U23 * U24 * V12 * V13 * V14 * H4 * Y1 * Y2 + U23 * U24 * V12 * V13 * V14 * H4 * Y1 * Y3 + U23 * U24 * V12 * V14 * H2 + U23 * U24 * V12 * V14 * H4 * Y1 - U23 * U24 * V13 * V14 * H2 - U23 * U24 * V13 * V14 * H4 * Y1 - U23 * U34 * V12 * V13 * V14 * V24 * H2 * Y2^2 + U23 * U34 * V12 * V13 * V14 * V24 * H2 * Y2 * Y3 + U23 * U34 * V12 * V13 * V14 * V24 * H2 * Y2 * Y4 - U23 * U34 * V12 * V13 * V14 * V24 * H2 * Y3 * Y4 - U23 * U34 * V12 * V13 * V14 * V24 * H4 * Y1 * Y2^2 + U23 * U34 * V12 * V13 * V14 * V24 * H4 * Y1 * Y2 * Y3 + U23 * U34 * V12 * V13 * V14 * V24 * H4 * Y1 * Y2 * Y4 - U23 * U34 * V12 * V13 * V14 * V24 * H4 * Y1 * Y3 * Y4 + U23 * U34 * V12 * V13 * V14 * H2 * Y2 - U23 * U34 * V12 * V13 * V14 * H2 * Y3 + U23 * U34 * V12 * V13 * V14 * H4 * Y1 * Y2 - U23 * U34 * V12 * V13 * V14 * H4 * Y1 * Y3 + U23 * U34 * V12 * V14 * V24 * H2 * Y2 - U23 * U34 * V12 * V14 * V24 * H2 * Y4 + U23 * U34 * V12 * V14 * V24 * H4 * Y1 * Y2 - U23 * U34 * V12 * V14 * V24 * H4 * Y1 * Y4 - U23 * U34 * V12 * V14 * H2 - U23 * U34 * V12 * V14 * H4 * Y1 - U23 * U34 * V13 * V14 * V24 * H2 * Y2 + U23 * U34 * V13 * V14 * V24 * H2 * Y4 - U23 * U34 * V13 * V14 * V24 * H4 * Y1 * Y2 + U23 * U34 * V13 * V14 * V24 * H4 * Y1 * Y4 + U23 * U34 * V13 * V14 * H2 + U23 * U34 * V13 * V14 * H4 * Y1 + U24 * U34 * V12 * V13 * V14 * V23 * H2 * Y2^2 - U24 * U34 * V12 * V13 * V14 * V23 * H2 * Y2 * Y3 - U24 * U34 * V12 * V13 * V14 * V23 * H2 * Y2 * Y4 + U24 * U34 * V12 * V13 * V14 * V23 * H2 * Y3 * Y4 + U24 * U34 * V12 * V13 * V14 * V23 * H4 * Y1 * Y2^2 - U24 * U34 * V12 * V13 * V14 * V23 * H4 * Y1 * Y2 * Y3 - U24 * U34 * V12 * V13 * V14 * V23 * H4 * Y1 * Y2 * Y4 + U24 * U34 * V12 * V13 * V14 * V23 * H4 * Y1 * Y3 * Y4 - U24 * U34 * V12 * V13 * V14 * H2 * Y2 + U24 * U34 * V12 * V13 * V14 * H2 * Y3 - U24 * U34 * V12 * V13 * V14 * H4 * Y1 * Y2 + U24 * U34 * V12 * V13 * V14 * H4 * Y1 * Y3 - U24 * U34 * V12 * V13 * V23 * H2 * Y2 + U24 * U34 * V12 * V13 * V23 * H2 * Y3 - U24 * U34 * V12 * V13 * V23 * H4 * Y1 * Y2 + U24 * U34 * V12 * V13 * V23 * H4 * Y1 * Y3 + U24 * U34 * V12 * V14 * H2 + U24 * U34 * V12 * V14 * H4 * Y1 + U24 * U34 * V13 * V14 * V23 * H2 * Y2 - U24 * U34 * V13 * V14 * V23 * H2 * Y3 + U24 * U34 * V13 * V14 * V23 * H4 * Y1 * Y2 - U24 * U34 * V13 * V14 * V23 * H4 * Y1 * Y3 - U24 * U34 * V13 * V14 * H2 - U24 * U34 * V13 * V14 * H4 * Y1 ]
Index: /trunk/examples/trisector.lisp
===================================================================
--- /trunk/examples/trisector.lisp	(revision 8)
+++ /trunk/examples/trisector.lisp	(revision 8)
@@ -0,0 +1,9 @@
+(setf *colored-poly-debug* t)
+(string-grobner-system
+"[-XC^2+XB^2-2*BC*CXBC*XB+BC^2,XC^2-2*BC*CXCB*XC-XB^2+BC^2,-YC^2+YA^2-2*AC*CYAC*YA+AC^2,YC^2-2*AC*CYCA*YC-YA^2+AC^2,-ZB^2+ZA^2-2*AB*CZAB*ZA+AB^2,ZB^2-2*AB*CZBA*ZB-ZA^2+AB^2,SXBC^2+CXBC^2-1,SXCB^2+CXCB^2-1,SYAC^2+CYAC^2-1,SZAB^2+CZAB^2-1,SZBA^2+CZBA^2-1,-2*AB*AC*COSA-BC^2+AC^2+AB^2,-2*AB*BC*COSB+BC^2-AC^2+AB^2,-2*AC*BC*COSC+BC^2+AC^2-AB^2,SINA^2+COSA^2-1,SINB^2+COSB^2-1,SINC^2+COSC^2-1,XB^2-X2^2-X1^2+2*X1-1,XC^2-X2^2+2*U2*X2-X1^2+2*U1*X1-U2^2-U1^2,YA^2-X4^2-X3^2,YC^2-X4^2+2*U2*X4-X3^2+2*U1*X3-U2^2-U1^2,ZA^2-X6^2-X5^2,ZB^2-X6^2-X5^2+2*X5-1,AB^2-1,-U2^2-U1^2+AC^2,-U2^2-U1^2+2*U1+BC^2-1,XY^2-X4^2+2*X2*X4-X3^2+2*X1*X3-X2^2-X1^2,XZ^2-X6^2+2*X2*X6-X5^2+2*X1*X5-X2^2-X1^2,YZ^2-X6^2+2*X4*X6-X5^2+2*X3*X5-X4^2-X3^2,4*CXBC^3-3*CXBC-COSB,4*CXCB^3-3*CXCB-COSC,4*CYAC^3-3*CYAC-COSA,4*CYCA^3-3*CYCA-COSC,4*CZAB^3-3*CZAB-COSA,4*CZBA^3-3*CZBA-COSB,4*CXBC^2*SXBC-3*SXBC-SINB,4*CXCB^2*SXCB-3*SXCB-SINC,-3*SYAC+4*CYAC^2*SXCB-SINA,4*CYCA^2*SYCA-3*SYCA-SINC,4*CZAB^2*SZAB-3*SZAB-SINA,4*CZBA^2*SZBA-3*SZBA-SINB,V*XZ-V*XY+1]"
+'(X1 X2 X3 X4 X5 X6 XB XC YA YC ZA ZB AB AC BC XY XZ YZ COSA COSB COSC SINA SINB SINC CXBC CXCB CYAC CYCA CZAB CZBA SXBC SXCB SYAC SYCA SZAB SZBA V)
+'(U1 U2)
+:cover '(("[]" "[]"))
+:main-order #'grevlex>
+:parameter-order #'grevlex>
+)
Index: /trunk/examples/trisector.macsyma
===================================================================
--- /trunk/examples/trisector.macsyma	(revision 8)
+++ /trunk/examples/trisector.macsyma	(revision 8)
@@ -0,0 +1,91 @@
+if get('geometry2, 'version)=false then load(geometry2);
+/* Points: A,B,C, X,Y,Z.
+Cosines and sines of angles at A B and C are:
+COSA, COSB, COSC, SINA, SINB, SINC
+CXBC, CYAC, CYCA, CZAB, CZBA, CZBA.
+Lengths:
+	XB, XC, YA, YC, ZA, ZB
+	AB, AC, BC,
+	XY, XZ, YZ 
+X,Y,Z are characterized by the conditions
+that 
+	angle XBC is 1/3 of ABC
+	angle XCB is 1/3 of ACB
+	angle YAC is 1/3 of BAC
+	angle YCA is 1/3 of BCA
+	angle ZAB is 1/3 of CAB
+	angle ZBA is 1/3 of CBA
+Conclusion is that XYZ form an equilateral triangle
+		XY=XZ=YZ
+*/
+
+A:[0,0]; B:[1,0]; C:[u1,u2];
+X:[x1,x2]; Y:[x3,x4]; Z:[x5,x6];
+
+vars:append(listofvars([X,Y,Z]),[XB,XC,YA,YC,ZA,ZB],
+	[AB,AC,BC], [XY,XZ,YZ],
+	[COSA, COSB, COSC, SINA, SINB, SINC],
+	[CXBC, CXCB, CYAC, CYCA, CZAB, CZBA],
+	[SXBC, SXCB, SYAC, SYCA, SZAB, SZBA],
+	[V]);
+	
+params:listofvars([A,B,C]);
+cover:[[],[u2]];
+
+
+eqns:[
+	/* Angles: cosine law */
+	XB^2+BC^2-2*XB*BC*CXBC-XC^2,
+	XC^2+BC^2-2*XC*BC*CXCB-XB^2,
+	YA^2+AC^2-2*YA*AC*CYAC-YC^2,
+	YC^2+AC^2-2*YC*AC*CYCA-YA^2,
+	ZA^2+AB^2-2*ZA*AB*CZAB-ZB^2,
+	ZB^2+AB^2-2*ZB*AB*CZBA-ZA^2,
+	CXBC^2+SXBC^2-1,
+	CXCB^2+SXCB^2-1,
+	CYAC^2+SYAC^2-1,
+	CZAB^2+SZAB^2-1,
+	CZBA^2+SZBA^2-1,
+	/* Main angles: cosine law */
+	AB^2+AC^2-2*AB*AC*COSA-BC^2,
+	AB^2+BC^2-2*AB*BC*COSB-AC^2,
+	AC^2+BC^2-2*AC*BC*COSC-AB^2,
+	SINA^2+COSA^2-1,		
+	SINB^2+COSB^2-1,		
+	SINC^2+COSC^2-1,		
+	/* Distances of X,Y,Z from vertices */
+	distance(X,B,XB),
+	distance(X,C,XC),
+	distance(Y,A,YA),
+	distance(Y,C,YC),
+	distance(Z,A,ZA),
+	distance(Z,B,ZB),
+	/* Lengths of sides of main triangle */
+	distance(A,B,AB),
+	distance(A,C,AC),
+	distance(B,C,BC),
+	/* Lengths of the trisector triangle */
+	distance(X,Y,XY),
+	distance(X,Z,XZ),
+	distance(Y,Z,YZ),
+	/* Trisector relations */
+	4*CXBC^3-3*CXBC-COSB,
+	4*CXCB^3-3*CXCB-COSC,
+	4*CYAC^3-3*CYAC-COSA,
+	4*CYCA^3-3*CYCA-COSC,
+	4*CZAB^3-3*CZAB-COSA,
+	4*CZBA^3-3*CZBA-COSB,
+	/* sine rules */
+	4*CXBC^2*SXBC-3*SXBC-SINB,
+	4*CXCB^2*SXCB-3*SXCB-SINC,
+	4*CYAC^2*SXCB-3*SYAC-SINA,
+	4*CYCA^2*SYCA-3*SYCA-SINC,
+	4*CZAB^2*SZAB-3*SZAB-SINA,
+	4*CZBA^2*SZBA-3*SZBA-SINB,
+	/* Conclusion: XY=XZ */
+	1-v*(XY-XZ) 
+];
+
+eqns:expand(eqns);
+cover:expand(cover);
+stringout("trisector.out",eqns,vars,params,cover);
Index: /trunk/examples/trisector.out
===================================================================
--- /trunk/examples/trisector.out	(revision 8)
+++ /trunk/examples/trisector.out	(revision 8)
@@ -0,0 +1,5 @@
+
+[-XC^2+XB^2-2*BC*CXBC*XB+BC^2,XC^2-2*BC*CXCB*XC-XB^2+BC^2,-YC^2+YA^2-2*AC*CYAC*YA+AC^2,YC^2-2*AC*CYCA*YC-YA^2+AC^2,-ZB^2+ZA^2-2*AB*CZAB*ZA+AB^2,ZB^2-2*AB*CZBA*ZB-ZA^2+AB^2,SXBC^2+CXBC^2-1,SXCB^2+CXCB^2-1,SYAC^2+CYAC^2-1,SZAB^2+CZAB^2-1,SZBA^2+CZBA^2-1,-2*AB*AC*COSA-BC^2+AC^2+AB^2,-2*AB*BC*COSB+BC^2-AC^2+AB^2,-2*AC*BC*COSC+BC^2+AC^2-AB^2,SINA^2+COSA^2-1,SINB^2+COSB^2-1,SINC^2+COSC^2-1,XB^2-X2^2-X1^2+2*X1-1,XC^2-X2^2+2*U2*X2-X1^2+2*U1*X1-U2^2-U1^2,YA^2-X4^2-X3^2,YC^2-X4^2+2*U2*X4-X3^2+2*U1*X3-U2^2-U1^2,ZA^2-X6^2-X5^2,ZB^2-X6^2-X5^2+2*X5-1,AB^2-1,-U2^2-U1^2+AC^2,-U2^2-U1^2+2*U1+BC^2-1,XY^2-X4^2+2*X2*X4-X3^2+2*X1*X3-X2^2-X1^2,XZ^2-X6^2+2*X2*X6-X5^2+2*X1*X5-X2^2-X1^2,YZ^2-X6^2+2*X4*X6-X5^2+2*X3*X5-X4^2-X3^2,4*CXBC^3-3*CXBC-COSB,4*CXCB^3-3*CXCB-COSC,4*CYAC^3-3*CYAC-COSA,4*CYCA^3-3*CYCA-COSC,4*CZAB^3-3*CZAB-COSA,4*CZBA^3-3*CZBA-COSB,4*CXBC^2*SXBC-3*SXBC-SINB,4*CXCB^2*SXCB-3*SXCB-SINC,-3*SYAC+4*CYAC^2*SXCB-SINA,4*CYCA^2*SYCA-3*SYCA-SINC,4*CZAB^2*SZAB-3*SZAB-SINA,4*CZBA^2*SZBA-3*SZBA-SINB,V*XZ-V*XY+1];
+[X1,X2,X3,X4,X5,X6,XB,XC,YA,YC,ZA,ZB,AB,AC,BC,XY,XZ,YZ,COSA,COSB,COSC,SINA,SINB,SINC,CXBC,CXCB,CYAC,CYCA,CZAB,CZBA,SXBC,SXCB,SYAC,SYCA,SZAB,SZBA,V];
+[U1,U2];
+[[],[U2]];
Index: /trunk/examples/trisector2.lisp
===================================================================
--- /trunk/examples/trisector2.lisp	(revision 8)
+++ /trunk/examples/trisector2.lisp	(revision 8)
@@ -0,0 +1,5 @@
+(string-grobner
+"[-XC^2+XB^2-2*BC*CXBC*XB+BC^2,XC^2-2*BC*CXCB*XC-XB^2+BC^2,-YC^2+YA^2-2*AC*CYAC*YA+AC^2,YC^2-2*AC*CYCA*YC-YA^2+AC^2,-ZB^2+ZA^2-2*AB*CZAB*ZA+AB^2,ZB^2-2*AB*CZBA*ZB-ZA^2+AB^2,SXBC^2+CXBC^2-1,SXCB^2+CXCB^2-1,SYAC^2+CYAC^2-1,SZAB^2+CZAB^2-1,SZBA^2+CZBA^2-1,-2*AB*AC*COSA-BC^2+AC^2+AB^2,-2*AB*BC*COSB+BC^2-AC^2+AB^2,-2*AC*BC*COSC+BC^2+AC^2-AB^2,SINA^2+COSA^2-1,SINB^2+COSB^2-1,SINC^2+COSC^2-1,XB^2-X2^2-X1^2+2*X1-1,XC^2-X2^2+2*U2*X2-X1^2+2*U1*X1-U2^2-U1^2,YA^2-X4^2-X3^2,YC^2-X4^2+2*U2*X4-X3^2+2*U1*X3-U2^2-U1^2,ZA^2-X6^2-X5^2,ZB^2-X6^2-X5^2+2*X5-1,AB^2-1,-U2^2-U1^2+AC^2,-U2^2-U1^2+2*U1+BC^2-1,XY^2-X4^2+2*X2*X4-X3^2+2*X1*X3-X2^2-X1^2,XZ^2-X6^2+2*X2*X6-X5^2+2*X1*X5-X2^2-X1^2,YZ^2-X6^2+2*X4*X6-X5^2+2*X3*X5-X4^2-X3^2,4*CXBC^3-3*CXBC-COSB,4*CXCB^3-3*CXCB-COSC,4*CYAC^3-3*CYAC-COSA,4*CYCA^3-3*CYCA-COSC,4*CZAB^3-3*CZAB-COSA,4*CZBA^3-3*CZBA-COSB,4*CXBC^2*SXBC-3*SXBC-SINB,4*CXCB^2*SXCB-3*SXCB-SINC,-3*SYAC+4*CYAC^2*SXCB-SINA,4*CYCA^2*SYCA-3*SYCA-SINC,4*CZAB^2*SZAB-3*SZAB-SINA,4*CZBA^2*SZBA-3*SZBA-SINB,V*XZ-V*XY+1]"
+'(U1 U2 X1 X2 X3 X4 X5 X6 XB XC YA YC ZA ZB AB AC BC XY XZ YZ COSA COSB COSC SINA SINB SINC CXBC CXCB CYAC CYCA CZAB CZBA SXBC SXCB SYAC SYCA SZAB SZBA V)
+:order #'grevlex>
+)
Index: /trunk/latex-doc/cgb-lisp.tex
===================================================================
--- /trunk/latex-doc/cgb-lisp.tex	(revision 8)
+++ /trunk/latex-doc/cgb-lisp.tex	(revision 8)
@@ -0,0 +1,29 @@
+\begin{lisp:documentation}{*examples*}{VARIABLE}{'((string$-$grobner (string$-$grobner [x\symbol{94}2+y,x$-$y] '(x y)) (string$-$grobner [y$-$x\symbol{94}2,z$-$x\symbol{94}3] '(x y z) order \#'grevlex$>$))
+ (string$-$grobner$-$system (string$-$grobner$-$system [u*x+y,x+y] '(x y) '(u)) (string$-$grobner$-$system [u*x+y,x+y] '(x y) '(u) cover '(([u$-$1] [])))) (string$-$read$-$poly (string$-$read$-$poly [x\symbol{94}3+3*x\symbol{94}2+3*x+1] '(x)))
+ (string$-$elimination$-$ideal (string$-$elimination$-$ideal [x\symbol{94}2+y\symbol{94}2$-$2,x*y$-$1] '(x y) 1)) (string$-$ideal$-$saturation$-$1 (string$-$ideal$-$saturation$-$1 [x\symbol{94}2*y,y\symbol{94}3] x '(x y)))
+ (string$-$ideal$-$polysaturation$-$1 (string$-$ideal$-$polysaturation$-$1 [x\symbol{94}2*y,y\symbol{94}3] [x,y] '(x y))) (string$-$cond (string$-$cond '([u\symbol{94}2$-$v] [v$-$1]) '(u v) \#'grevlex$>$))
+ (string$-$cover (string$-$cover '(([u\symbol{94}2$-$v] [u]) ([u+v] [])) '(u v) \#'grevlex$>$)) (string$-$determine (string$-$determine [u*x+y,v*x\symbol{94}2+y\symbol{94}2] '(x y) '(u v) cond '([u,v] [v$-$1]) main$-$order \#'lex$>$))
+ (parse$-$string$-$to$-$sorted$-$alist (parse$-$string$-$to$-$sorted$-$alist x\symbol{94}2+y\symbol{94}3 '(x y) \#'grevlex$>$) (parse$-$string$-$to$-$sorted$-$alist [x\symbol{94}2+y\symbol{94}3,x$-$y] '(x y) \#'grevlex$>$))
+ (translate$-$statements (translate$-$statements (collinear a b c) (perpendicular a b a c)))
+ (translate$-$theorem (translate$-$theorem ((perpendicular a b c d) (perpendicular c d e f)) ((parallel a b e f) (identical$-$points c d)))
+  (translate$-$theorem ((perpendicular a b a c) (midpoint b c m) (midpoint a m o) (collinear b h c) (perpendicular a h b c)) ((equidistant m o h o) (identical$-$points b c))))
+ (prove$-$theorem (prove$-$theorem ((perpendicular a b c d) (perpendicular c d e f)) ((parallel a b e f) (identical$-$points c d)))
+  (prove$-$theorem ((perpendicular a b a c) (midpoint b c m) (midpoint a m o) (collinear b h c) (perpendicular a h b c)) ((equidistant m o h o) (identical$-$points b c)))
+  (prove$-$theorem ((perpendicular a b a c) (identical$-$points b c)) ((identical$-$points a b) (identical$-$points a c)))
+  (prove$-$theorem ((perpendicular a b a c) (identical$-$points b c)) ((identical$-$points a b) (real$-$identical$-$points a c))))) }
+A list of available examples.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{example}{FUNCTION}{symbol {\sf \&optional} (stream t) }
+Run short examples associated with a symbol, which typically is a
+function name. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{run$-$example}{FUNCTION}{e stream }
+Evaluate a single form E and send output to stream STREAM.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{all$-$examples}{FUNCTION}{{\sf \&optional} (stream t) }
+Run all available examples and send output to STREAM.
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/coefficient-ring.tex
===================================================================
--- /trunk/latex-doc/coefficient-ring.tex	(revision 8)
+++ /trunk/latex-doc/coefficient-ring.tex	(revision 8)
@@ -0,0 +1,41 @@
+\begin{lisp:documentation}{ring}{STRUCTURE}{+ $-$ * / gcd lcm zerop unit length signum numerator denominator }
+The structure whose slots are bound to functions
+performing usual ring operations. In addition to usual arithmetical
+operations, bindings for other common operations
+which increase efficiency of Grobner basis calculations are also
+included. They are as follows:
+	GCD	$-$ greatest common divisor;
+	LCM	$-$ least common multiple;
+	ZEROP	$-$ test whether an element is zero;
+	SIGNUM  $-$ the sign of a ring element (+1, $-$1 or zero);
+	UNIT	$-$ the unit of the ring;
+	NUMERATOR $-$ the numerator, if a ring of fractions
+	DENOMINATOR $-$ the denominator, if a ring of fractions
+	LENGTH  $-$ an integer giving the approximate length
+		of the representation; for example, for integers
+		its default binding is \#'integer$-$length;
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*ring$-$of$-$integers*}{VARIABLE}{(make$-$ring :+ \#'+ :$-$ \#'$-$ :* \#'* :/ \#'floor :gcd \#'gcd :lcm \#'lcm :zerop \#'zerop :signum \#'signum :unit 1 :length \#'integer$-$length
+                                                              :numerator \#'numerator :denominator \#'denominator) }
+Operations in the ring of integers.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*field$-$of$-$rationals*}{VARIABLE}{(make$-$ring :+ \#'+ :$-$ \#'$-$ :* \#'* :/ \#'/ :gcd \#'(lambda (\&rest r) (declare (ignore r)) 1) :lcm \#'(lambda (\&rest r) (apply \#'* r)) :zerop
+                                                                \#'zerop :signum \#'signum :unit 1 :length \#'(lambda (x) (+ (integer$-$length (numerator x)) (integer$-$length (denominator x)))) :numerator
+                                                                \#'numerator :denominator \#'denominator) }
+Operations on the field of rational numbers.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{field$-$modulo$-$prime}{FUNCTION}{modulus }
+Return a RING structure with operations bound
+to the arithmetical operations modulo MODULUS, which
+should be a prime.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*coefficient$-$ring*}{VARIABLE}{*ring$-$of$-$integers* }
+The default RING structure, used in most operations
+on the coefficients of polynomials. It should be carefully
+set if rings other than the default ring is used.
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/colored-poly.tex
===================================================================
--- /trunk/latex-doc/colored-poly.tex	(revision 8)
+++ /trunk/latex-doc/colored-poly.tex	(revision 8)
@@ -0,0 +1,389 @@
+\begin{lisp:documentation}{*colored$-$poly$-$debug*}{VARIABLE}{nil }
+If true debugging output is on.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{debug$-$cgb}{MACRO}{{\sf \&rest} args }
+{\ } % NO DOCUMENTATION FOR DEBUG-CGB
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{make$-$colored$-$poly}{FUNCTION}{poly k {\sf \&key} (key \#'identity) (main$-$order \#'lex$>$) (parameter$-$order \#'lex$>$) {\sf \&aux} l }
+Colored poly is represented as a list
+	(TERM1 TERM2 ... TERMS)
+where each term is a triple
+	(MONOM . (POLY . COLOR))
+where monoms and polys have common number of variables while color is
+one of the three: :RED, :GREEN or :WHITE.  This function translates
+an ordinary polynomial into a colored one by dividing variables into
+K and N$-$K, where N is the total number of variables in the
+polynomial poly; the function KEY can be called to select variables
+in arbitrary order.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{make$-$colored$-$poly$-$list}{FUNCTION}{plist {\sf \&rest} rest }
+Translate a list of polynomials PLIST into a list of colored
+polynomials by calling MAKE$-$COLORED$-$POLY. Returns the resulting
+list. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{color$-$poly$-$list}{FUNCTION}{flist {\sf \&optional} (cond (list nil nil)) }
+Add colors to an ordinary list of polynomials FLIST, according to a
+condition COND. A condition is a pair of polynomial lists.  Each
+polynomial in COND is a polynomial in parameters only.  The list
+(FIRST COND) is called the ``green list'' and it consists of
+polynomials which vanish for the parameters associated with the
+condition. The list (SECOND COND) is called the ``red list
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{color$-$poly}{FUNCTION}{f {\sf \&optional} (cond (list nil nil)) }
+Add color to a single polynomial F, according to condition COND.
+See the documentation of COLOR$-$POLY$-$LIST.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colored$-$poly$-$to$-$poly}{FUNCTION}{cpoly }
+For a given colored polynomial CPOLY, removes the colors and
+it returns the polynomial as an ordinary polynomial with
+coefficients which are polynomials in parameters.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colored$-$poly$-$print}{FUNCTION}{poly vars {\sf \&key} (stream t) (beg t) (print$-$green$-$part nil) (mark$-$coefficients nil) }
+Print a colored polynomial POLY. Use variables VARS to represent
+the variables. Some of the variables are going to be used as
+parameters, according to the length of the monomials in the main
+monomial and coefficient part of each term in POLY. The key variable
+STREAM may be used to redirect the output. If parameter
+PRINT$-$GREEN$-$PART is set then the coefficients which have color
+:GREEN will be printed, otherwise they are discarded silently. If
+MARK$-$COEFFICIENTS is not NIL then every coefficient will be marked
+according to its color, for instance G(U$-$1) would mean that U$-$1
+is in the green list. Returns P.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colored$-$poly$-$print$-$list}{FUNCTION}{poly$-$list vars {\sf \&key} (stream t) (beg t) (print$-$green$-$part nil) (mark$-$coefficients nil) }
+Pring a list of colored polynomials via a call to
+COLORED$-$POLY$-$PRINT.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{determine}{FUNCTION}{f {\sf \&optional} (cond (list nil nil)) (order \#'lex$>$) (ring *coefficient$-$ring*) }
+This function takes a list of colored polynomials F and a condition
+COND, and it returns a list of pairs (COND' F') such that COND' cover
+COND and F' is a ``determined'' version of the colored polynomial
+list F, i.e. every polynomial has its leading coefficient determined.
+This means that some of the initial coefficients in each polynomial
+in F' are in the green list of COND, and the first non$-$green
+coefficient is in the red list of COND. We note that F' differs from
+F only by different colors: some of the terms marked :WHITE are now
+marked either :GREEN or :RED. Coloring is done either by explicitly
+checking membership in red or green list of COND, or implicitly by
+performing Grobner basis calculations in the polynomial ring over the
+parameters. The admissible monomial order ORDER is used only in the
+parameter space. Also, the ring structure RING is used only for
+calculations on polynomials of the parameters only.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{determine$-$1}{FUNCTION}{cond p end gp order ring }
+Determine a single colored polynomial  P according to condition COND.
+Prepend green part GP to P. Cons the result with END, which should be
+a list of colored polynomials, and return the resulting list of
+polynomials. This is an auxillary function of DETERMINE.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{determine$-$white$-$term}{FUNCTION}{cond term restp end gp order ring }
+This is an auxillary function of DETERMINE.  In this function the
+parameter COND is a condition.  The parameters TERM, RESTP and GP are
+three parts of a polynomial being processed, where TERM is colored
+:WHITE. We test the membership in the red and green list of COND we
+try to determine whether the term is :RED or :GREEN. This is done by
+performing ideal membership tests in the polynomial ring. Let C be
+the coefficient of TERM.  Thus, C is a polynomial in parameters. We
+find whether C is in the green list by performing a plain ideal
+membership test. However, to test properly whether C is in the red
+list, one needs a different strategy.  In fact, we test whether
+adding C to the red list would produce a non$-$empty set of
+parameters in some algebraic extension. The test is whether 1 belongs
+to the saturation ideal of (FIRST COND) in (CONS C (SECOND COND)).
+Thus, we use POLY$-$SATURATION. If we are successful in determining
+the color of TERM, we simply change the color of the term and return
+the list ((COND P)) where P is obtained by appending GP, (LIST TERM)
+and RESTP. If we cannot determine whether TERM is :RED or :GREEN, we
+return the list ((COND' P') (COND'' P
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{cond$-$system$-$print}{FUNCTION}{system vars params {\sf \&key} (suppress$-$value t) (print$-$green$-$part nil) (mark$-$coefficients nil) {\sf \&aux} (label 0) }
+A conditional system SYSTEM is a list of pairs (COND PLIST), where
+COND is a condition (a pair (GREEN$-$LIST RED$-$LIST)) and PLIST is a
+list of colored polynomials. This function pretty$-$prints this list
+of pairs. A conditional system is the data structure returned by
+GROBNER$-$SYSTEM. This function returns SYSTEM, if SUPPRESS$-$VALUE
+is non$-$NIL and no value otherwise. If MARK$-$COEFFICIENTS is
+non$-$NIL coefficients will be marked as in G(u$-$1)*x+R(2)*y, which
+means that u$-$1 is :GREEN and 2 is :RED. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{cond$-$print}{FUNCTION}{cond params }
+Pretty$-$print a condition COND, using symbol list PARAMS as
+parameter names. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{add$-$pairs}{FUNCTION}{gs pred }
+The parameter GS shoud be a Grobner system, i.e. a set of pairs
+(CONDITION POLY$-$LIST) This functions adds the third component: the
+list of initial critical pairs (I J), as in the ordinary Grobner
+basis algorithm. In addition, it adds the length of of the
+POLY$-$LIST, less 1, as the fourth component. The resulting list of
+quadruples is returned.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{cond$-$part}{FUNCTION}{p }
+Find the part of a colored polynomial P starting with the first
+ non$-$green term.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{cond$-$hm}{FUNCTION}{p }
+Return the conditional head monomial of a colored polynomial P.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{delete$-$green$-$polys}{FUNCTION}{gamma }
+Delete totally green polynomials from in a grobner system GAMMA.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{grobner$-$system}{FUNCTION}{f {\sf \&key} (cover (list '(nil nil))) (main$-$order \#'lex$>$) (parameter$-$order \#'lex$>$) (reduce t) (green$-$reduce t) (top$-$reduction$-$only
+                                                                                                                                                                                     nil) (ring
+                                                                                                                                                                                           *coefficient$-$ring*) {\sf \&aux} (cover
+                                                                                                                                                                                                                              (saturate$-$cover
+                                                                                                                                                                                                                               cover
+                                                                                                                                                                                                                               parameter$-$order
+                                                                                                                                                                                                                               ring)) (gamma
+                                                                                                                                                                                                                                       (delete$-$green$-$polys
+                                                                                                                                                                                                                                        (mapcan
+                                                                                                                                                                                                                                         \#'(lambda (cond) (determine f cond parameter$-$order ring))
+                                                                                                                                                                                                                                         cover))) }
+This function returns a grobner system, given a list of colored
+polynomials F, Other parameters are:
+A cover COVER, i.e. a list of conditions, i.e. pairs of the form
+(GREEN$-$LIST RED$-$LIST), where GREEN$-$LIST and RED$-$LIST are to
+lists of ordinary polynomials in parameters. A monomial order
+MAIN$-$ORDER used on main variables (not parameters). A monomial
+order PARAMETER$-$ORDER used in calculations with parameters only.
+REDUCE, a flag deciding whether COLORED$-$REDUCTION will be performed
+on the resulting grobner system. GREEN$-$REDUCE, a flag deciding
+whether the green list of each condition will be reduced in a form of
+a reduced Grobner basis. TOP$-$REDUCTION$-$ONLY, a flag deciding
+whether in the internal calculations in the space of parameters top
+reduction only will be used. RING, a structure as in the package
+COEFFICIENT$-$RING, used in operations on the coefficients of the
+polynomials in parameters. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{reorder$-$pairs}{FUNCTION}{b bnew g pred {\sf \&optional} (sort$-$first nil) }
+Reorder pairs according to some heuristic. The heuristic at this time
+is ad hoc, in the future it should be replaced with sugar strategy
+and a mechanism for implementing new heuristic strategies, as in the
+GROBNER package. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colored$-$criterion$-$1}{FUNCTION}{i j f }
+Buchberger criterion 1 for colored polynomials.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colored$-$criterion$-$2}{FUNCTION}{i j f b s }
+Buchberger criterion 2 for colored polynomials.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{cond$-$normal$-$form}{FUNCTION}{f fl main$-$order parameter$-$order top$-$reduction$-$only ring }
+Returns the conditional normal form of a colored polynomial F with
+respect to the list of colored polynomials FL. The list FL is assumed
+to consist of determined polynomials, i.e. such that the first term
+which is not marked :GREEN is :RED.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{cond$-$spoly}{FUNCTION}{f g main$-$order parameter$-$order ring }
+Returns the conditional S$-$polynomial of two colored polynomials F
+and G. Both polynomials are assumed to be determined.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{cond$-$lm}{FUNCTION}{f }
+Returns the conditional leading monomial of a colored polynomial F,
+which is assumed to be determined.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{cond$-$lc}{FUNCTION}{f }
+Returns the conditional leading coefficient of a colored polynomial
+F, which is assumed to be determined.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colored$-$term$-$times$-$poly}{FUNCTION}{term f order ring }
+Returns the product of a colored term TERM and a colored polynomial
+F. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colored$-$scalar$-$times$-$poly}{FUNCTION}{c f ring }
+Returns the product of an element of the coefficient ring C a colored
+polynomial F. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colored$-$term*}{FUNCTION}{term1 term2 order ring }
+Returns the product of two colored terms TERM1 and TERM2.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{color*}{FUNCTION}{c1 c2 }
+Returns a product of two colores. Rules:
+:red * :red yields :red
+any * :green yields :green
+otherwise the result is :white.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{color+}{FUNCTION}{c1 c2 }
+Returns a sum of colors. Rules:
+:green + :green yields :green,
+:red + :green yields :red
+any other result is :white.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{color$-$}{FUNCTION}{c1 c2 }
+Identical to COLOR+.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colored$-$poly+}{FUNCTION}{p q main$-$order parameter$-$order ring }
+Returns the sum of colored polynomials P and Q.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colored$-$poly$-$}{FUNCTION}{p q main$-$order parameter$-$order ring }
+Returns the difference of colored polynomials P and Q.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colored$-$term$-$uminus}{FUNCTION}{term ring }
+Returns the negation of a colored term TERM.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colored$-$minus$-$poly}{FUNCTION}{p ring }
+Returns the negation of a colored polynomial P.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$grobner$-$system}{FUNCTION}{f vars params {\sf \&key} (cover (list (list "[]" "[]"))) (main$-$order \#'lex$>$) (parameter$-$order \#'lex$>$) (ring
+                                                                                                                                                                                  *coefficient$-$ring*) (suppress$-$value
+                                                                                                                                                                                                         t) (suppress$-$printing
+                                                                                                                                                                                                             nil) (mark$-$coefficients
+                                                                                                                                                                                                                   nil) (reduce
+                                                                                                                                                                                                                         t) (green$-$reduce
+                                                                                                                                                                                                                             t) {\sf \&aux} (f
+                                                                                                                                                                                                                                             (parse$-$to$-$colored$-$poly$-$list
+                                                                                                                                                                                                                                              f
+                                                                                                                                                                                                                                              vars
+                                                                                                                                                                                                                                              params
+                                                                                                                                                                                                                                              main$-$order
+                                                                                                                                                                                                                                              parameter$-$order)) (cover
+                                                                                                                                                                                                                                                                   (string$-$cover
+                                                                                                                                                                                                                                                                    cover
+                                                                                                                                                                                                                                                                    params
+                                                                                                                                                                                                                                                                    parameter$-$order)) }
+An interface to GROBNER$-$SYSTEM in which polynomials can be
+specified in infix notations as strings. Lists of polynomials are
+comma$-$separated list marked by a matchfix operators [] 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$cond}{FUNCTION}{cond params {\sf \&optional} (order \#'lex$>$) }
+Return the internal representation of a condition COND, specified
+as pairs of strings (GREEN$-$LIST RED$-$LIST). GREEN$-$LIST and
+RED$-$LIST in the input are assumed to be strings which parse to two
+lists of polynomials with respect to variables whose names are in the
+list of symbols PARAMS. ORDER is the predicate used to sort the terms
+of the polynomials.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$cover}{FUNCTION}{cover params {\sf \&optional} (order \#'lex$>$) }
+Returns the internal representation of COVER, given in the form of
+a list of conditions. See STRING$-$COND for description of a
+condition. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{saturate$-$cover}{FUNCTION}{cover order ring }
+Brings every condition of a list of conditions COVER to the form (G
+R) where G is saturated with respect to R and G is a Grobner basis
+We could reduce R so that the elements of R are relatively prime,
+but this is not currently done.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{saturate$-$cond}{FUNCTION}{cond order ring }
+Saturate a single condition COND. An auxillary function of
+SATURATE$-$COVER. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$determine}{FUNCTION}{f vars params {\sf \&key} (cond '([] [])) (main$-$order \#'lex$>$) (parameter$-$order \#'lex$>$) (suppress$-$value t) (suppress$-$printing
+                                                                                                                                                                                nil) (mark$-$coefficients
+                                                                                                                                                                                      nil) (ring
+                                                                                                                                                                                            *coefficient$-$ring*) {\sf \&aux} (f
+                                                                                                                                                                                                                               (parse$-$to$-$colored$-$poly$-$list
+                                                                                                                                                                                                                                f
+                                                                                                                                                                                                                                vars
+                                                                                                                                                                                                                                params
+                                                                                                                                                                                                                                main$-$order
+                                                                                                                                                                                                                                parameter$-$order)) (cond
+                                                                                                                                                                                                                                                     (string$-$cond
+                                                                                                                                                                                                                                                      cond
+                                                                                                                                                                                                                                                      params
+                                                                                                                                                                                                                                                      parameter$-$order)) }
+A string interface to DETERMINE. See the documentation of
+STRING$-$GROBNER$-$SYSTEM. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{tidy$-$grobner$-$system}{FUNCTION}{gs main$-$order parameter$-$order reduce green$-$reduce ring }
+Apply TIDY$-$PAIR to every pair of a Grobner system.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{tidy$-$pair}{FUNCTION}{pair main$-$order parameter$-$order reduce green$-$reduce ring {\sf \&aux} gs }
+Make the output of Grobner system more readable by performing
+certain simplifications on an element of a Grobner system.
+If REDUCE is non$-$NIL then COLORED$-$reduction will be performed.
+In addition TIDY$-$COND is called on the condition part of the pair
+PAIR. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{tidy$-$cond}{FUNCTION}{cond order ring }
+Currently saturates condition COND and does RED$-$REDUCTION on the
+red list. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colored$-$reduction}{FUNCTION}{cond p main$-$order parameter$-$order ring {\sf \&aux} (open (list (list cond nil p))) closed }
+Reduce a list of colored polynomials P.  The difficulty as compared
+to the usual Buchberger algorithm is that the polys may have the same
+leading monomial which may result in cancellations and polynomials
+which may not be determined. Thus, when we find those, we will have
+to split the condition by calling determine. Returns a list of pairs
+(COND' P') where P' is a reduced grobner basis with respect to any
+parameter choice compatible with condition COND'. Moreover, COND'
+form a cover of COND.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{green$-$reduce$-$colored$-$poly}{FUNCTION}{cond f parameter$-$order ring }
+It takes a colored polynomial F and it returns a modified
+polynomial obtained by reducing coefficient of F modulo green list of
+the condition COND.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{green$-$reduce$-$colored$-$list}{FUNCTION}{cond fl parameter$-$order ring }
+Apply GREEN$-$REDUCE$-$COLORED$-$POLY to a list of polynomials FL.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{cond$-$system$-$green$-$reduce}{FUNCTION}{gs parameter$-$order ring }
+Apply GREEN$-$REDUCE$-$COLORED$-$LIST to every pair of
+a grobner system GS.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{parse$-$to$-$colored$-$poly$-$list}{FUNCTION}{f vars params main$-$order parameter$-$order {\sf \&aux} (k (length vars)) (vars$-$params (append vars params)) }
+Parse a list of polynomials F, given as a string, with respect to
+a list of variables VARS, given as a list of symbols, to the internal
+representation of a colored polynomial. The polynomials will be
+properly sorted by MAIN$-$ORDER, with the coefficients, which are
+polynomials in parameters, sorted by PARAMETER$-$ORDER. Both orders
+must be admissible monomial orders. This form is suitable for parsing
+polynomials with integer coefficients.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{red$-$reduction}{FUNCTION}{p pred ring {\sf \&aux} (p (remove$-$if \#'poly$-$constant$-$p p)) }
+Takes a family of polynomials and produce a list whose prime factors 
+are the same but they are relatively prime
+Repetitively used the following procedure: it finds two elements f, g
+of P which are not relatively prime; it replaces f and g with
+f/GCD(f,g), g/ GCD(f,f) and GCD(f,g).
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/division.tex
===================================================================
--- /trunk/latex-doc/division.tex	(revision 8)
+++ /trunk/latex-doc/division.tex	(revision 8)
@@ -0,0 +1,13 @@
+\begin{lisp:documentation}{divide}{FUNCTION}{f fl {\sf \&optional} (pred \#'lex$>$) (ring *coefficient$-$ring*) {\sf \&aux} (s (length fl)) }
+Divide polynomial F by a list of polynomials FL; use predicate PRED
+to sort monomials; assumes that the polynomials have initially been
+sorted according to PRED. It returnes multiple values. The first
+value is a list of quotients A.  The second value is the remainder R.
+These object satisfy the quation F = SUM A[J]*FL[I] + R.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$exact$-$divide}{FUNCTION}{f g {\sf \&optional} (order \#'lex$>$) (ring *coefficient$-$ring*) }
+Divide a polynomial F by another polynomial G. Assume that exact
+division with no remainder is possible. Returns the quotient.
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/dynamics.tex
===================================================================
--- /trunk/latex-doc/dynamics.tex	(revision 8)
+++ /trunk/latex-doc/dynamics.tex	(revision 8)
@@ -0,0 +1,171 @@
+\begin{lisp:documentation}{poly$-$scalar$-$composition}{FUNCTION}{f g {\sf \&optional} (order \#'lex$>$) }
+Returns a polynomial obtained by substituting a list of polynomials
+G=(G1,G2,...,GN) into a polynomial F(X1,X2,...,XN). All polynomials
+are assumed to be in the internal form, so variables do not
+explicitly apprear in the calculation. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$composition}{FUNCTION}{f g {\sf \&optional} (order \#'lex$>$) }
+Return the composition of a polynomial map F with a polynomial map
+G. Both maps are represented as lists of polynomials, and each
+polynomial is in the internal alist representation. The restriction
+is that the length of the list G must be the number of variables in
+the list F. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$dynamic$-$power}{FUNCTION}{f n {\sf \&optional} (order \#'lex$>$) }
+Calculate the composition FoFo...oF (n times), where
+F is a polynomial map represented as a list of polynomials.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$scalar$-$evaluate}{FUNCTION}{f x {\sf \&optional} (order \#'lex$>$) }
+Evaluate a polynomial F at a point X. This operation is implemented
+through POLY$-$SCALAR$-$COMPOSITION.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$evaluate}{FUNCTION}{f x {\sf \&optional} (order \#'lex$>$) }
+Evaluate a polynomial map F, represented as list of polynomials, at a
+point X. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{factorial}{FUNCTION}{n {\sf \&optional} (k n) {\sf \&aux} (result 1) }
+Return N!/(N$-$K)!=N(N$-$1)(N$-$K+1).
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$scalar$-$diff}{FUNCTION}{f m }
+Return the partial derivative of a polynomial F over multiple
+ variables according to multiindex M.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$diff}{FUNCTION}{f m }
+Return the partial derivative of a polynomial map F, represented as a
+list of polynomials, with respect to several variables, according to
+multi$-$index M. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{standard$-$vector}{FUNCTION}{n k {\sf \&optional} (coeff 1) {\sf \&aux} (v (make$-$list n :initial$-$element 0)) }
+Returns vector (0 0 ... 1 ... 0 0) of length N, where 1 appears on
+K$-$th place. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{scalar$-$partial}{FUNCTION}{f k {\sf \&optional} (l 1) }
+Returns the L$-$th partial derivative of a polynomial F over the
+K$-$th variable. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{partial}{FUNCTION}{f k {\sf \&optional} (l 1) }
+Returns the L$-$th partial derivative over the K$-$th variable, of a
+polynomial map F, represented as a list of polynomials.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{determinant}{FUNCTION}{f {\sf \&optional} (order \#'lex$>$) {\sf \&aux} (result nil) }
+Returns the determinant of a polynomial matrix F, which is a list of
+rows of the matrix, each row is a list of polynomials.  The algorithm
+is recursive expansion along columns.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{minor}{FUNCTION}{f i j {\sf \&optional} (order \#'lex$>$) }
+Calculate the minor of a polynomial matrix F with respect to entry
+(I,J). 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{drop$-$row}{FUNCTION}{f i }
+Discards the I$-$th row from a polynomial matrix F.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{drop$-$column}{FUNCTION}{f j }
+Discards the J$-$th column from a polynomial matrix F.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{drop$-$elt}{FUNCTION}{lst j }
+Discards the J$-$th element from a list LST.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{matrix$-$}{FUNCTION}{f g {\sf \&optional} (order \#'lex$>$) }
+Returns difference of two polynomial matrices F and G.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{scalar$-$times$-$matrix}{FUNCTION}{s f }
+Returns a product of a polynomial S by a polynomial matrix F.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$times$-$matrix}{FUNCTION}{m f }
+Returns a product of a monomial M by a polynomial matrix F.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{term$-$times$-$matrix}{FUNCTION}{term f }
+Returns a product of a term TERM by a polynomial matrix F.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$list$-$}{FUNCTION}{f g {\sf \&optional} (order \#'lex$>$) }
+Returns the list of differences of two lists of polynomials
+F and G (polynomial maps).
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{scalar$-$times$-$poly$-$list}{FUNCTION}{s f }
+Returns the list of products of a polynomial S by the
+list of polynomials F.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$times$-$poly$-$list}{FUNCTION}{m f }
+Returns the list of products of a monomial M by the
+list of polynomials F.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{term$-$times$-$poly$-$list}{FUNCTION}{term f }
+Returns the list of products of a term TERM by the
+list of polynomials F.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{characteristic$-$combination}{FUNCTION}{a b {\sf \&optional} (order \#'lex$>$) {\sf \&aux} (n (length b)) }
+Returns A $-$ U1 * B1 $-$ U2 * B2 $-$ ... $-$ UM * BM where A is a
+polynomial and B=(B1,B2,...,BM) is a polynomial list, where U1, U2,
+... , UM are new variables. These variables will be added to every
+polynomial A and BI as the last M variables.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{characteristic$-$combination$-$poly$-$list}{FUNCTION}{a b {\sf \&optional} (order \#'lex$>$) }
+Returns A $-$ U1 * B1 $-$ U2 * B2 $-$ ... $-$ UM * BM where A is a
+polynomial list and B=(B1, B2, ... , BM) is a list of polynomial
+lists, where U1, U2, ... ,UM are new variables. These variables will
+be added to every polynomial A and BI as the last M variables. Se
+also CHARACTERISTIC$-$COMBINATION. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{characteristic$-$matrix}{FUNCTION}{a {\sf \&optional} (order \#'lex$>$) (b (list (identity$-$matrix (length a) (length (caaaar a))))) }
+Returns A $-$ U1*B1 $-$ U2*B2 $-$ ... $-$ UM * BM where A is a
+polynomial matrix and B=(B1,B2,...,BM) is a list of polynomial
+matrices, where U1, U2, .., UM are new variables. These variables
+will be added to every polynomial A and BI as the last M variables.
+Se also CHARACTERISTIC$-$COMBINATION. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{characteristic$-$polynomial}{FUNCTION}{a {\sf \&optional} (order \#'lex$>$) (b (list (identity$-$matrix (length a) (length (caaaar a))))) }
+Returns the generalized characteristic polynomial, i.e. the
+determinant DET(A $-$ U1 * B1 $-$ U2 * B2 $-$ ... $-$ UM * BM), where
+A and BI are square polynomial matrices in N variables. The resulting
+polynomial will have N+M variables, with U1, U2, ..., UM added as the
+last M variables. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{identity$-$matrix}{FUNCTION}{dim nvars }
+Return the polynomial matrix which is the identity matrix. DIM is the
+requested dimension and NVARS is the number of variables of each
+entry. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{print$-$matrix}{FUNCTION}{f vars }
+Prints a polynomial matrix F, using a list of symbols VARS as
+variable names. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{jacobi$-$matrix}{FUNCTION}{f {\sf \&optional} (m (length f)) (n (length (caaaar f))) }
+Returns the Jacobi matrix of a polynomial list F over the first N
+variables. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{jacobian}{FUNCTION}{f {\sf \&optional} (order \#'lex$>$) (m (length f)) (n (length (caaaar f))) }
+Returns the Jacobian (determinant) of a polynomial list F over the
+first N variables. 
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/examples.tex
===================================================================
--- /trunk/latex-doc/examples.tex	(revision 8)
+++ /trunk/latex-doc/examples.tex	(revision 8)
@@ -0,0 +1,179 @@
+\begin{verbatim}
+;;----------------------------------------------------------------
+;;
+;; (STRING-GROBNER "[x^2+y,x-y]" '(X Y))
+;;
+;;----------------------------------------------------------------
+Args:[ X^2 + Y, X - Y ]
+[ X - Y, Y^2 + Y ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-GROBNER "[y-x^2,z-x^3]" '(X Y Z) :ORDER #'GREVLEX>)
+;;
+;;----------------------------------------------------------------
+Args:[  - X^2 + Y,  - X^3 + Z ]
+[ X^2 - Y, X * Y - Z, Y^2 - X * Z ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-GROBNER-SYSTEM "[u*x+y,x+y]" '(X Y) '(U))
+;;
+;;----------------------------------------------------------------
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [ U ]
+  Red list: [  ]
+ Basis: [ (1) * Y, (1) * X ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ U, U - 1 ]
+ Basis: [ (U - 1) * X, ( - U + 1) * Y ]
+------------------- CASE 3 -------------------
+Condition:
+  Green list: [ U - 1 ]
+  Red list: [ U ]
+ Basis: [ (1) * X + (1) * Y ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-GROBNER-SYSTEM "[u*x+y,x+y]" '(X Y) '(U) :COVER '(("[u-1]" "[]")))
+;;
+;;----------------------------------------------------------------
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [ U - 1 ]
+  Red list: [ U ]
+ Basis: [ (1) * X + (1) * Y ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-READ-POLY "[x^3+3*x^2+3*x+1]" '(X))
+;;
+;;----------------------------------------------------------------
+Args:[ X^3 + 3 * X^2 + 3 * X + 1 ]
+[ RETURN VALUE 1]-->> ([ (((3) . 1) ((2) . 3) ((1) . 3) ((0) . 1)))
+
+;;----------------------------------------------------------------
+;;
+;; (STRING-ELIMINATION-IDEAL "[x^2+y^2-2,x*y-1]" '(X Y) 1)
+;;
+;;----------------------------------------------------------------
+Args:[ X^2 + Y^2 - 2, X * Y - 1 ]
+[ Y^4 - 2 * Y^2 + 1 ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-IDEAL-SATURATION-1 "[x^2*y,y^3]" "x" '(X Y))
+;;
+;;----------------------------------------------------------------
+[ Y ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-IDEAL-POLYSATURATION-1 "[x^2*y,y^3]" "[x,y]" '(X Y))
+;;
+;;----------------------------------------------------------------
+Args1:[ X^2 * Y, Y^3 ]
+Args2:[ X, Y ]
+[ 1 ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-COND '("[u^2-v]" "[v-1]") '(U V) #'GREVLEX>)
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]-->> (((((2 0) . 1) ((0 1) . -1))) ((((0 1) . 1) ((0 0) . -1))))
+
+;;----------------------------------------------------------------
+;;
+;; (STRING-COVER '(("[u^2-v]" "[u]") ("[u+v]" "[]")) '(U V) #'GREVLEX>)
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]-->> ((((((2 0) . 1) ((0 1) . -1))) ((((1 0) . 1)))) (((((1 0) . 1) ((0 1) . 1))) NIL))
+
+;;----------------------------------------------------------------
+;;
+;; (STRING-DETERMINE "[u*x+y,v*x^2+y^2]" '(X Y) '(U V) :COND '("[u,v]" "[v-1]") :MAIN-ORDER #'LEX>)
+;;
+;;----------------------------------------------------------------
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [ U, V ]
+  Red list: [ V - 1, 1 ]
+ Basis: [ (1) * Y, (1) * Y^2 ]
+;;----------------------------------------------------------------
+;;
+;; (PARSE-STRING-TO-SORTED-ALIST "x^2+y^3" '(X Y) #'GREVLEX>)
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]-->> (((0 3) . 1) ((2 0) . 1))
+
+;;----------------------------------------------------------------
+;;
+;; (PARSE-STRING-TO-SORTED-ALIST "[x^2+y^3,x-y]" '(X Y) #'GREVLEX>)
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]-->> ([ (((0 3) . 1) ((2 0) . 1)) (((1 0) . 1) ((0 1) . -1)))
+
+;;----------------------------------------------------------------
+;;
+;; (TRANSLATE-STATEMENTS (COLLINEAR A B C) (PERPENDICULAR A B A C))
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]-->> ((((+ (- (* B1 C2) (* B2 C1)) (- (* A2 C1) (* A1 C2)) (- (* A1 B2) (* A2 B1))))
+                        ((+ (* (- A1 B1) (- A1 C1)) (* (- A2 B2) (- A2 C2)))))
+                       (B1 B2 A1 A2 C1 C2))
+
+;;----------------------------------------------------------------
+;;
+;; (TRANSLATE-THEOREM ((PERPENDICULAR A B C D) (PERPENDICULAR C D E F))
+                      ((PARALLEL A B E F) (IDENTICAL-POINTS C D)))
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]-->> (((+ (* (- A1 B1) (- C1 D1)) (* (- A2 B2) (- C2 D2)))
+                        (+ (* (- C1 D1) (- E1 F1)) (* (- C2 D2) (- E2 F2))))
+                       (A1 A2 B1 B2 C1 C2 D1 D2 E1 E2 F1 F2))
+[ RETURN VALUE 2]-->> ((((- (* (- A1 B1) (- E2 F2)) (* (- A2 B2) (- E1 F1)))) ((- C1 D1) (- C2 D2)))
+                       (A1 A2 B1 B2 E1 E2 F1 F2 C1 C2 D1 D2))
+
+;;----------------------------------------------------------------
+;;
+;; (TRANSLATE-THEOREM ((PERPENDICULAR A B A C) (MIDPOINT B C M) (MIDPOINT A M O) (COLLINEAR B H C)
+                       (PERPENDICULAR A H B C))
+                      ((EQUIDISTANT M O H O) (IDENTICAL-POINTS B C)))
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]-->> (((+ (* (- A1 B1) (- A1 C1)) (* (- A2 B2) (- A2 C2))) (- (* 2 M1) B1 C1)
+                        (- (* 2 M2) B2 C2) (- (* 2 O1) A1 M1) (- (* 2 O2) A2 M2)
+                        (+ (- (* H1 C2) (* H2 C1)) (- (* B2 C1) (* B1 C2)) (- (* B1 H2) (* B2 H1)))
+                        (+ (* (- A1 H1) (- B1 C1)) (* (- A2 H2) (- B2 C2))))
+                       (M1 M2 O1 O2 A1 A2 H1 H2 B1 B2 C1 C2))
+[ RETURN VALUE 2]-->> ((((- (+ (EXPT (- M1 O1) 2) (EXPT (- M2 O2) 2))
+                            (+ (EXPT (- H1 O1) 2) (EXPT (- H2 O2) 2))))
+                        ((- B1 C1) (- B2 C2)))
+                       (M1 M2 H1 H2 O1 O2 B1 B2 C1 C2))
+
+;;----------------------------------------------------------------
+;;
+;; (PROVE-THEOREM ((PERPENDICULAR A B C D) (PERPENDICULAR C D E F)) ((PARALLEL A B E F) (IDENTICAL-POINTS C D)))
+;;
+;;----------------------------------------------------------------
+[ 1 ]
+;;----------------------------------------------------------------
+;;
+;; (PROVE-THEOREM ((PERPENDICULAR A B A C) (MIDPOINT B C M) (MIDPOINT A M O) (COLLINEAR B H C)
+                   (PERPENDICULAR A H B C))
+                  ((EQUIDISTANT M O H O) (IDENTICAL-POINTS B C)))
+;;
+;;----------------------------------------------------------------
+[ 1 ]
+;;----------------------------------------------------------------
+;;
+;; (PROVE-THEOREM ((PERPENDICULAR A B A C) (IDENTICAL-POINTS B C))
+                  ((IDENTICAL-POINTS A B) (IDENTICAL-POINTS A C)))
+;;
+;;----------------------------------------------------------------
+[ B1 - C1, B2 - C2, A1^2 + A2^2 - 2 * A1 * C1 + C1^2 - 2 * A2 * C2 + C2^2 ]
+;;----------------------------------------------------------------
+;;
+;; (PROVE-THEOREM ((PERPENDICULAR A B A C) (IDENTICAL-POINTS B C))
+                  ((IDENTICAL-POINTS A B) (REAL-IDENTICAL-POINTS A C)))
+;;
+;;----------------------------------------------------------------
+[ 1 ]
+\end{verbatim}
Index: /trunk/latex-doc/grobner.tex
===================================================================
--- /trunk/latex-doc/grobner.tex	(revision 8)
+++ /trunk/latex-doc/grobner.tex	(revision 8)
@@ -0,0 +1,574 @@
+\begin{lisp:documentation}{*grobner$-$debug*}{VARIABLE}{nil }
+If T, produce debugging and tracing output.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*buchberger$-$merge$-$pairs*}{VARIABLE}{'buchberger$-$merge$-$pairs$-$smallest$-$lcm }
+A variable holding the predicate used to sort critical pairs
+in the order of decreasing priority for the Buchberger algorithm.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*gebauer$-$moeller$-$merge$-$pairs*}{VARIABLE}{'gebauer$-$moeller$-$merge$-$pairs$-$use$-$mock$-$spoly }
+A variable holding the predicate used to sort critical pairs
+in the order of decreasing priority for the Gebauer$-$Moeller
+algorithm 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*grobner$-$function*}{VARIABLE}{'buchberger }
+The name of the function used to calculate Grobner basis
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{select$-$grobner$-$algorithm}{FUNCTION}{algorithm }
+Select one of the several implementations of the Grobner basis
+algorithm.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{grobner}{FUNCTION}{f {\sf \&optional} (pred \#'lex$>$) (start 0) (top$-$reduction$-$only nil) (ring *coefficient$-$ring*) }
+Return Grobner basis of an ideal generated by polynomial list F.
+Assume that the monomials of each polynomial are ordered according to
+the admissible monomial order PRED. The result will be a list of
+polynomials ordered as well according to PRED. The polynomials from 0
+to START$-$1 in the list F are assumed to be a Grobner basis, and
+thus certain critical pairs do not have to be calculated. If
+TOP$-$REDUCTION$-$ONLY is not NIL then only top reductions will be
+performed, instead of full division, and thus the returned Grobner
+basis will have its polynomials only top$-$reduced with respect to
+the preceding polynomials. RING should be set to the RING structure
+(see COEFFICIENT$-$RING package) corresponding to the coefficients of
+the polynomials in the list F. This function is currently just an
+interface to several algorithms which fine Grobner bases. Use
+SELECT$-$GROBNER$-$ALGORITHM in order to change the algorithm.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{debug$-$cgb}{MACRO}{{\sf \&rest} args }
+This macro is used in printing debugging and tracing messages
+and its arguments are analogous to the FORMAT function, except
+that the stream argument is omitted. By default, the output is
+sent to *trace$-$output*, which can be set to produce output 
+in a file.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{spoly}{FUNCTION}{f g pred ring }
+Return the S$-$polynomial of F and G, which should
+be two polynomials with terms ordered by PRED and
+coefficients in a ring whose operations are the slots
+of the RING structure.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{grobner$-$primitive$-$part}{FUNCTION}{p ring }
+Divide polynomial P with integer coefficients by gcd of its
+coefficients and return the result. Use the RING structure from the
+COEFFICIENT$-$RING package to perform the operations on the
+coefficients.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{grobner$-$content}{FUNCTION}{p ring }
+Greatest common divisor of the coefficients of the polynomial P. Use
+the RING structure to compute the greatest common divisor.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{normal$-$form}{FUNCTION}{f fl pred top$-$reduction$-$only ring }
+Calculate the normal form of the polynomial F with respect to
+the polynomial list FL. Destructive to F; thus, copy$-$tree should be
+used where F needs to be preserved. It returns multiple values.
+The first value is the polynomial R which is reduced (or
+top$-$reduced if TOP$-$REDUCTION$-$ONLY is not NIL). The second value
+is an integer which is the number of reductions actually performed.
+The third value is the coefficient by which F needs to be multiplied
+in order to be able to perform the division without actually having
+to divide in the coefficient ring (a form of pseudo$-$division is
+used). All operations on the coefficients are performed using the
+RING structure from the COEFFICIENT$-$RING package.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{buchberger}{FUNCTION}{f pred start top$-$reduction$-$only ring {\sf \&aux} (s (1$-$ (length f))) b m }
+An implementation of the Buchberger algorithm. Return Grobner
+basis of the ideal generated by the polynomial list F.
+The terms of each polynomial are ordered by the admissible
+monomial order PRED. Polynomials 0 to START$-$1 are assumed to
+be a Grobner basis already, so that certain critical pairs
+will not be examined. If TOP$-$REDUCTION$-$ONLY set, top reduction
+will be preformed. The RING structure is used to perform operations
+on coefficents (see COEFFICIENT$-$RING package).
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{grobner$-$op}{FUNCTION}{c1 c2 m a b pred ring {\sf \&aux} n a1 a2 }
+Perform a calculation equivalent to
+(POLY$-$ (SCALAR$-$TIMES$-$POLY C2 A)
+	 (SCALAR$-$TIMES$-$POLY C1 (MONOM$-$TIMES$-$POLY M B))
+	 PRED)
+but more efficiently; it destructively modifies A and stores the 
+result in it; A is returned.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{buchberger$-$sort$-$pairs}{FUNCTION}{b g pred ring }
+Sort critical pairs B by the function which is
+the value of the vairable *buchberger$-$merge$-$pairs*.
+G is the list of polynomials which the elemnts
+of B point into. PRED is the admissible monomial order.
+The RING structure holds operations on the coefficients
+as described in the COEFFICIENT$-$RING package.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{mock$-$spoly}{FUNCTION}{f g pred }
+Returns an upper$-$bound on the leading
+monomial of the S$-$polynomial of F and G, which are two polynomials
+sorted by the admissible monomial order PRED.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{buchberger$-$merge$-$pairs$-$use$-$mock$-$spoly}{FUNCTION}{b c g pred ring }
+Merges lists of critical pairs B and C into one list. 
+The pairs are assumed to be ordered according to the
+increasing value of MOCK$-$SPOLY, as determined by the admissible
+monomial order PRED. G is the list of polynomials which the pairs
+of integers in B and C point into, and RING is the ring structure
+defined in the COEFFICIENT$-$RING package.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{buchberger$-$merge$-$pairs$-$smallest$-$lcm}{FUNCTION}{b c g pred ring }
+Merges lists of critical pairs B and C into a single ordered
+list. Implements a strategy of ordering pairs according to the
+smallest lcm of the leading monomials of the two polynomials $-$ so
+called normal strategy.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{buchberger$-$merge$-$pairs$-$use$-$smallest$-$degree}{FUNCTION}{b c g pred ring }
+Mergest lists B and C of critical pairs. This strategy is based on
+ordering the pairs according to the smallest degree of the lcm of
+the leading monomials of the two polynomials.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{buchberger$-$merge$-$pairs$-$use$-$smallest$-$length}{FUNCTION}{b c g pred ring }
+Mergest lists B and C of critical pairs. This strategy is based on
+ordering the pairs according to the smallest total length of the 
+two polynomials, where length is the number of terms.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{buchberger$-$merge$-$pairs$-$use$-$smallest$-$coefficient$-$length}{FUNCTION}{b c g pred ring }
+Mergest lists B and C of critical pairs. This strategy is based on
+ordering the pairs according to the smallest combined length of the 
+coefficients of the two polynomials.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{buchberger$-$set$-$pair$-$heuristic}{FUNCTION}{method {\sf \&aux} (strategy$-$fn
+                                                                                              (ecase method (:minimal$-$mock$-$spoly \#'buchberger$-$merge$-$pairs$-$use$-$mock$-$spoly)
+                                                                                               (:minimal$-$lcm \#'buchberger$-$merge$-$pairs$-$smallest$-$lcm)
+                                                                                               (:minimal$-$total$-$degree \#'buchberger$-$merge$-$pairs$-$use$-$smallest$-$degree)
+                                                                                               (:minimal$-$length \#'buchberger$-$merge$-$pairs$-$use$-$smallest$-$length)
+                                                                                               (:minimal$-$coefficient$-$length \#'buchberger$-$merge$-$pairs$-$use$-$smallest$-$coefficient$-$length))) }
+Simply sets the variable *buchberger$-$merge$-$pairs* to the
+heuristic function STRATEGY$-$FN implementing one of several
+strategies introduces before of selecting the most promising. METHOD
+should be one of the listed keywords.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{criterion$-$1}{FUNCTION}{pair g {\sf \&aux} (i (first pair)) (j (second pair)) }
+Returns T if the leading monomials of the two polynomials
+in G pointed to by the integers in PAIR have disjoint (relatively
+prime) monomials. This test is known as the first Buchberger
+criterion. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{criterion$-$2}{FUNCTION}{pair g m {\sf \&aux} (i (first pair)) (j (second pair)) }
+Returns T if the leading monomial of some element P of G divides
+the LCM of the leading monomials of the two polynomials in the
+polynomial list G, pointed to by the two integers in PAIR, and P
+paired with each of the polynomials pointed to by the the PAIR has
+already been treated, as indicated by the hash table M, which stores
+value T for every treated pair so far.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{normalize$-$poly}{FUNCTION}{p ring }
+Divide a polynomial by its leading coefficient. It assumes
+that the division is possible, which may not always be the
+case in rings which are not fields. The exact division operator
+is assumed to be provided by the RING structure of the
+COEFFICIENT$-$RING package.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{normalize$-$basis}{FUNCTION}{plist ring }
+Divide every polynomial in a list PLIST by its leading coefficient.
+Use RING structure to perform the division of the coefficients.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{reduction}{FUNCTION}{p pred ring }
+Reduce a list of polynomials P, so that non of the terms in any of
+the polynomials is divisible by a leading monomial of another
+polynomial. Return the reduced list.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{reduced$-$grobner}{FUNCTION}{f {\sf \&optional} (pred \#'lex$>$) (start 0) (top$-$reduction$-$only nil) (ring *coefficient$-$ring*) }
+Return the reduced Grobner basis of the ideal generated by a
+polynomial list F. This combines calls to two functions: GROBNER and
+REDUCTION. The parameters have the same meaning as in GROBNER or
+BUCHBERGER. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$depends$-$p}{FUNCTION}{m k }
+Return T if the monomial M depends on variable number K.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{term$-$depends$-$p}{FUNCTION}{term k }
+Return T if the term TERM depends on variable number K.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$depends$-$p}{FUNCTION}{p k }
+Return T if the term polynomial P depends on variable number K.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ring$-$intersection}{FUNCTION}{plist k {\sf \&key} (key \#'identity) }
+This function assumes that polynomial list PLIST is a Grobner basis
+and it calculates the intersection with the ring R[x[k+1],...,x[n]],
+i.e. it discards polynomials which depend on variables x[0], x[1],
+..., x[k]. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{elimination$-$ideal}{FUNCTION}{flist k {\sf \&key} (primary$-$order \#'lex$>$) (secondary$-$order \#'lex$>$) (start 0) (order
+                                                                                                                                                   (elimination$-$order k :primary$-$order primary$-$order
+                                                                                                                                                    :secondary$-$order secondary$-$order)) (top$-$reduction$-$only
+                                                                                                                                                                                            nil) (ring
+                                                                                                                                                                                                  *coefficient$-$ring*) }
+Returns the K$-$th elimination ideal of the ideal generated by
+polynomial list FLIST. Thus, a Grobner basis of the ideal generated
+by FLIST is calculated and polynomials depending on variables 0$-$K
+are discarded. The monomial order in the calculation is an
+elimination order formed by combining two orders: PRIMARY$-$ORDER
+used on variables 0$-$K and SECONDARY$-$ORDER used on variables
+starting from variable K+1. Thus, if both orders are set to the
+lexicographic order \#'LEX$>$ then the resulting order is simply
+equivalent to \#'LEX$>$. But one could use arbitrary two orders in
+this function, for instance, two copies of \#'GREVLEX$>$ (see ORDER
+package). When doing so, the caller must ensure that the same order
+has been used to sort the terms of the polynomials FLIST. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ideal$-$intersection}{FUNCTION}{f g pred top$-$reduction$-$only ring }
+Return the Grobner basis of the intersection of the ideals
+generated by the polynomial lists F and G. PRED is an admissible
+monomial order with respect to which the terms of F and G have been
+sorted. This order is going to be used in the Grobner basis
+calculation. If TOP$-$REDUCTION$-$ONLY is not NIL, internally the
+Grobner basis algorithm will perform top reduction only.  The RING
+parameter, as usual, should be set to a structure defined in the
+package COEFFICIENT$-$RING, and it will be used to perform all
+operations on coefficients.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$contract}{FUNCTION}{f {\sf \&optional} (k 1) }
+Return a polynomial obtained from polynomial F by dropping the
+first K variables, if F does not depend on them.  Note that this
+operation makes the polynomial incompatible for certain arithmetical
+operations with the original polynomial F. Calling this function on a
+polynomial F which does depend on variables 0$-$K will result in
+error. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$lcm}{FUNCTION}{f g {\sf \&optional} (pred \#'lex$>$) (ring *coefficient$-$ring*) }
+Return LCM (least common multiple) of two polynomials F and G.
+The polynomials must be ordered according to monomial order PRED
+and their coefficients must be compatible with the RING structure
+defined in the COEFFICIENT$-$RING package.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{grobner$-$gcd}{FUNCTION}{f g {\sf \&optional} (pred \#'lex$>$) (ring *coefficient$-$ring*) }
+Return GCD (greatest common divisor) of two polynomials F and G.
+The polynomials must be ordered according to monomial order PRED
+and their coefficients must be compatible with the RING structure
+defined in the COEFFICIENT$-$RING package.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{grobner$-$equal}{FUNCTION}{g1 g2 {\sf \&optional} (pred \#'lex$>$) (ring *coefficient$-$ring*) }
+Returns T if two lists of polynomials G1 and G2, assumed to be
+Grobner bases, generate  the same ideal, and NIL otherwise.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{grobner$-$subsetp}{FUNCTION}{g1 g2 {\sf \&optional} (pred \#'lex$>$) (ring *coefficient$-$ring*) }
+Returns T if a list of polynomials G1 generates
+an ideal contained in the ideal generated by a polynomial list G2,
+both G1 and G2 assumed to be Grobner bases. Returns NIL otherwise.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{grobner$-$member}{FUNCTION}{p g {\sf \&optional} (pred \#'lex$>$) (ring *coefficient$-$ring*) }
+Returns T if a polynomial P belongs to the ideal generated by the
+polynomial list G, which is assumed to be a Grobner basis. Returns
+NIL otherwise. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ideal$-$equal}{FUNCTION}{f1 f2 pred top$-$reduction$-$only ring }
+Returns T if two ideals generated by polynomial lists F1 and F2 are
+identical. Returns NIL otherwise.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ideal$-$subsetp}{FUNCTION}{f1 f2 {\sf \&optional} (pred \#'lex$>$) (ring *coefficient$-$ring*) }
+Returns T if the ideal spanned by the polynomial list F1 is contained
+in the ideal spanned by the polynomial list F2. Returns NIL
+otherwise. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ideal$-$member}{FUNCTION}{p plist pred top$-$reduction$-$only ring }
+Returns T if the polynomial P belongs to the ideal spanned by the
+polynomial list PLIST, and NIL otherwise.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ideal$-$saturation$-$1}{FUNCTION}{f p pred start top$-$reduction$-$only ring {\sf \&aux} (pred (elimination$-$order$-$1 pred)) }
+Returns the reduced Grobner basis of the saturation of the ideal
+generated by a polynomial list F in the ideal generated by a single
+polynomial P. The saturation ideal is defined as the set of
+polynomials H such for some natural number n (* (EXPT P N) H) is in
+the ideal F. Geometrically, over an algebraically closed field, this
+is the set of polynomials in the ideal generated by F which do not
+identically vanish on the variety of P.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{add$-$variables}{FUNCTION}{plist n }
+Add N new variables, adn the first N variables, to every polynomial
+in polynomial list PLIST. The resulting polynomial will not depend on
+these N variables. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{extend$-$polynomials}{FUNCTION}{plist {\sf \&aux} (k (length plist)) }
+Returns polynomial list \{U1*P1', U2*P2', ... , UK*PK'\}
+where Ui are new variables and PLIST=\{P1, P2, ... , PK\} is a
+polynomial list. PI' is obtained from PI by adding new variables U1,
+U2, ..., UN UK as the first K variables. Thus, the resulting list is
+consists of polynomials whose terms are ordered by the lexicographic
+order on variables UI, with ties resolved by the monomial order which
+was used to order the terms of the polynomials in PLIST. We note that
+the monomial order does not explicitly participate in this
+calculation, and neither do the variable names.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{saturation$-$extension}{FUNCTION}{f plist ring {\sf \&aux} (k (length plist)) (d (+ k (length (caaar plist)))) }
+Returns F' union \{U1*P1$-$1,U2*P2$-$1,...,UK*PK$-$1\} where Ui are
+new variables and F' is a polynomial list  obtained from F by adding
+variables U1, U2, ..., Uk as the first K variables to each polynomial
+in F. Thus, the resulting list is consists of polynomials whose terms
+are ordered by the lexicographic order on variables Ui, with ties
+resolved by the monomial order which was used to order the terms of
+the polynomials in F. We note that the monomial order does not
+explicitly participate in this calculation, and neither do the
+variable names. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{polysaturation$-$extension}{FUNCTION}{f plist ring {\sf \&aux} (k (length plist)) (d (+ k (length (caaar plist)))) }
+Returns F' union \{U1*P1+U2*P2+UK*PK$-$1\} where Ui are new variables
+and F' is a polynomial list  obtained from F by adding variables U1,
+U2, ..., Uk as the first K variables to each polynomial in F. Thus,
+the resulting list is consists of polynomials whose terms are ordered
+by the lexicographic order on variables Ui, with ties resolved by the
+monomial order which was used to order the terms of the polynomials
+in F. We note that the monomial order does not explicitly participate
+in this calculation, and neither do the variable names. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{saturation$-$extension$-$1}{FUNCTION}{f p ring }
+Return the list F' union \{U*P$-$1\} where U is a new variable,
+where F' is obtained from the polynomial list F by adding U as the
+first variable. The variable U will be added as the first variable,
+so that it can be easily eliminated.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ideal$-$polysaturation$-$1}{FUNCTION}{f plist pred start top$-$reduction$-$only ring }
+Returns the reduced Grobner basis of the ideal obtained by a
+sequence of successive saturations in the polynomials
+of the polynomial list PLIST of the ideal generated by the
+polynomial list F.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ideal$-$saturation}{FUNCTION}{f g pred start top$-$reduction$-$only ring {\sf \&aux} (k (length g)) (pred (elimination$-$order k :primary$-$order \#'lex$>$ :secondary$-$order pred)) }
+Returns the reduced Grobner basis of the saturation of the ideal
+generated by a polynomial list F in the ideal generated a polynomial
+list G The saturation ideal is defined as the set of polynomials H
+such for some natural number n and some P in the ideal generated by G
+the polynomial P**N * H is in the ideal spanned by F.  Geometrically,
+over an algebraically closed field, this is the set of polynomials in
+the ideal generated by F which do not identically vanish on the
+variety of G.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ideal$-$polysaturation}{FUNCTION}{f ideal$-$list pred start top$-$reduction$-$only ring }
+Returns the reduced Grobner basis of the ideal obtained by a
+successive applications of IDEAL$-$SATURATIONS to F and
+lists of polynomials in the list IDEAL$-$LIST.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{buchberger$-$criterion}{FUNCTION}{g pred ring }
+Returns T if G is a Grobner basis, by using the Buchberger
+criterion: for every two polynomials h1 and h2 in G the
+S$-$polynomial S(h1,h2) reduces to 0 modulo G.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{grobner$-$test}{FUNCTION}{g f pred ring }
+Test whether G is a Grobner basis and F is contained in G. Return T
+upon success and NIL otherwise.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{minimization}{FUNCTION}{p pred }
+Returns a sublist of the polynomial list P spanning the same
+monomial ideal as P but minimal, i.e. no leading monomial
+of a polynomial in the sublist divides the leading monomial
+of another polynomial.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{add$-$minimized}{FUNCTION}{f gred pred }
+Adds a polynomial f to GRED, reduced Grobner basis, preserving the
+property described in the documentation for MINIMIZATION.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colon$-$ideal}{FUNCTION}{f g pred top$-$reduction$-$only ring }
+Returns the reduced Grobner basis of the colon ideal Id(F):Id(G),
+where F and G are two lists of polynomials. The colon ideal I:J is
+defined as the set of polynomials H such that there is a polynomial W
+in J for which W*H belongs to I.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{colon$-$ideal$-$1}{FUNCTION}{f g pred top$-$reduction$-$only ring }
+Returns the reduced Grobner basis of the colon ideal Id(F):Id(\{G\}),
+where F is a list of polynomials and G is a polynomial.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{pseudo$-$divide}{FUNCTION}{f fl pred ring }
+Pseudo$-$divide a polynomial F by the list of polynomials FL. Return
+multiple values. The first value is a list of quotients A.
+The second value is the remainder R. The third value is an integer
+count of the number of reductions performed. Finally, the fourth
+argument is a scalar coefficient C, such that C*F can be divided by
+FL within the ring of coefficients, which is not necessarily a field.
+The resulting objects satisfy the equation:
+ C*F= sum A[i]*FL[i] + R
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{gebauer$-$moeller}{FUNCTION}{f pred start top$-$reduction$-$only ring {\sf \&aux} b g f1 }
+Compute Grobner basis by using the algorithm of Gebauer and Moeller.
+This algorithm is described as BUCHBERGERNEW2 in the book by
+Becker$-$Weispfenning entitled ``Grobner Bases''
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{update}{FUNCTION}{g b h pred ring {\sf \&aux} c d e b$-$new g$-$new pair }
+An implementation of the auxillary UPDATE algorithm used by the
+Gebauer$-$Moeller algorithm. G is a list of polynomials, B is a list
+of critical pairs and H is a new polynomial which possibly will be
+added to G. The naming conventions used are very close to the one
+used in the book of Becker$-$Weispfenning.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{gebauer$-$moeller$-$merge$-$pairs$-$use$-$mock$-$spoly}{FUNCTION}{b c pred ring }
+The merging strategy used by the Gebauer$-$Moeller algorithm, based
+on MOCK$-$SPOLY; see the documentation of
+BUCHBERGER$-$MERGE$-$PAIRS$-$USE$-$MOCK$-$SPOLY.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{gebauer$-$moeller$-$merge$-$pairs$-$smallest$-$lcm}{FUNCTION}{b c pred ring }
+The merging strategy based on the smallest$-$lcm (normal strategy);
+see the documentation of BUCHBERGER$-$MERGE$-$PAIRS$-$SMALLEST$-$LCM.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$degree}{FUNCTION}{b c pred ring }
+The merging strategy based on the smallest$-$lcm (normal strategy);
+see the documentation of
+BUCHBERGER$-$MERGE$-$PAIRS$-$USE$-$SMALLEST$-$DEGREE. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$length}{FUNCTION}{b c pred ring }
+{\ } % NO DOCUMENTATION FOR GEBAUER-MOELLER-MERGE-PAIRS-USE-SMALLEST-LENGTH
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$coefficient$-$length}{FUNCTION}{b c pred ring }
+The merging strategy based on the smallest$-$lcm (normal strategy);
+see the documentation of
+BUCHBERGER$-$MERGE$-$PAIRS$-$USE$-$SMALLEST$-$COEFFICIENT$-$LENGTH. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{gebauer$-$moeller$-$set$-$pair$-$heuristic}{FUNCTION}{method {\sf \&aux} (strategy$-$fn
+                                                                                                     (ecase method (:minimal$-$mock$-$spoly \#'gebauer$-$moeller$-$merge$-$pairs$-$use$-$mock$-$spoly)
+                                                                                                      (:minimal$-$lcm \#'gebauer$-$moeller$-$merge$-$pairs$-$smallest$-$lcm)
+                                                                                                      (:minimal$-$total$-$degree \#'gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$degree)
+                                                                                                      (:minimal$-$length \#'gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$length)
+                                                                                                      (:minimal$-$coefficient$-$length
+                                                                                                       \#'gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$coefficient$-$length))) }
+{\ } % NO DOCUMENTATION FOR GEBAUER-MOELLER-SET-PAIR-HEURISTIC
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{spoly$-$sugar}{FUNCTION}{f$-$with$-$sugar g$-$with$-$sugar ring }
+Calculate the ``sugar'' of the S$-$polynomial of two polynomials with
+sugar. A polynomial with sugar is simply a pair (P . SUGAR) where
+SUGAR is an integer constant defined according to the following
+algorighm: the sugar of sum or difference of two polynomials with
+sugar is the MAX of the sugars of those two polynomials. The sugar of
+a product of a term and a polynomial is the sum of the degree of the
+term and the sugar of the polynomial.  The idea is to accumulate
+sugar as we perform the arithmetic operations, and that polynomials
+with small (little) sugar should be given priority in the
+calculations. Thus, the ``sugar strategy'' of the critical pair
+selection is to select a pair with the smallest value of sugar of the
+resulting S$-$polynomial.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{spoly$-$with$-$sugar}{FUNCTION}{f$-$with$-$sugar g$-$with$-$sugar pred ring }
+The S$-$polynomials of two polynomials with SUGAR strategy.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{normal$-$form$-$with$-$sugar}{FUNCTION}{f fl pred top$-$reduction$-$only ring }
+Normal form of the polynomial with sugar F with respect to
+a list of polynomials with sugar FL. Assumes that FL is not empty.
+Parameters PRED, TOP$-$REDUCTION$-$ONLY and RING have the same
+meaning as in NORMAL$-$FORM. The parameter SUGAR$-$LIMIT should be
+set to a positive integer. If the sugar limit of the partial
+remainder exceeds SUGAR$-$LIMIT then the calculation is stopped and
+the partial remainder is returned, although it is not fully reduced
+with respect to FL. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{buchberger$-$with$-$sugar}{FUNCTION}{f$-$no$-$sugar pred start top$-$reduction$-$only ring {\sf \&aux} (s (1$-$ (length f$-$no$-$sugar))) b m f }
+Returns a Grobner basis of an ideal generated by a list of ordinary
+polynomials F$-$NO$-$SUGAR. Adds initial sugar to the polynomials and
+performs the Buchberger algorithm with ``sugar strategy''. It returns
+an ordinary list of polynomials with no sugar. One of the most
+effective algorithms for Grobner basis calculation.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{buchberger$-$with$-$sugar$-$merge$-$pairs}{FUNCTION}{b c g m pred ring }
+Merges lists of critical pairs. It orders pairs according to
+increasing sugar, with ties broken by smaller MOCK$-$SPOLY value of
+the two polynomials. In this function B must already be sorted.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{buchberger$-$with$-$sugar$-$sort$-$pairs}{FUNCTION}{c g m pred ring }
+Sorts critical pairs C according to sugar strategy.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{criterion$-$1$-$with$-$sugar}{FUNCTION}{pair g {\sf \&aux} (i (first pair)) (j (second pair)) }
+An implementation of Buchberger's first criterion for polynomials 
+with sugar. See the documentation of BUCHBERGER$-$CRITERION$-$1.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{criterion$-$2$-$with$-$sugar}{FUNCTION}{pair g m {\sf \&aux} (i (first pair)) (j (second pair)) }
+An implementation of Buchberger's first criterion for polynomials 
+with sugar. See the documentation of BUCHBERGER$-$CRITERION$-$2.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{gebauer$-$moeller$-$with$-$sugar}{FUNCTION}{f pred start top$-$reduction$-$only ring {\sf \&aux} b g f1 }
+Compute Grobner basis by using the algorithm of Gebauer and Moeller.
+This algorithm is described as BUCHBERGERNEW2 in the book by
+Becker$-$Weispfenning entitled ``Grobner Bases''
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{update$-$with$-$sugar}{FUNCTION}{g b h pred ring {\sf \&aux} c d e b$-$new g$-$new pair }
+An implementation of the auxillary UPDATE algorithm used by the
+Gebauer$-$Moeller algorithm. G is a list of polynomials, B is a list
+of critical pairs and H is a new polynomial which possibly will be
+added to G. The naming conventions used are very close to the one
+used in the book of Becker$-$Weispfenning. Operates on polynomials
+with sugar. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{gebauer$-$moeller$-$with$-$sugar$-$merge$-$pairs}{FUNCTION}{b c pred ring }
+Merges lists of critical pairs. It orders pairs according to
+increasing sugar, with ties broken by smaller lcm of head monomials
+In this function B must already be sorted. Operates on polynomials
+with sugar. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{grobner$-$primitive$-$part$-$with$-$sugar}{FUNCTION}{h ring }
+{\ } % NO DOCUMENTATION FOR GROBNER-PRIMITIVE-PART-WITH-SUGAR
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/infix.tex
===================================================================
--- /trunk/latex-doc/infix.tex	(revision 8)
+++ /trunk/latex-doc/infix.tex	(revision 8)
@@ -0,0 +1,182 @@
+\begin{lisp:documentation}{*version*}{PARAMETER}{"1.3  28$-$jun$-$96" }
+{\ } % NO DOCUMENTATION FOR *VERSION*
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*print$-$infix$-$copyright*}{PARAMETER}{t }
+If non$-$NIL, prints a copyright notice upon loading this file.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{infix$-$copyright}{FUNCTION}{{\sf \&optional} (stream *standard$-$output*) }
+Prints an INFIX copyright notice and header upon startup.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*infix$-$readtable*}{PARAMETER}{(copy$-$readtable nil) }
+{\ } % NO DOCUMENTATION FOR *INFIX-READTABLE*
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*normal$-$readtable*}{PARAMETER}{(copy$-$readtable nil) }
+{\ } % NO DOCUMENTATION FOR *NORMAL-READTABLE*
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{infix$-$error}{MACRO}{format$-$string {\sf \&rest} args }
+{\ } % NO DOCUMENTATION FOR INFIX-ERROR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{infix$-$reader}{FUNCTION}{stream subchar arg }
+{\ } % NO DOCUMENTATION FOR INFIX-READER
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$$>$prefix}{FUNCTION}{string }
+Convert a string to a prefix s$-$expression using the infix reader.
+ If the argument is not a string, just return it as is.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{read$-$infix}{FUNCTION}{stream }
+{\ } % NO DOCUMENTATION FOR READ-INFIX
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{read$-$regular}{FUNCTION}{stream }
+{\ } % NO DOCUMENTATION FOR READ-REGULAR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{same$-$operator$-$p}{FUNCTION}{x y }
+{\ } % NO DOCUMENTATION FOR SAME-OPERATOR-P
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{same$-$token$-$p}{FUNCTION}{x y }
+{\ } % NO DOCUMENTATION FOR SAME-TOKEN-P
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*peeked$-$token*}{VARIABLE}{nil }
+{\ } % NO DOCUMENTATION FOR *PEEKED-TOKEN*
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{read$-$token}{FUNCTION}{stream }
+{\ } % NO DOCUMENTATION FOR READ-TOKEN
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{peek$-$token}{FUNCTION}{stream }
+{\ } % NO DOCUMENTATION FOR PEEK-TOKEN
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{fancy$-$number$-$format$-$p}{FUNCTION}{left operator stream }
+{\ } % NO DOCUMENTATION FOR FANCY-NUMBER-FORMAT-P
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{valid$-$numberp}{FUNCTION}{string }
+{\ } % NO DOCUMENTATION FOR VALID-NUMBERP
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{gather$-$superiors}{FUNCTION}{previous$-$operator stream }
+Gathers an expression whose operators all exceed the precedence of
+the operator to the left.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{get$-$first$-$token}{FUNCTION}{stream }
+{\ } % NO DOCUMENTATION FOR GET-FIRST-TOKEN
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{apply$-$token$-$prefix$-$operator}{FUNCTION}{token stream }
+{\ } % NO DOCUMENTATION FOR APPLY-TOKEN-PREFIX-OPERATOR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{get$-$next$-$token}{FUNCTION}{stream left }
+{\ } % NO DOCUMENTATION FOR GET-NEXT-TOKEN
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{apply$-$token$-$infix$-$operator}{FUNCTION}{token left stream }
+{\ } % NO DOCUMENTATION FOR APPLY-TOKEN-INFIX-OPERATOR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{infix$-$read$-$delimited$-$list}{FUNCTION}{end$-$token delimiter$-$token stream }
+{\ } % NO DOCUMENTATION FOR INFIX-READ-DELIMITED-LIST
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*operator$-$ordering*}{PARAMETER}{'(([ ( !) (\symbol{94}) (~) (* / \%) (+ $-$) ($<$$<$ $>$$>$) ($<$ == $>$ $<$= != $>$=) (\&) (\symbol{94}\symbol{94}) (|) (not) (and) (or) (= := += $-$= *= /=) (,) (if) (then else) (] )) (\%infix$-$end$-$token\%)) }
+Ordered list of operators of equal precedence.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{operator$-$lessp}{FUNCTION}{op1 op2 }
+{\ } % NO DOCUMENTATION FOR OPERATOR-LESSP
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*right$-$associative$-$operators*}{PARAMETER}{'(\symbol{94} =) }
+{\ } % NO DOCUMENTATION FOR *RIGHT-ASSOCIATIVE-OPERATORS*
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{operator$-$right$-$associative$-$p}{FUNCTION}{operator }
+{\ } % NO DOCUMENTATION FOR OPERATOR-RIGHT-ASSOCIATIVE-P
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*token$-$operators*}{VARIABLE}{nil }
+{\ } % NO DOCUMENTATION FOR *TOKEN-OPERATORS*
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*token$-$prefix$-$operator$-$table*}{VARIABLE}{(make$-$hash$-$table) }
+{\ } % NO DOCUMENTATION FOR *TOKEN-PREFIX-OPERATOR-TABLE*
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*token$-$infix$-$operator$-$table*}{VARIABLE}{(make$-$hash$-$table) }
+{\ } % NO DOCUMENTATION FOR *TOKEN-INFIX-OPERATOR-TABLE*
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{token$-$operator$-$p}{FUNCTION}{token }
+{\ } % NO DOCUMENTATION FOR TOKEN-OPERATOR-P
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{get$-$token$-$prefix$-$operator}{FUNCTION}{token }
+{\ } % NO DOCUMENTATION FOR GET-TOKEN-PREFIX-OPERATOR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{get$-$token$-$infix$-$operator}{FUNCTION}{token }
+{\ } % NO DOCUMENTATION FOR GET-TOKEN-INFIX-OPERATOR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{define$-$token$-$operator}{MACRO}{operator$-$name {\sf \&key} (prefix nil prefix$-$p) (infix nil infix$-$p) }
+{\ } % NO DOCUMENTATION FOR DEFINE-TOKEN-OPERATOR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{define$-$character$-$tokenization}{MACRO}{char function }
+{\ } % NO DOCUMENTATION FOR DEFINE-CHARACTER-TOKENIZATION
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{post$-$process$-$expression}{FUNCTION}{expression }
+{\ } % NO DOCUMENTATION FOR POST-PROCESS-EXPRESSION
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*test$-$cases*}{PARAMETER}{'((1 * +2 (* 1 2)) (1 * $-$2 (* 1 ($-$ 2))) (1 * /2 (* 1 (/ 2))) (/2 (/ 2)) (not true (not true)) (foo$\backslash$$-$bar foo$-$bar) (a + b$-$c (+ a b ($-$ c))) (a + b$\backslash$$-$c (+ a b$-$c)) (f$\backslash$oo foo) (!foo$-$bar * 2 (* foo$-$bar 2))
+ (!(foo bar baz) (foo bar baz)) (!foo$-$bar  foo$-$bar) (!foo$-$bar foo$-$bar) (a+$-$b (+ a ($-$ b))) (a+b (+ a b)) (a+b*c (+ a (* b c))) (a+b+c (+ a b c)) (a+b$-$c (+ a b ($-$ c))) (a+b$-$c+d (+ a b ($-$ c) d))
+ (a+b$-$c$-$d (+ a b ($-$ c) ($-$ d))) (a$-$b ($-$ a b)) (a*b (* a b)) (a*b*c (* a b c)) (a*b+c (+ (* a b) c)) (a/b (/ a b)) (a\symbol{94}b (expt a b)) (foo/$-$bar (/ foo ($-$ bar))) (1+2*3\symbol{94}4 (+ 1 (* 2 (expt 3 4))))
+ (1+2*3\symbol{94}4+5 (+ 1 (* 2 (expt 3 4)) 5)) (2*3\symbol{94}4+1 (+ (* 2 (expt 3 4)) 1)) (2+3\symbol{94}4*5 (+ 2 (* (expt 3 4) 5))) (2\symbol{94}3\symbol{94}4 (expt 2 (expt 3 4))) (x\symbol{94}2 + y\symbol{94}2 (+ (expt x 2) (expt y 2))) ((1+2)/3 (/ (+ 1 2) 3)) ((a=b) (setq a b))
+ ((a=b,b=c) (progn (setq a b) (setq b c))) (1*(2+3) (* 1 (+ 2 3))) (1+2/3 (+ 1 (/ 2 3))) (a,b (progn a b)) (a,b,c (progn a b c)) (foo(a,b,(c,d)) (foo a b (progn c d))) (foo(a,b,c) (foo a b c))
+ ((a+b,c) (progn (+ a b) c)) (1 1) ($-$1 ($-$ 1)) (+1 1) (1. 1) (1.1 1.1) (1e3 1000.0) (1e$-$3 0.001) (1f$-$3 0.001) (1e$-$3e ($-$ 1e 3e)) (!1e$-$3  0.001) (a and b and c (and a b c)) (a and b or c (or (and a b) c))
+ (a and b (and a b)) (a or b and c (or a (and b c))) (a or b (or a b)) (a$<$b and b$<$c (and ($<$ a b) ($<$ b c))) (if (if a then b else c) then e (when (if a b c) e)) (if 1 then 2 else 3+4 (if 1 2 (+ 3 4)))
+ ((if 1 then 2 else 3)+4 (+ (if 1 2 3) 4)) (if a $<$ b then b else a (if ($<$ a b) b a)) (if a and b then c and d else e and f (if (and a b) (and c d) (and e f)))
+ (if a or b then c or d else e or f (if (or a b) (or c d) (or e f))) (if a then (if b then c else d) else e (if a (if b c d) e)) (if a then (if b then c) else d (if a (when b c) d))
+ (if a then b else c (if a b c)) (if a then b (when a b)) (if a then if b then c else d else e (if a (if b c d) e)) (if a then if b then c else d (when a (if b c d)))
+ (if if a then b else c then e (when (if a b c) e)) (if not a and not b then c (when (and (not a) (not b)) c)) (if not a then not b else not c and d (if (not a) (not b) (and (not c) d)))
+ (not a and not b (and (not a) (not b))) (not a or not b (or (not a) (not b))) (not a$<$b and not b$<$c (and (not ($<$ a b)) (not ($<$ b c)))) (not a$<$b (not ($<$ a b))) (a[i,k]*b[j,k] (* (aref a i k) (aref b j k)))
+ (foo(bar)=foo[bar,baz] (setf (foo bar) (aref foo bar baz))) (foo(bar,baz) (foo bar baz)) (foo[bar,baz] (aref foo bar baz)) (foo[bar,baz]=barf (setf (aref foo bar baz) barf))
+ (max = if a $<$ b then b else a (setq max (if ($<$ a b) b a))) (a $<$ b $<$ c ($<$ a b c)) (a $<$ b $<$= c (and ($<$ a b) ($<$= b c))) (a $<$= b $<$= c ($<$= a b c)) (a $<$= b $<$= c ($<$= a b c)) (a!=b and b$<$c (and (not (= a b)) ($<$ b c)))
+ (a!=b (not (= a b))) (a$<$b ($<$ a b)) (a==b (= a b)) (a*b(c)+d (+ (* a (b c)) d)) (a+b(c)*d (+ a (* (b c) d))) (a+b(c)+d (+ a (b c) d)) (d+a*b(c) (+ d (* a (b c)))) (+a+b (+ a b)) ($-$a+b (+ ($-$ a) b))
+ ($-$a$-$b (+ ($-$ a) ($-$ b))) ($-$a$-$b$-$c (+ ($-$ a) ($-$ b) ($-$ c))) (a*b/c (/ (* a b) c)) (a+b$-$c (+ a b ($-$ c))) (a$-$b$-$c ($-$ a b c)) (a/b*c (* (/ a b) c)) (a/b/c (/ a b c)) (/a/b (/ (* a b))) (a\symbol{94}b\symbol{94}c (expt a (expt b c)))
+ (a(d)\symbol{94}b\symbol{94}c (expt (a d) (expt b c))) (a$<$b+c$<$d ($<$ a (+ b c) d)) (1*~2+3 (+ (* 1 (lognot 2)) 3)) (1+~2*3 (+ 1 (* (lognot 2) 3))) (1+~2+3 (+ 1 (lognot 2) 3)) (f(a)*=g(b) (setf (f a) (* (f a) (g b))))
+ (f(a)+=g(b) (incf (f a) (g b))) (f(a)$-$=g(b) (decf (f a) (g b))) (f(a)/=g(b) (setf (f a) (/ (f a) (g b)))) (a\&b (logand a b)) (a\symbol{94}\symbol{94}b (logxor a b)) (a|b (logior a b)) (a$<$$<$b (ash a b)) (a$>$$>$b (ash a ($-$ b)))
+ (~a (lognot a)) (a\&\&b (and a b)) (a||b (or a b)) (a\%b (mod a b))
+ (x\symbol{94}2   ; the x coordinate
+        + y\symbol{94}2 ; the y coordinate error)
+ (x\symbol{94}2   ; the x coordinate
+        + y\symbol{94}2 ; the y coordinate
+         (+ (expt x 2) (expt y 2)))
+ (foo(bar,baz error) (foo(bar,baz)) (foo bar baz)) (foo[bar,baz]] error) ([foo,bar] error) (and a error) ($<$ a error) (=bar error) (*bar error) (a not b error) (a if b then c error) ( error) ()a error) (]a error)) }
+{\ } % NO DOCUMENTATION FOR *TEST-CASES*
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{test$-$infix}{FUNCTION}{{\sf \&optional} (tests *test$-$cases*) }
+{\ } % NO DOCUMENTATION FOR TEST-INFIX
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{test$-$infix$-$case}{FUNCTION}{string result }
+{\ } % NO DOCUMENTATION FOR TEST-INFIX-CASE
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/makelist.tex
===================================================================
--- /trunk/latex-doc/makelist.tex	(revision 8)
+++ /trunk/latex-doc/makelist.tex	(revision 8)
@@ -0,0 +1,40 @@
+\begin{lisp:documentation}{makelist$-$1}{MACRO}{expr var lo hi {\sf \&optional} (step 1) }
+{\ } % NO DOCUMENTATION FOR MAKELIST-1
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{makelist}{MACRO}{expr (var lo hi {\sf \&optional} (step 1)) {\sf \&rest} more }
+{\ } % NO DOCUMENTATION FOR MAKELIST
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{sum}{MACRO}{{\sf \&body} body }
+{\ } % NO DOCUMENTATION FOR SUM
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{list$-$of}{MACRO}{expr (var lst) {\sf \&rest} more }
+{\ } % NO DOCUMENTATION FOR LIST-OF
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{list$-$of$-$1}{MACRO}{expr var lst }
+{\ } % NO DOCUMENTATION FOR LIST-OF-1
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{union$-$of}{MACRO}{expr (var lst) {\sf \&rest} more }
+{\ } % NO DOCUMENTATION FOR UNION-OF
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{union$-$of$-$1}{MACRO}{expr var lst }
+{\ } % NO DOCUMENTATION FOR UNION-OF-1
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{set$-$of}{MACRO}{expr (var lst) {\sf \&rest} more }
+{\ } % NO DOCUMENTATION FOR SET-OF
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{set$-$of$-$1}{MACRO}{expr var lst }
+{\ } % NO DOCUMENTATION FOR SET-OF-1
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{select}{FUNCTION}{ind lst }
+{\ } % NO DOCUMENTATION FOR SELECT
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/man.log
===================================================================
--- /trunk/latex-doc/man.log	(revision 8)
+++ /trunk/latex-doc/man.log	(revision 8)
@@ -0,0 +1,27 @@
+This is TeX, Version 3.14159 (C version 6.1) (format=latex 97.4.20)  30 NOV 1997 12:26
+**man.sty
+(man.sty
+LaTeX2e <1996/12/01> patch level 1
+Babel <v3.6h> and hyphenation patterns for american, german, loaded.
+Preloading the manual format for the CGB package)
+*\end
+
+*\end
+! TeX capacity exceeded, sorry [parameter stack size=60].
+\end #1->
+         \csname end#1\endcsname \@checkend {#1}\expandafter \endgroup \if@e...
+<*> \end
+        
+If you really absolutely need more capacity,
+you can ask a wizard to enlarge me.
+
+ 
+Here is how much of TeX's memory you used:
+ 4 strings out of 10906
+ 21 string characters out of 72187
+ 43261 words of memory out of 262141
+ 2979 multiletter control sequences out of 9500
+ 3640 words of font info for 14 fonts, out of 150000 for 255
+ 14 hyphenation exceptions out of 607
+ 60i,0n,61p,68b,7s stack positions out of 300i,40n,60p,3000b,4000s
+No pages of output.
Index: /trunk/latex-doc/man.sty
===================================================================
--- /trunk/latex-doc/man.sty	(revision 8)
+++ /trunk/latex-doc/man.sty	(revision 8)
@@ -0,0 +1,3 @@
+\message{Preloading the manual format for the CGB package}
+%\chardef'\<=\<
+%\chardef'\$=\$
Index: /trunk/latex-doc/manual.aux
===================================================================
--- /trunk/latex-doc/manual.aux	(revision 8)
+++ /trunk/latex-doc/manual.aux	(revision 8)
@@ -0,0 +1,359 @@
+\relax 
+\@writefile{toc}{\contentsline {section}{\numberline {1}The Gr\"obner Basis package}{1}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  *grobner$-$debug*}}{1}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  *buchberger$-$merge$-$pairs*}}{1}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  *gebauer$-$moeller$-$merge$-$pairs*}}{1}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  *grobner$-$function*}}{1}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  select$-$grobner$-$algorithm}}{2}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  grobner}}{2}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  debug$-$cgb}}{2}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  spoly}}{2}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  grobner$-$primitive$-$part}}{2}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  grobner$-$content}}{2}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  normal$-$form}}{2}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  buchberger}}{3}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  grobner$-$op}}{3}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  buchberger$-$sort$-$pairs}}{3}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  mock$-$spoly}}{3}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  buchberger$-$merge$-$pairs$-$use$-$mock$-$spoly}}{3}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  buchberger$-$merge$-$pairs$-$smallest$-$lcm}}{3}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  buchberger$-$merge$-$pairs$-$use$-$smallest$-$degree}}{3}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  buchberger$-$merge$-$pairs$-$use$-$smallest$-$length}}{3}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  buchberger$-$merge$-$pairs$-$use$-$smallest$-$coefficient$-$length}}{3}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  buchberger$-$set$-$pair$-$heuristic}}{4}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  criterion$-$1}}{4}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  criterion$-$2}}{4}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  normalize$-$poly}}{4}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  normalize$-$basis}}{4}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  reduction}}{4}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  reduced$-$grobner}}{4}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$depends$-$p}}{4}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  term$-$depends$-$p}}{4}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$depends$-$p}}{5}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ring$-$intersection}}{5}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  elimination$-$ideal}}{5}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ideal$-$intersection}}{5}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$contract}}{5}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$lcm}}{5}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  grobner$-$gcd}}{5}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  grobner$-$equal}}{5}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  grobner$-$subsetp}}{6}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  grobner$-$member}}{6}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ideal$-$equal}}{6}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ideal$-$subsetp}}{6}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ideal$-$member}}{6}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ideal$-$saturation$-$1}}{6}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  add$-$variables}}{6}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  extend$-$polynomials}}{6}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  saturation$-$extension}}{6}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  polysaturation$-$extension}}{7}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  saturation$-$extension$-$1}}{7}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ideal$-$polysaturation$-$1}}{7}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ideal$-$saturation}}{7}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ideal$-$polysaturation}}{7}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  buchberger$-$criterion}}{7}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  grobner$-$test}}{7}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  minimization}}{7}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  add$-$minimized}}{7}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colon$-$ideal}}{8}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colon$-$ideal$-$1}}{8}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  pseudo$-$divide}}{8}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  gebauer$-$moeller}}{8}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  update}}{8}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  gebauer$-$moeller$-$merge$-$pairs$-$use$-$mock$-$spoly}}{8}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  gebauer$-$moeller$-$merge$-$pairs$-$smallest$-$lcm}}{8}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$degree}}{8}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$length}}{8}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$coefficient$-$length}}{8}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  gebauer$-$moeller$-$set$-$pair$-$heuristic}}{9}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  spoly$-$sugar}}{9}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  spoly$-$with$-$sugar}}{9}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  normal$-$form$-$with$-$sugar}}{9}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  buchberger$-$with$-$sugar}}{9}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  buchberger$-$with$-$sugar$-$merge$-$pairs}}{9}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  buchberger$-$with$-$sugar$-$sort$-$pairs}}{9}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  criterion$-$1$-$with$-$sugar}}{9}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  criterion$-$2$-$with$-$sugar}}{10}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  gebauer$-$moeller$-$with$-$sugar}}{10}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  update$-$with$-$sugar}}{10}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  gebauer$-$moeller$-$with$-$sugar$-$merge$-$pairs}}{10}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  grobner$-$primitive$-$part$-$with$-$sugar}}{10}}
+\@writefile{toc}{\contentsline {section}{\numberline {2}The String Interface to the Gr\"obner Basis package}{10}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$normal$-$form}}{10}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$grobner}}{10}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$elimination$-$ideal}}{10}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$ideal$-$intersection}}{10}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$poly$-$lcm}}{11}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$ideal$-$saturation$-$1}}{11}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$ideal$-$polysaturation$-$1}}{11}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$ideal$-$saturation}}{11}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$ideal$-$polysaturation}}{11}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$colon$-$ideal}}{11}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$read$-$poly}}{11}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$rational$-$to$-$integer}}{11}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  read$-$vars}}{11}}
+\@writefile{toc}{\contentsline {section}{\numberline {3}The Comprehensive Gr\"obner basis package}{12}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  *colored$-$poly$-$debug*}}{12}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  debug$-$cgb}}{12}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  make$-$colored$-$poly}}{12}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  make$-$colored$-$poly$-$list}}{12}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  color$-$poly$-$list}}{12}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  color$-$poly}}{12}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colored$-$poly$-$to$-$poly}}{12}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colored$-$poly$-$print}}{12}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colored$-$poly$-$print$-$list}}{12}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  determine}}{13}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  determine$-$1}}{13}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  determine$-$white$-$term}}{13}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  cond$-$system$-$print}}{13}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  cond$-$print}}{13}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  add$-$pairs}}{13}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  cond$-$part}}{14}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  cond$-$hm}}{14}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  delete$-$green$-$polys}}{14}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  grobner$-$system}}{14}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  reorder$-$pairs}}{14}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colored$-$criterion$-$1}}{14}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colored$-$criterion$-$2}}{14}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  cond$-$normal$-$form}}{14}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  cond$-$spoly}}{14}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  cond$-$lm}}{15}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  cond$-$lc}}{15}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colored$-$term$-$times$-$poly}}{15}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colored$-$scalar$-$times$-$poly}}{15}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colored$-$term*}}{15}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  color*}}{15}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  color+}}{15}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  color$-$}}{15}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colored$-$poly+}}{15}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colored$-$poly$-$}}{15}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colored$-$term$-$uminus}}{15}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colored$-$minus$-$poly}}{15}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$grobner$-$system}}{16}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$cond}}{16}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$cover}}{16}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  saturate$-$cover}}{16}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  saturate$-$cond}}{16}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  string$-$determine}}{16}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  tidy$-$grobner$-$system}}{16}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  tidy$-$pair}}{16}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  tidy$-$cond}}{16}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  colored$-$reduction}}{17}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  green$-$reduce$-$colored$-$poly}}{17}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  green$-$reduce$-$colored$-$list}}{17}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  cond$-$system$-$green$-$reduce}}{17}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  parse$-$to$-$colored$-$poly$-$list}}{17}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  red$-$reduction}}{17}}
+\@writefile{toc}{\contentsline {section}{\numberline {4}The Coefficient Ring package}{17}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ring}}{17}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  *ring$-$of$-$integers*}}{17}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  *field$-$of$-$rationals*}}{18}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  field$-$modulo$-$prime}}{18}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  *coefficient$-$ring*}}{18}}
+\@writefile{toc}{\contentsline {section}{\numberline {5}The Division Package}{18}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  divide}}{18}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$exact$-$divide}}{18}}
+\@writefile{toc}{\contentsline {section}{\numberline {6}The Dynamical Systems package}{18}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$scalar$-$composition}}{18}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$composition}}{18}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$dynamic$-$power}}{18}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$scalar$-$evaluate}}{18}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$evaluate}}{19}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  factorial}}{19}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$scalar$-$diff}}{19}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$diff}}{19}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  standard$-$vector}}{19}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  scalar$-$partial}}{19}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  partial}}{19}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  determinant}}{19}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  minor}}{19}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  drop$-$row}}{19}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  drop$-$column}}{19}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  drop$-$elt}}{19}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  matrix$-$}}{19}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  scalar$-$times$-$matrix}}{20}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$times$-$matrix}}{20}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  term$-$times$-$matrix}}{20}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$list$-$}}{20}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  scalar$-$times$-$poly$-$list}}{20}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$times$-$poly$-$list}}{20}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  term$-$times$-$poly$-$list}}{20}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  characteristic$-$combination}}{20}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  characteristic$-$combination$-$poly$-$list}}{20}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  characteristic$-$matrix}}{20}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  characteristic$-$polynomial}}{20}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  identity$-$matrix}}{21}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  print$-$matrix}}{21}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  jacobi$-$matrix}}{21}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  jacobian}}{21}}
+\@writefile{toc}{\contentsline {section}{\numberline {7}The Geometric Theorem Prover package}{21}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  *prover$-$order*}}{21}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  csym}}{21}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  real$-$identical$-$points}}{21}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  identical$-$points}}{21}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  perpendicular}}{21}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  parallel}}{21}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  collinear}}{22}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  equidistant}}{22}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  euclidean$-$distance}}{22}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  midpoint}}{22}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  translate$-$statements}}{22}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  translate$-$assumptions}}{22}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  translate$-$conclusions}}{22}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  translate$-$theorem}}{22}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  prove$-$theorem}}{22}}
+\@writefile{toc}{\contentsline {section}{\numberline {8}The Monomial Order Package}{22}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  lex$>$}}{22}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  total$-$degree}}{23}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  grlex$>$}}{23}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  grevlex$>$}}{23}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  revlex$>$}}{23}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  invlex$>$}}{23}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  elimination$-$order}}{23}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  elimination$-$order$-$1}}{23}}
+\@writefile{toc}{\contentsline {section}{\numberline {9}The Polynomial Package}{23}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  scalar$-$times$-$poly}}{23}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  term$-$times$-$poly}}{23}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$times$-$poly}}{23}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  minus$-$poly}}{23}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  sort$-$poly}}{24}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly+}}{24}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$}}{24}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly*}}{24}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$op}}{24}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$expt}}{24}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$mexpt}}{24}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$constant$-$p}}{24}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$extend}}{24}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$extend$-$end}}{24}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$zerop}}{24}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  lt}}{25}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  lm}}{25}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  lc}}{25}}
+\@writefile{toc}{\contentsline {section}{\numberline {10}The Parser Package}{25}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  parse}}{25}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  alist$-$form}}{25}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  alist$-$form$-$1}}{25}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  powers}}{25}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  parse$-$to$-$alist}}{25}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  parse$-$string$-$to$-$alist}}{25}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  parse$-$to$-$sorted$-$alist}}{26}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  parse$-$string$-$to$-$sorted$-$alist}}{26}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  sort$-$poly$-$1}}{26}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  sort$-$poly}}{26}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$eval$-$1}}{26}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$eval}}{26}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$basis}}{26}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  convert$-$number}}{26}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  \$poly+}}{27}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  \$poly$-$}}{27}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  \$minus$-$poly}}{27}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  \$poly*}}{27}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  \$poly/}}{27}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  \$poly$-$expt}}{27}}
+\@writefile{toc}{\contentsline {section}{\numberline {11}Other packages}{27}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  makelist$-$1}}{27}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  makelist}}{27}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  sum}}{27}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  list$-$of}}{27}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  list$-$of$-$1}}{27}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  union$-$of}}{27}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  union$-$of$-$1}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  set$-$of}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  set$-$of$-$1}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  select}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom/}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom*}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  nmonom*}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$divides$-$p}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$divisible$-$by$-$p}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$rel$-$prime}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$equal}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$lcm}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$gcd}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$gcd}}{28}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$pseudo$-$divide}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$pseudo$-$remainder}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  mdeg}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  lcoeff}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  lrest}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  lpart}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$primitive$-$part}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$content}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$with$-$sugar$-$poly}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$with$-$sugar$-$sugar}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$with$-$sugar$-$tail}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  (setf poly$-$with$-$sugar$-$poly)}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  (setf poly$-$with$-$sugar$-$sugar)}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  (setf poly$-$with$-$sugar$-$tail)}}{29}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$sugar}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  coefficient$-$sugar}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  term$-$sugar}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$add$-$sugar}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  scalar$-$times$-$poly$-$with$-$sugar}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  term$-$times$-$poly$-$with$-$sugar}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$times$-$poly$-$with$-$sugar}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  minus$-$poly$-$with$-$sugar}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$with$-$sugar+}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$with$-$sugar$-$}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$with$-$sugar$-$op}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$with$-$sugar$-$nreverse}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$with$-$sugar$-$append}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$with$-$sugar$-$zerop}}{30}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$with$-$sugar$-$lm}}{31}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$with$-$sugar$-$lc}}{31}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$with$-$sugar$-$lt}}{31}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$print}}{31}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$print$-$1}}{31}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$print$-$2}}{31}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  print$-$term}}{31}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  print$-$monom}}{31}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  num}}{31}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  denom}}{31}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  rat$-$simplify$-$2}}{31}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  rat$-$simplify}}{31}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  rat+}}{31}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  rat$-$}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  rat*}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  rat/}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  scalar$-$times$-$rat}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  scalar$-$div$-$rat}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  rat$-$zerop}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  rat$-$uminus}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  rat$-$expt}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  rat$-$constant}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  rat$-$to$-$poly}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly+}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly$-$}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly$-$uminus}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly*}}{32}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  scalar$-$times$-$ratpoly}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  rat$-$times$-$ratpoly}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly$-$divide}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly$-$remainder}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly$-$gcd}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly$-$diff}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly$-$square$-$free}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly$-$normalize}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly$-$resultant}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  deg}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  lead}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly$-$discriminant}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly$-$print}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$to$-$ratpoly}}{33}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$to$-$poly1}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly1$-$to$-$ratpoly}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly$-$to$-$poly1}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly1$-$to$-$poly}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  ratpoly$-$to$-$poly}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  poly$-$resultant}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  term*}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  term/}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  monom$-$times$-$term}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  term$-$divides$-$p}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  term$-$monom}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  term$-$coefficient}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  (setf term$-$monom)}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  (setf term$-$coefficient)}}{34}}
+\@writefile{toc}{\contentsline {paragraph}{{\sf  xgcd}}{35}}
+\@writefile{toc}{\contentsline {section}{\numberline {A}All examples produced by the {\tt  all-examples} utility}{35}}
Index: /trunk/latex-doc/manual.log
===================================================================
--- /trunk/latex-doc/manual.log	(revision 8)
+++ /trunk/latex-doc/manual.log	(revision 8)
@@ -0,0 +1,526 @@
+This is TeX, Version 3.14159 (C version 6.1) (format=latex 97.4.20)  24 DEC 1997 19:18
+**manual.tex
+(manual.tex
+LaTeX2e <1996/12/01> patch level 1
+Babel <v3.6h> and hyphenation patterns for american, german, loaded.
+(/usr/lib/texmf/texmf/tex/latex/base/article.cls
+Document Class: article 1996/10/31 v1.3u Standard LaTeX document class
+(/usr/lib/texmf/texmf/tex/latex/base/size10.clo
+File: size10.clo 1996/10/31 v1.3u Standard LaTeX file (size option)
+)
+\c@part=\count79
+\c@section=\count80
+\c@subsection=\count81
+\c@subsubsection=\count82
+\c@paragraph=\count83
+\c@subparagraph=\count84
+\c@figure=\count85
+\c@table=\count86
+\abovecaptionskip=\skip41
+\belowcaptionskip=\skip42
+\bibindent=\dimen102
+)
+(/usr/lib/texmf/texmf/tex/latex/graphics/color.sty
+Package: color 1997/01/07 v1.0d Standard LaTeX Color (DPC)
+
+(/usr/lib/texmf/texmf/tex/latex/config/color.cfg)
+Package color Info: Driver file: dvips.def on input line 128.
+
+(/usr/lib/texmf/texmf/tex/latex/graphics/dvips.def
+File: dvips.def 1996/12/12 v3.0d Driver-dependant file (DPC,SPQR)
+)
+(/usr/lib/texmf/texmf/tex/latex/graphics/dvipsnam.def
+File: dvipsnam.def 1996/12/12 v3.0d Driver-dependant file (DPC,SPQR)
+))
+(/usr/lib/texmf/texmf/tex/latex/misc/fullpage.sty
+Style Option FULLPAGE Version 2 as of 15 Dec 1988
+) (man.sty Preloading the manual format for the CGB package)
+(../contrib/user_man/lisp-documentation.tex
+\formnamelen=\skip43
+\pboxargslen=\skip44
+\typelen=\skip45
+) (manual.aux)
+LaTeX Font Info:    Checking defaults for OML/cmm/m/it on input line 13.
+LaTeX Font Info:    ... okay on input line 13.
+LaTeX Font Info:    Checking defaults for T1/cmr/m/n on input line 13.
+LaTeX Font Info:    ... okay on input line 13.
+LaTeX Font Info:    Checking defaults for OT1/cmr/m/n on input line 13.
+LaTeX Font Info:    ... okay on input line 13.
+LaTeX Font Info:    Checking defaults for OMS/cmsy/m/n on input line 13.
+LaTeX Font Info:    ... okay on input line 13.
+LaTeX Font Info:    Checking defaults for OMX/cmex/m/n on input line 13.
+LaTeX Font Info:    ... okay on input line 13.
+LaTeX Font Info:    Checking defaults for U/cmr/m/n on input line 13.
+LaTeX Font Info:    ... okay on input line 13.
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <12> on input line 14.
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <8> on input line 14.
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <6> on input line 14.
+ (manual.toc)
+\tf@toc=\write3
+
+(grobner.tex
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <7> on input line 1.
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <5> on input line 1.
+ [1
+
+]
+Underfull \hbox (badness 10000) in paragraph at lines 25--25
+[]\OT1/cmr/m/it/10 f \OT1/cmss/m/n/10 &op-tional \OT1/cmr/m/it/10 (pred #'lex$\
+OML/cmm/m/it/10 >$\OT1/cmr/m/it/10 ) (start 0) (top$\OMS/cmsy/m/n/10 ^^@$\OT1/c
+mr/m/it/10 reduction$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 only nil) (ring
+ []
+
+[2]
+Overfull \hbox (44.88268pt too wide) in paragraph at lines 95--101
+[]\OT1/cmr/m/n/10 Perform a cal-cu-la-tion equiv-a-lent to (POLY$\OMS/cmsy/m/n/
+10 ^^@$ \OT1/cmr/m/n/10 (SCALAR$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 TIMES$\OMS
+/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 POLY C2 A) (SCALAR$\OMS/cmsy/m/n/10 ^^@$\OT1/c
+mr/m/n/10 TIMES$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 POLY
+ []
+
+
+Overfull \hbox (36.6243pt too wide) in paragraph at lines 104--110
+\OT1/cmr/m/n/10 or-der. The RING struc-ture holds op-er-a-tions on the co-ef-fi
+-cients as de-scribed in the COEFFICIENT$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 R
+ING
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 157--157
+[]\OT1/cmr/m/it/10 method \OT1/cmss/m/n/10 &aux \OT1/cmr/m/it/10 (strategy$\OMS
+/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 fn (ecase
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 157--157
+\OT1/cmr/m/it/10 method (:minimal$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 mock$\O
+MS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 spoly
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 157--157
+\OT1/cmr/m/it/10 #'buchberger$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 merge$\OMS/
+cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 pairs$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 us
+e$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 mock$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it
+/10 spoly)
+ []
+
+
+Overfull \hbox (4.30997pt too wide) in paragraph at lines 157--157
+\OT1/cmr/m/it/10 (:minimal$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 lcm #'buchberg
+er$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 merge$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/
+it/10 pairs$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 smallest$\OMS/cmsy/m/n/10 ^^@
+$\OT1/cmr/m/it/10 lcm)
+ []
+
+
+Overfull \hbox (75.06502pt too wide) in paragraph at lines 157--157
+\OT1/cmr/m/it/10 (:minimal$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 total$\OMS/cms
+y/m/n/10 ^^@$\OT1/cmr/m/it/10 degree #'buchberger$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr
+/m/it/10 merge$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 pairs$\OMS/cmsy/m/n/10 ^^@
+$\OT1/cmr/m/it/10 use$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 smallest$\OMS/cmsy/
+m/n/10 ^^@$\OT1/cmr/m/it/10 degree)
+ []
+
+
+Overfull \hbox (47.09862pt too wide) in paragraph at lines 157--157
+\OT1/cmr/m/it/10 (:minimal$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 length #'buchb
+erger$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 merge$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr
+/m/it/10 pairs$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 use$\OMS/cmsy/m/n/10 ^^@$\
+OT1/cmr/m/it/10 smallest$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 length)
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 157--157
+\OT1/cmr/m/it/10 (:minimal$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 coefficient$\O
+MS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 length
+ []
+
+
+Overfull \hbox (27.2931pt too wide) in paragraph at lines 157--157
+\OT1/cmr/m/it/10 #'buchberger$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 merge$\OMS/
+cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 pairs$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 us
+e$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 smallest$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/
+m/it/10 coefficient$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 length))) 
+ []
+
+[3]
+Overfull \hbox (5.681pt too wide) in paragraph at lines 158--162
+\OT1/cmr/m/n/10 im-ple-ment-ing one of sev-eral strate-gies in-tro-duces be-for
+e of se-lect-ing the most promis-ing. METHOD
+ []
+
+[4]
+Underfull \hbox (badness 4556) in paragraph at lines 229--229
+[]\OT1/cmr/m/it/10 flist k \OT1/cmss/m/n/10 &key \OT1/cmr/m/it/10 (primary$\OMS
+/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 order #'lex$\OML/cmm/m/it/10 >$\OT1/cmr/m/it/
+10 ) (secondary$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 order #'lex$\OML/cmm/m/it
+/10 >$\OT1/cmr/m/it/10 )
+ []
+
+[5]
+Underfull \hbox (badness 10000) in paragraph at lines 312--312
+[]\OT1/cmr/m/it/10 f p pred start top$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 red
+uction$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 only ring \OT1/cmss/m/n/10 &aux \O
+T1/cmr/m/it/10 (pred
+ []
+
+LaTeX Font Info:    Try loading font information for OMS+cmr on input line 329.
+
+(/usr/lib/texmf/texmf/tex/latex/base/omscmr.fd
+File: omscmr.fd 1997/01/14 v2.5a Standard LaTeX font definitions
+)
+LaTeX Font Info:    Font shape `OMS/cmr/m/n' in size <10> not available
+(Font)              Font shape `OMS/cmsy/m/n' tried instead on input line 329.
+ [6]
+Underfull \hbox (badness 1147) in paragraph at lines 377--377
+[]\OT1/cmr/m/it/10 f g pred start top$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 red
+uction$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 only ring \OT1/cmss/m/n/10 &aux \O
+T1/cmr/m/it/10 (k (length g)) (pred
+ []
+
+
+Overfull \hbox (62.62083pt too wide) in paragraph at lines 389--392
+[]\OT1/cmr/m/n/10 Returns the re-duced Grob-ner ba-sis of the ideal ob-tained b
+y a suc-ces-sive ap-pli-ca-tions of IDEAL$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 
+SATURATIONS
+ []
+
+[7]
+Underfull \hbox (badness 10000) in paragraph at lines 487--487
+[]\OT1/cmr/m/it/10 method \OT1/cmss/m/n/10 &aux \OT1/cmr/m/it/10 (strategy$\OMS
+/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 fn (ecase
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 487--487
+\OT1/cmr/m/it/10 method (:minimal$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 mock$\O
+MS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 spoly
+ []
+
+
+Overfull \hbox (1.49353pt too wide) in paragraph at lines 487--487
+\OT1/cmr/m/it/10 #'gebauer$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 moeller$\OMS/c
+msy/m/n/10 ^^@$\OT1/cmr/m/it/10 merge$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 pai
+rs$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 use$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it
+/10 mock$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 spoly)
+ []
+
+
+Overfull \hbox (55.4155pt too wide) in paragraph at lines 487--487
+\OT1/cmr/m/it/10 (:minimal$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 lcm #'gebauer$
+\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 moeller$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/i
+t/10 merge$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 pairs$\OMS/cmsy/m/n/10 ^^@$\OT
+1/cmr/m/it/10 smallest$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 lcm)
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 487--487
+\OT1/cmr/m/it/10 (:minimal$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 total$\OMS/cms
+y/m/n/10 ^^@$\OT1/cmr/m/it/10 degree
+ []
+
+
+Overfull \hbox (19.51003pt too wide) in paragraph at lines 487--487
+\OT1/cmr/m/it/10 #'gebauer$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 moeller$\OMS/c
+msy/m/n/10 ^^@$\OT1/cmr/m/it/10 merge$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 pai
+rs$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 use$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it
+/10 smallest$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 degree)
+ []
+
+
+Overfull \hbox (98.20415pt too wide) in paragraph at lines 487--487
+\OT1/cmr/m/it/10 (:minimal$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 length #'gebau
+er$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 moeller$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/
+m/it/10 merge$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 pairs$\OMS/cmsy/m/n/10 ^^@$
+\OT1/cmr/m/it/10 use$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 smallest$\OMS/cmsy/m
+/n/10 ^^@$\OT1/cmr/m/it/10 length)
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 487--487
+\OT1/cmr/m/it/10 (:minimal$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 coefficient$\O
+MS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 length
+ []
+
+
+Overfull \hbox (78.39864pt too wide) in paragraph at lines 487--487
+\OT1/cmr/m/it/10 #'gebauer$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 moeller$\OMS/c
+msy/m/n/10 ^^@$\OT1/cmr/m/it/10 merge$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 pai
+rs$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 use$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it
+/10 smallest$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 coefficient$\OMS/cmsy/m/n/10
+ ^^@$\OT1/cmr/m/it/10 length))) 
+ []
+
+[8] [9]) (string-grobner.tex
+Underfull \hbox (badness 10000) in paragraph at lines 4--4
+[]\OT1/cmr/m/it/10 f fl vars \OT1/cmss/m/n/10 &key \OT1/cmr/m/it/10 (stream t) 
+(print t) (or-der #'lex$\OML/cmm/m/it/10 >$\OT1/cmr/m/it/10 )
+ []
+
+
+Underfull \hbox (badness 4805) in paragraph at lines 12--12
+[]\OT1/cmr/m/it/10 plist vars \OT1/cmss/m/n/10 &key \OT1/cmr/m/it/10 (or-der #'
+lex$\OML/cmm/m/it/10 >$\OT1/cmr/m/it/10 ) (start 0) (stream t) (re-duce t)
+ []
+
+
+Underfull \hbox (badness 1701) in paragraph at lines 12--12
+\OT1/cmr/m/it/10 (reduce$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 before t) (suppr
+ess$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 value t) (top$\OMS/cmsy/m/n/10 ^^@$\O
+T1/cmr/m/it/10 reduction$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 only nil) (ring
+ []
+
+
+Underfull \hbox (badness 2582) in paragraph at lines 25--25
+\OT1/cmr/m/it/10 (or-der (elimination$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 ord
+er k :primary$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 order primary$\OMS/cmsy/m/n
+/10 ^^@$\OT1/cmr/m/it/10 order
+ []
+
+
+Underfull \hbox (badness 2556) in paragraph at lines 25--25
+\OT1/cmr/m/it/10 :secondary$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 order seconda
+ry$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 order)) \OT1/cmss/m/n/10 &aux \OT1/cmr
+/m/it/10 (vars (read$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 vars
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 52--52
+[]\OT1/cmr/m/it/10 f g vars \OT1/cmss/m/n/10 &key \OT1/cmr/m/it/10 (or-der #'le
+x$\OML/cmm/m/it/10 >$\OT1/cmr/m/it/10 ) (ring *coefficient$\OMS/cmsy/m/n/10 ^^@
+$\OT1/cmr/m/it/10 ring*)
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 52--52
+\OT1/cmr/m/it/10 (stream t) (suppress$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 val
+ue t) \OT1/cmss/m/n/10 &aux \OT1/cmr/m/it/10 (vars (read$\OMS/cmsy/m/n/10 ^^@$\
+OT1/cmr/m/it/10 vars
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 52--52
+\OT1/cmr/m/it/10 vars)) (f (parse$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 string$
+\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 to$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 
+sorted$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 alist f vars or-der)) (g
+ []
+
+[10]
+Underfull \hbox (badness 10000) in paragraph at lines 84--84
+[]\OT1/cmr/m/it/10 f plist vars \OT1/cmss/m/n/10 &key \OT1/cmr/m/it/10 (or-der 
+#'lex$\OML/cmm/m/it/10 >$\OT1/cmr/m/it/10 ) (start 0)
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 84--84
+\OT1/cmr/m/it/10 (top$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 reduction$\OMS/cmsy
+/m/n/10 ^^@$\OT1/cmr/m/it/10 only nil) (ring *coefficient$\OMS/cmsy/m/n/10 ^^@$
+\OT1/cmr/m/it/10 ring*)
+ []
+
+
+Underfull \hbox (badness 1728) in paragraph at lines 84--84
+\OT1/cmr/m/it/10 (stream t) (suppress$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 val
+ue t) \OT1/cmss/m/n/10 &aux \OT1/cmr/m/it/10 (vars (read$\OMS/cmsy/m/n/10 ^^@$\
+OT1/cmr/m/it/10 vars
+ []
+
+
+Underfull \hbox (badness 1014) in paragraph at lines 84--84
+\OT1/cmr/m/it/10 vars)) (f (parse$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 string$
+\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 to$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 
+sorted$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 alist f vars or-der))
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 115--115
+[]\OT1/cmr/m/it/10 f ideal$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 list vars \OT1
+/cmss/m/n/10 &key \OT1/cmr/m/it/10 (or-der #'lex$\OML/cmm/m/it/10 >$\OT1/cmr/m/
+it/10 ) (start 0)
+ []
+
+
+Underfull \hbox (badness 2707) in paragraph at lines 115--115
+\OT1/cmr/m/it/10 t) (suppress$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 value t) \O
+T1/cmss/m/n/10 &aux \OT1/cmr/m/it/10 (vars (read$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/
+m/it/10 vars vars)) (f
+ []
+
+
+Underfull \hbox (badness 4291) in paragraph at lines 115--115
+\OT1/cmr/m/it/10 (parse$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 string$\OMS/cmsy/
+m/n/10 ^^@$\OT1/cmr/m/it/10 to$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 sorted$\OM
+S/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 alist f vars or-der)) (ideal$\OMS/cmsy/m/n/1
+0 ^^@$\OT1/cmr/m/it/10 list
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 129--129
+\OT1/cmr/m/it/10 (stream t) (or-der #'lex$\OML/cmm/m/it/10 >$\OT1/cmr/m/it/10 )
+ (suppress$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 value t) \OT1/cmss/m/n/10 &aux
+ \OT1/cmr/m/it/10 (vars
+ []
+
+
+Underfull \hbox (badness 7944) in paragraph at lines 138--138
+[]\OT1/cmr/m/it/10 f vars \OT1/cmss/m/n/10 &key \OT1/cmr/m/it/10 (or-der #'lex$
+\OML/cmm/m/it/10 >$\OT1/cmr/m/it/10 ) (suppress$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m
+/it/10 value nil) (stream t)
+ []
+
+
+Underfull \hbox (badness 2285) in paragraph at lines 138--138
+\OT1/cmr/m/it/10 (convert$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 rational$\OMS/c
+msy/m/n/10 ^^@$\OT1/cmr/m/it/10 to$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 intege
+r t) \OT1/cmss/m/n/10 &aux \OT1/cmr/m/it/10 (vars (read$\OMS/cmsy/m/n/10 ^^@$\O
+T1/cmr/m/it/10 vars vars)) (f
+ []
+
+) (colored-poly.tex [11]
+Overfull \hbox (54.0505pt too wide) in paragraph at lines 23--26
+[]\OT1/cmr/m/n/10 Translate a list of poly-no-mi-als PLIST into a list of col-o
+red poly-no-mi-als by call-ing MAKE$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 COLORE
+D$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 POLY.
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 48--48
+[]\OT1/cmr/m/it/10 poly vars \OT1/cmss/m/n/10 &key \OT1/cmr/m/it/10 (stream t) 
+(beg t) (print$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 green$\OMS/cmsy/m/n/10 ^^@
+$\OT1/cmr/m/it/10 part nil)
+ []
+
+[12] [13] [14]
+Underfull \hbox (badness 3333) in paragraph at lines 278--278
+\OT1/cmr/m/it/10 #'lex$\OML/cmm/m/it/10 >$\OT1/cmr/m/it/10 ) (parameter$\OMS/cm
+sy/m/n/10 ^^@$\OT1/cmr/m/it/10 order #'lex$\OML/cmm/m/it/10 >$\OT1/cmr/m/it/10 
+) (ring *coefficient$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 ring*)
+ []
+
+[15]
+Overfull \hbox (10.81523pt too wide) in paragraph at lines 285--291
+[]\OT1/cmr/m/n/10 Return the in-ter-nal rep-re-sen-ta-tion of a con-di-tion CON
+D, spec-i-fied as pairs of strings (GREEN$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 
+LIST
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 324--324
+[]\OT1/cmr/m/it/10 f vars params \OT1/cmss/m/n/10 &key \OT1/cmr/m/it/10 (cond '
+([] [])) (main$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 order #'lex$\OML/cmm/m/it/
+10 >$\OT1/cmr/m/it/10 )
+ []
+
+
+Underfull \hbox (badness 7168) in paragraph at lines 324--324
+\OT1/cmr/m/it/10 (parameter$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 order #'lex$\
+OML/cmm/m/it/10 >$\OT1/cmr/m/it/10 ) (suppress$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/
+it/10 value t) (suppress$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 printing
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 324--324
+\OT1/cmr/m/it/10 nil) (mark$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 coefficients 
+nil) (ring *coefficient$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 ring*) \OT1/cmss/
+m/n/10 &aux
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 324--324
+\OT1/cmr/m/it/10 (f (parse$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 to$\OMS/cmsy/m
+/n/10 ^^@$\OT1/cmr/m/it/10 colored$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 poly$\
+OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 list f vars params main$\OMS/cmsy/m/n/10 ^
+^@$\OT1/cmr/m/it/10 order
+ []
+
+[16]) (coefficient-ring.tex [17]) (division.tex) (dynamics.tex
+Overfull \hbox (73.32835pt too wide) in paragraph at lines 22--24
+[]\OT1/cmr/m/n/10 Evaluate a poly-no-mial F at a point X. This op-er-a-tion is 
+im-ple-mented through POLY$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 SCALAR$\OMS/cms
+y/m/n/10 ^^@$\OT1/cmr/m/n/10 COMPOSITION. 
+ []
+
+[18] [19] [20]) (prover.tex [21]
+Overfull \hbox (20.69022pt too wide) in paragraph at lines 96--100
+[]\OT1/cmr/m/n/10 Proves a ge-o-met-ric the-o-rem, spec-i-fied in the same man-
+ner as in the macro TRANSLATE$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 THEOREM.
+ []
+
+) (order.tex [22]) (poly.tex [23]
+Overfull \hbox (5.36993pt too wide) in paragraph at lines 66--70
+[]\OT1/cmr/m/n/10 Given a poly-no-mial P in k[x[r+1],...,xn], it re-turns the s
+ame poly-no-mial as an el-e-ment of k[x1,...,xn],
+ []
+
+[24]) (parse.tex
+Overfull \hbox (27.25775pt too wide) in paragraph at lines 38--46
+\OT1/cmr/m/n/10 ple: (WITH$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 INPUT$\OMS/cmsy
+/m/n/10 ^^@$\OT1/cmr/m/n/10 FROM$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 STRING (S
+ "X^2$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 Y^2+($\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/
+m/n/10 4/3)*U^2*W^3$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 5") (PARSE$\OMS/cmsy/m
+/n/10 ^^@$\OT1/cmr/m/n/10 TO$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 ALIST
+ []
+
+
+Overfull \hbox (57.11893pt too wide) in paragraph at lines 61--73
+\OT1/cmr/m/n/10 (WITH$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 INPUT$\OMS/cmsy/m/n/
+10 ^^@$\OT1/cmr/m/n/10 FROM$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 STRING (S "X^2
+$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 Y^2+($\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/1
+0 4/3)*U^2*W^3$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 5") (PARSE$\OMS/cmsy/m/n/10
+ ^^@$\OT1/cmr/m/n/10 TO$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 SORTED$\OMS/cmsy/m
+/n/10 ^^@$\OT1/cmr/m/n/10 ALIST
+ []
+
+
+Overfull \hbox (57.11893pt too wide) in paragraph at lines 61--73
+\OT1/cmr/m/n/10 (WITH$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 INPUT$\OMS/cmsy/m/n/
+10 ^^@$\OT1/cmr/m/n/10 FROM$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 STRING (S "X^2
+$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 Y^2+($\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/1
+0 4/3)*U^2*W^3$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 5") (PARSE$\OMS/cmsy/m/n/10
+ ^^@$\OT1/cmr/m/n/10 TO$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/n/10 SORTED$\OMS/cmsy/m
+/n/10 ^^@$\OT1/cmr/m/n/10 ALIST
+ []
+
+[25] [26]) (makelist.tex [27]) (monom.tex) (poly-gcd.tex [28])
+(poly-with-sugar.tex [29] [30]) (printer.tex) (rat.tex [31]) (ratpoly.tex
+[32] [33]) (term.tex) (xgcd.tex) (examples.tex [34] [35]
+Overfull \hbox (21.6393pt too wide) in paragraph at lines 179--179
+[]\OT1/cmtt/m/n/9 [ RETURN VALUE 1]-->> ((((((2 0) . 1) ((0 1) . -1))) ((((1 0)
+ . 1)))) (((((1 0) . 1) ((0 1) . 1))) NIL))[] 
+ []
+
+[36]
+Overfull \hbox (7.46446pt too wide) in paragraph at lines 179--179
+[]\OT1/cmtt/m/n/9 [ RETURN VALUE 1]-->> ((((+ (- (* B1 C2) (* B2 C1)) (- (* A2 
+C1) (* A1 C2)) (- (* A1 B2) (* A2 B1))))[] 
+ []
+
+
+Overfull \hbox (2.73952pt too wide) in paragraph at lines 179--179
+[]\OT1/cmtt/m/n/9 [ RETURN VALUE 2]-->> ((((- (* (- A1 B1) (- E2 F2)) (* (- A2 
+B2) (- E1 F1)))) ((- C1 D1) (- C2 D2)))[] 
+ []
+
+
+Overfull \hbox (59.43886pt too wide) in paragraph at lines 179--179
+[]\OT1/cmtt/m/n/9 ;; (PROVE-THEOREM ((PERPENDICULAR A B C D) (PERPENDICULAR C D
+ E F)) ((PARALLEL A B E F) (IDENTICAL-POINTS C D)))[] 
+ []
+
+[37]) [38] (manual.aux) ) 
+Here is how much of TeX's memory you used:
+ 640 strings out of 10906
+ 7319 string characters out of 72187
+ 53901 words of memory out of 262141
+ 3472 multiletter control sequences out of 9500
+ 9042 words of font info for 33 fonts, out of 150000 for 255
+ 14 hyphenation exceptions out of 607
+ 23i,6n,19p,334b,362s stack positions out of 300i,40n,60p,3000b,4000s
+
+Output written on manual.dvi (38 pages, 128456 bytes).
Index: /trunk/latex-doc/manual.tex
===================================================================
--- /trunk/latex-doc/manual.tex	(revision 8)
+++ /trunk/latex-doc/manual.tex	(revision 8)
@@ -0,0 +1,66 @@
+%	$Id: manual.tex,v 1.13 1997/12/13 05:36:18 marek Exp $	
+% -*- Mode: latex -*-
+\documentclass{article}
+%
+\usepackage[dvips]{color}
+\usepackage{fullpage}
+\usepackage{man}
+%
+\input ../contrib/user_man/lisp-documentation
+\title{CGBLisp User Guide and Manual}
+\author{Marek Rychlik}
+\pagecolor{white}
+\begin{document}
+\maketitle
+\tableofcontents
+%----------------------------------------------------------------
+%\section{The CGB-Lisp package}
+%\input cgb-lisp.tex
+%----------------------------------------------------------------
+\section{The Gr\"obner Basis package}
+\input grobner.tex
+%----------------------------------------------------------------
+\section{The String Interface to the Gr\"obner Basis package}
+\input string-grobner.tex
+%----------------------------------------------------------------
+\section{The Comprehensive Gr\"obner basis package}
+\input colored-poly.tex
+%----------------------------------------------------------------
+\section{The Coefficient Ring package}
+%----------------------------------------------------------------
+\input coefficient-ring.tex
+%----------------------------------------------------------------
+\section{The Division Package}
+\input division.tex
+%----------------------------------------------------------------
+\section{The Dynamical Systems package}
+\input dynamics.tex
+%----------------------------------------------------------------
+\section{The Geometric Theorem Prover package}
+\input prover.tex
+%----------------------------------------------------------------
+\section{The Monomial Order Package}
+\input order.tex
+%----------------------------------------------------------------
+\section{The Polynomial Package}
+\input poly.tex
+%----------------------------------------------------------------
+\section{The Parser Package}
+\input parse.tex
+%----------------------------------------------------------------
+\section{Other packages}
+\input makelist.tex
+\input monom.tex
+\input poly-gcd.tex
+\input poly-with-sugar.tex
+\input printer.tex
+\input rat.tex
+\input ratpoly.tex
+\input term.tex
+\input xgcd.tex
+\appendix 
+\section{All examples produced by the {\tt all-examples} utility}
+\begin{small}
+\input examples.tex
+\end{small}
+\end{document}
Index: /trunk/latex-doc/manual.toc
===================================================================
--- /trunk/latex-doc/manual.toc	(revision 8)
+++ /trunk/latex-doc/manual.toc	(revision 8)
@@ -0,0 +1,358 @@
+\contentsline {section}{\numberline {1}The Gr\"obner Basis package}{1}
+\contentsline {paragraph}{{\sf *grobner$-$debug*}}{1}
+\contentsline {paragraph}{{\sf *buchberger$-$merge$-$pairs*}}{1}
+\contentsline {paragraph}{{\sf *gebauer$-$moeller$-$merge$-$pairs*}}{1}
+\contentsline {paragraph}{{\sf *grobner$-$function*}}{1}
+\contentsline {paragraph}{{\sf select$-$grobner$-$algorithm}}{2}
+\contentsline {paragraph}{{\sf grobner}}{2}
+\contentsline {paragraph}{{\sf debug$-$cgb}}{2}
+\contentsline {paragraph}{{\sf spoly}}{2}
+\contentsline {paragraph}{{\sf grobner$-$primitive$-$part}}{2}
+\contentsline {paragraph}{{\sf grobner$-$content}}{2}
+\contentsline {paragraph}{{\sf normal$-$form}}{2}
+\contentsline {paragraph}{{\sf buchberger}}{3}
+\contentsline {paragraph}{{\sf grobner$-$op}}{3}
+\contentsline {paragraph}{{\sf buchberger$-$sort$-$pairs}}{3}
+\contentsline {paragraph}{{\sf mock$-$spoly}}{3}
+\contentsline {paragraph}{{\sf buchberger$-$merge$-$pairs$-$use$-$mock$-$spoly}}{3}
+\contentsline {paragraph}{{\sf buchberger$-$merge$-$pairs$-$smallest$-$lcm}}{3}
+\contentsline {paragraph}{{\sf buchberger$-$merge$-$pairs$-$use$-$smallest$-$degree}}{3}
+\contentsline {paragraph}{{\sf buchberger$-$merge$-$pairs$-$use$-$smallest$-$length}}{3}
+\contentsline {paragraph}{{\sf buchberger$-$merge$-$pairs$-$use$-$smallest$-$coefficient$-$length}}{3}
+\contentsline {paragraph}{{\sf buchberger$-$set$-$pair$-$heuristic}}{4}
+\contentsline {paragraph}{{\sf criterion$-$1}}{4}
+\contentsline {paragraph}{{\sf criterion$-$2}}{4}
+\contentsline {paragraph}{{\sf normalize$-$poly}}{4}
+\contentsline {paragraph}{{\sf normalize$-$basis}}{4}
+\contentsline {paragraph}{{\sf reduction}}{4}
+\contentsline {paragraph}{{\sf reduced$-$grobner}}{4}
+\contentsline {paragraph}{{\sf monom$-$depends$-$p}}{4}
+\contentsline {paragraph}{{\sf term$-$depends$-$p}}{4}
+\contentsline {paragraph}{{\sf poly$-$depends$-$p}}{5}
+\contentsline {paragraph}{{\sf ring$-$intersection}}{5}
+\contentsline {paragraph}{{\sf elimination$-$ideal}}{5}
+\contentsline {paragraph}{{\sf ideal$-$intersection}}{5}
+\contentsline {paragraph}{{\sf poly$-$contract}}{5}
+\contentsline {paragraph}{{\sf poly$-$lcm}}{5}
+\contentsline {paragraph}{{\sf grobner$-$gcd}}{5}
+\contentsline {paragraph}{{\sf grobner$-$equal}}{5}
+\contentsline {paragraph}{{\sf grobner$-$subsetp}}{6}
+\contentsline {paragraph}{{\sf grobner$-$member}}{6}
+\contentsline {paragraph}{{\sf ideal$-$equal}}{6}
+\contentsline {paragraph}{{\sf ideal$-$subsetp}}{6}
+\contentsline {paragraph}{{\sf ideal$-$member}}{6}
+\contentsline {paragraph}{{\sf ideal$-$saturation$-$1}}{6}
+\contentsline {paragraph}{{\sf add$-$variables}}{6}
+\contentsline {paragraph}{{\sf extend$-$polynomials}}{6}
+\contentsline {paragraph}{{\sf saturation$-$extension}}{6}
+\contentsline {paragraph}{{\sf polysaturation$-$extension}}{7}
+\contentsline {paragraph}{{\sf saturation$-$extension$-$1}}{7}
+\contentsline {paragraph}{{\sf ideal$-$polysaturation$-$1}}{7}
+\contentsline {paragraph}{{\sf ideal$-$saturation}}{7}
+\contentsline {paragraph}{{\sf ideal$-$polysaturation}}{7}
+\contentsline {paragraph}{{\sf buchberger$-$criterion}}{7}
+\contentsline {paragraph}{{\sf grobner$-$test}}{7}
+\contentsline {paragraph}{{\sf minimization}}{7}
+\contentsline {paragraph}{{\sf add$-$minimized}}{7}
+\contentsline {paragraph}{{\sf colon$-$ideal}}{8}
+\contentsline {paragraph}{{\sf colon$-$ideal$-$1}}{8}
+\contentsline {paragraph}{{\sf pseudo$-$divide}}{8}
+\contentsline {paragraph}{{\sf gebauer$-$moeller}}{8}
+\contentsline {paragraph}{{\sf update}}{8}
+\contentsline {paragraph}{{\sf gebauer$-$moeller$-$merge$-$pairs$-$use$-$mock$-$spoly}}{8}
+\contentsline {paragraph}{{\sf gebauer$-$moeller$-$merge$-$pairs$-$smallest$-$lcm}}{8}
+\contentsline {paragraph}{{\sf gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$degree}}{8}
+\contentsline {paragraph}{{\sf gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$length}}{8}
+\contentsline {paragraph}{{\sf gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$coefficient$-$length}}{8}
+\contentsline {paragraph}{{\sf gebauer$-$moeller$-$set$-$pair$-$heuristic}}{9}
+\contentsline {paragraph}{{\sf spoly$-$sugar}}{9}
+\contentsline {paragraph}{{\sf spoly$-$with$-$sugar}}{9}
+\contentsline {paragraph}{{\sf normal$-$form$-$with$-$sugar}}{9}
+\contentsline {paragraph}{{\sf buchberger$-$with$-$sugar}}{9}
+\contentsline {paragraph}{{\sf buchberger$-$with$-$sugar$-$merge$-$pairs}}{9}
+\contentsline {paragraph}{{\sf buchberger$-$with$-$sugar$-$sort$-$pairs}}{9}
+\contentsline {paragraph}{{\sf criterion$-$1$-$with$-$sugar}}{9}
+\contentsline {paragraph}{{\sf criterion$-$2$-$with$-$sugar}}{10}
+\contentsline {paragraph}{{\sf gebauer$-$moeller$-$with$-$sugar}}{10}
+\contentsline {paragraph}{{\sf update$-$with$-$sugar}}{10}
+\contentsline {paragraph}{{\sf gebauer$-$moeller$-$with$-$sugar$-$merge$-$pairs}}{10}
+\contentsline {paragraph}{{\sf grobner$-$primitive$-$part$-$with$-$sugar}}{10}
+\contentsline {section}{\numberline {2}The String Interface to the Gr\"obner Basis package}{10}
+\contentsline {paragraph}{{\sf string$-$normal$-$form}}{10}
+\contentsline {paragraph}{{\sf string$-$grobner}}{10}
+\contentsline {paragraph}{{\sf string$-$elimination$-$ideal}}{10}
+\contentsline {paragraph}{{\sf string$-$ideal$-$intersection}}{10}
+\contentsline {paragraph}{{\sf string$-$poly$-$lcm}}{11}
+\contentsline {paragraph}{{\sf string$-$ideal$-$saturation$-$1}}{11}
+\contentsline {paragraph}{{\sf string$-$ideal$-$polysaturation$-$1}}{11}
+\contentsline {paragraph}{{\sf string$-$ideal$-$saturation}}{11}
+\contentsline {paragraph}{{\sf string$-$ideal$-$polysaturation}}{11}
+\contentsline {paragraph}{{\sf string$-$colon$-$ideal}}{11}
+\contentsline {paragraph}{{\sf string$-$read$-$poly}}{11}
+\contentsline {paragraph}{{\sf poly$-$rational$-$to$-$integer}}{11}
+\contentsline {paragraph}{{\sf read$-$vars}}{11}
+\contentsline {section}{\numberline {3}The Comprehensive Gr\"obner basis package}{12}
+\contentsline {paragraph}{{\sf *colored$-$poly$-$debug*}}{12}
+\contentsline {paragraph}{{\sf debug$-$cgb}}{12}
+\contentsline {paragraph}{{\sf make$-$colored$-$poly}}{12}
+\contentsline {paragraph}{{\sf make$-$colored$-$poly$-$list}}{12}
+\contentsline {paragraph}{{\sf color$-$poly$-$list}}{12}
+\contentsline {paragraph}{{\sf color$-$poly}}{12}
+\contentsline {paragraph}{{\sf colored$-$poly$-$to$-$poly}}{12}
+\contentsline {paragraph}{{\sf colored$-$poly$-$print}}{12}
+\contentsline {paragraph}{{\sf colored$-$poly$-$print$-$list}}{12}
+\contentsline {paragraph}{{\sf determine}}{13}
+\contentsline {paragraph}{{\sf determine$-$1}}{13}
+\contentsline {paragraph}{{\sf determine$-$white$-$term}}{13}
+\contentsline {paragraph}{{\sf cond$-$system$-$print}}{13}
+\contentsline {paragraph}{{\sf cond$-$print}}{13}
+\contentsline {paragraph}{{\sf add$-$pairs}}{13}
+\contentsline {paragraph}{{\sf cond$-$part}}{14}
+\contentsline {paragraph}{{\sf cond$-$hm}}{14}
+\contentsline {paragraph}{{\sf delete$-$green$-$polys}}{14}
+\contentsline {paragraph}{{\sf grobner$-$system}}{14}
+\contentsline {paragraph}{{\sf reorder$-$pairs}}{14}
+\contentsline {paragraph}{{\sf colored$-$criterion$-$1}}{14}
+\contentsline {paragraph}{{\sf colored$-$criterion$-$2}}{14}
+\contentsline {paragraph}{{\sf cond$-$normal$-$form}}{14}
+\contentsline {paragraph}{{\sf cond$-$spoly}}{14}
+\contentsline {paragraph}{{\sf cond$-$lm}}{15}
+\contentsline {paragraph}{{\sf cond$-$lc}}{15}
+\contentsline {paragraph}{{\sf colored$-$term$-$times$-$poly}}{15}
+\contentsline {paragraph}{{\sf colored$-$scalar$-$times$-$poly}}{15}
+\contentsline {paragraph}{{\sf colored$-$term*}}{15}
+\contentsline {paragraph}{{\sf color*}}{15}
+\contentsline {paragraph}{{\sf color+}}{15}
+\contentsline {paragraph}{{\sf color$-$}}{15}
+\contentsline {paragraph}{{\sf colored$-$poly+}}{15}
+\contentsline {paragraph}{{\sf colored$-$poly$-$}}{15}
+\contentsline {paragraph}{{\sf colored$-$term$-$uminus}}{15}
+\contentsline {paragraph}{{\sf colored$-$minus$-$poly}}{15}
+\contentsline {paragraph}{{\sf string$-$grobner$-$system}}{16}
+\contentsline {paragraph}{{\sf string$-$cond}}{16}
+\contentsline {paragraph}{{\sf string$-$cover}}{16}
+\contentsline {paragraph}{{\sf saturate$-$cover}}{16}
+\contentsline {paragraph}{{\sf saturate$-$cond}}{16}
+\contentsline {paragraph}{{\sf string$-$determine}}{16}
+\contentsline {paragraph}{{\sf tidy$-$grobner$-$system}}{16}
+\contentsline {paragraph}{{\sf tidy$-$pair}}{16}
+\contentsline {paragraph}{{\sf tidy$-$cond}}{16}
+\contentsline {paragraph}{{\sf colored$-$reduction}}{17}
+\contentsline {paragraph}{{\sf green$-$reduce$-$colored$-$poly}}{17}
+\contentsline {paragraph}{{\sf green$-$reduce$-$colored$-$list}}{17}
+\contentsline {paragraph}{{\sf cond$-$system$-$green$-$reduce}}{17}
+\contentsline {paragraph}{{\sf parse$-$to$-$colored$-$poly$-$list}}{17}
+\contentsline {paragraph}{{\sf red$-$reduction}}{17}
+\contentsline {section}{\numberline {4}The Coefficient Ring package}{17}
+\contentsline {paragraph}{{\sf ring}}{17}
+\contentsline {paragraph}{{\sf *ring$-$of$-$integers*}}{17}
+\contentsline {paragraph}{{\sf *field$-$of$-$rationals*}}{18}
+\contentsline {paragraph}{{\sf field$-$modulo$-$prime}}{18}
+\contentsline {paragraph}{{\sf *coefficient$-$ring*}}{18}
+\contentsline {section}{\numberline {5}The Division Package}{18}
+\contentsline {paragraph}{{\sf divide}}{18}
+\contentsline {paragraph}{{\sf poly$-$exact$-$divide}}{18}
+\contentsline {section}{\numberline {6}The Dynamical Systems package}{18}
+\contentsline {paragraph}{{\sf poly$-$scalar$-$composition}}{18}
+\contentsline {paragraph}{{\sf poly$-$composition}}{18}
+\contentsline {paragraph}{{\sf poly$-$dynamic$-$power}}{18}
+\contentsline {paragraph}{{\sf poly$-$scalar$-$evaluate}}{18}
+\contentsline {paragraph}{{\sf poly$-$evaluate}}{19}
+\contentsline {paragraph}{{\sf factorial}}{19}
+\contentsline {paragraph}{{\sf poly$-$scalar$-$diff}}{19}
+\contentsline {paragraph}{{\sf poly$-$diff}}{19}
+\contentsline {paragraph}{{\sf standard$-$vector}}{19}
+\contentsline {paragraph}{{\sf scalar$-$partial}}{19}
+\contentsline {paragraph}{{\sf partial}}{19}
+\contentsline {paragraph}{{\sf determinant}}{19}
+\contentsline {paragraph}{{\sf minor}}{19}
+\contentsline {paragraph}{{\sf drop$-$row}}{19}
+\contentsline {paragraph}{{\sf drop$-$column}}{19}
+\contentsline {paragraph}{{\sf drop$-$elt}}{19}
+\contentsline {paragraph}{{\sf matrix$-$}}{19}
+\contentsline {paragraph}{{\sf scalar$-$times$-$matrix}}{20}
+\contentsline {paragraph}{{\sf monom$-$times$-$matrix}}{20}
+\contentsline {paragraph}{{\sf term$-$times$-$matrix}}{20}
+\contentsline {paragraph}{{\sf poly$-$list$-$}}{20}
+\contentsline {paragraph}{{\sf scalar$-$times$-$poly$-$list}}{20}
+\contentsline {paragraph}{{\sf monom$-$times$-$poly$-$list}}{20}
+\contentsline {paragraph}{{\sf term$-$times$-$poly$-$list}}{20}
+\contentsline {paragraph}{{\sf characteristic$-$combination}}{20}
+\contentsline {paragraph}{{\sf characteristic$-$combination$-$poly$-$list}}{20}
+\contentsline {paragraph}{{\sf characteristic$-$matrix}}{20}
+\contentsline {paragraph}{{\sf characteristic$-$polynomial}}{20}
+\contentsline {paragraph}{{\sf identity$-$matrix}}{21}
+\contentsline {paragraph}{{\sf print$-$matrix}}{21}
+\contentsline {paragraph}{{\sf jacobi$-$matrix}}{21}
+\contentsline {paragraph}{{\sf jacobian}}{21}
+\contentsline {section}{\numberline {7}The Geometric Theorem Prover package}{21}
+\contentsline {paragraph}{{\sf *prover$-$order*}}{21}
+\contentsline {paragraph}{{\sf csym}}{21}
+\contentsline {paragraph}{{\sf real$-$identical$-$points}}{21}
+\contentsline {paragraph}{{\sf identical$-$points}}{21}
+\contentsline {paragraph}{{\sf perpendicular}}{21}
+\contentsline {paragraph}{{\sf parallel}}{21}
+\contentsline {paragraph}{{\sf collinear}}{22}
+\contentsline {paragraph}{{\sf equidistant}}{22}
+\contentsline {paragraph}{{\sf euclidean$-$distance}}{22}
+\contentsline {paragraph}{{\sf midpoint}}{22}
+\contentsline {paragraph}{{\sf translate$-$statements}}{22}
+\contentsline {paragraph}{{\sf translate$-$assumptions}}{22}
+\contentsline {paragraph}{{\sf translate$-$conclusions}}{22}
+\contentsline {paragraph}{{\sf translate$-$theorem}}{22}
+\contentsline {paragraph}{{\sf prove$-$theorem}}{22}
+\contentsline {section}{\numberline {8}The Monomial Order Package}{22}
+\contentsline {paragraph}{{\sf lex$>$}}{22}
+\contentsline {paragraph}{{\sf total$-$degree}}{23}
+\contentsline {paragraph}{{\sf grlex$>$}}{23}
+\contentsline {paragraph}{{\sf grevlex$>$}}{23}
+\contentsline {paragraph}{{\sf revlex$>$}}{23}
+\contentsline {paragraph}{{\sf invlex$>$}}{23}
+\contentsline {paragraph}{{\sf elimination$-$order}}{23}
+\contentsline {paragraph}{{\sf elimination$-$order$-$1}}{23}
+\contentsline {section}{\numberline {9}The Polynomial Package}{23}
+\contentsline {paragraph}{{\sf scalar$-$times$-$poly}}{23}
+\contentsline {paragraph}{{\sf term$-$times$-$poly}}{23}
+\contentsline {paragraph}{{\sf monom$-$times$-$poly}}{23}
+\contentsline {paragraph}{{\sf minus$-$poly}}{23}
+\contentsline {paragraph}{{\sf sort$-$poly}}{24}
+\contentsline {paragraph}{{\sf poly+}}{24}
+\contentsline {paragraph}{{\sf poly$-$}}{24}
+\contentsline {paragraph}{{\sf poly*}}{24}
+\contentsline {paragraph}{{\sf poly$-$op}}{24}
+\contentsline {paragraph}{{\sf poly$-$expt}}{24}
+\contentsline {paragraph}{{\sf poly$-$mexpt}}{24}
+\contentsline {paragraph}{{\sf poly$-$constant$-$p}}{24}
+\contentsline {paragraph}{{\sf poly$-$extend}}{24}
+\contentsline {paragraph}{{\sf poly$-$extend$-$end}}{24}
+\contentsline {paragraph}{{\sf poly$-$zerop}}{24}
+\contentsline {paragraph}{{\sf lt}}{25}
+\contentsline {paragraph}{{\sf lm}}{25}
+\contentsline {paragraph}{{\sf lc}}{25}
+\contentsline {section}{\numberline {10}The Parser Package}{25}
+\contentsline {paragraph}{{\sf parse}}{25}
+\contentsline {paragraph}{{\sf alist$-$form}}{25}
+\contentsline {paragraph}{{\sf alist$-$form$-$1}}{25}
+\contentsline {paragraph}{{\sf powers}}{25}
+\contentsline {paragraph}{{\sf parse$-$to$-$alist}}{25}
+\contentsline {paragraph}{{\sf parse$-$string$-$to$-$alist}}{25}
+\contentsline {paragraph}{{\sf parse$-$to$-$sorted$-$alist}}{26}
+\contentsline {paragraph}{{\sf parse$-$string$-$to$-$sorted$-$alist}}{26}
+\contentsline {paragraph}{{\sf sort$-$poly$-$1}}{26}
+\contentsline {paragraph}{{\sf sort$-$poly}}{26}
+\contentsline {paragraph}{{\sf poly$-$eval$-$1}}{26}
+\contentsline {paragraph}{{\sf poly$-$eval}}{26}
+\contentsline {paragraph}{{\sf monom$-$basis}}{26}
+\contentsline {paragraph}{{\sf convert$-$number}}{26}
+\contentsline {paragraph}{{\sf \$poly+}}{27}
+\contentsline {paragraph}{{\sf \$poly$-$}}{27}
+\contentsline {paragraph}{{\sf \$minus$-$poly}}{27}
+\contentsline {paragraph}{{\sf \$poly*}}{27}
+\contentsline {paragraph}{{\sf \$poly/}}{27}
+\contentsline {paragraph}{{\sf \$poly$-$expt}}{27}
+\contentsline {section}{\numberline {11}Other packages}{27}
+\contentsline {paragraph}{{\sf makelist$-$1}}{27}
+\contentsline {paragraph}{{\sf makelist}}{27}
+\contentsline {paragraph}{{\sf sum}}{27}
+\contentsline {paragraph}{{\sf list$-$of}}{27}
+\contentsline {paragraph}{{\sf list$-$of$-$1}}{27}
+\contentsline {paragraph}{{\sf union$-$of}}{27}
+\contentsline {paragraph}{{\sf union$-$of$-$1}}{28}
+\contentsline {paragraph}{{\sf set$-$of}}{28}
+\contentsline {paragraph}{{\sf set$-$of$-$1}}{28}
+\contentsline {paragraph}{{\sf select}}{28}
+\contentsline {paragraph}{{\sf monom/}}{28}
+\contentsline {paragraph}{{\sf monom*}}{28}
+\contentsline {paragraph}{{\sf nmonom*}}{28}
+\contentsline {paragraph}{{\sf monom$-$divides$-$p}}{28}
+\contentsline {paragraph}{{\sf monom$-$divisible$-$by$-$p}}{28}
+\contentsline {paragraph}{{\sf monom$-$rel$-$prime}}{28}
+\contentsline {paragraph}{{\sf monom$-$equal}}{28}
+\contentsline {paragraph}{{\sf monom$-$lcm}}{28}
+\contentsline {paragraph}{{\sf monom$-$gcd}}{28}
+\contentsline {paragraph}{{\sf poly$-$gcd}}{28}
+\contentsline {paragraph}{{\sf poly$-$pseudo$-$divide}}{29}
+\contentsline {paragraph}{{\sf poly$-$pseudo$-$remainder}}{29}
+\contentsline {paragraph}{{\sf mdeg}}{29}
+\contentsline {paragraph}{{\sf lcoeff}}{29}
+\contentsline {paragraph}{{\sf lrest}}{29}
+\contentsline {paragraph}{{\sf lpart}}{29}
+\contentsline {paragraph}{{\sf poly$-$primitive$-$part}}{29}
+\contentsline {paragraph}{{\sf poly$-$content}}{29}
+\contentsline {paragraph}{{\sf poly$-$with$-$sugar$-$poly}}{29}
+\contentsline {paragraph}{{\sf poly$-$with$-$sugar$-$sugar}}{29}
+\contentsline {paragraph}{{\sf poly$-$with$-$sugar$-$tail}}{29}
+\contentsline {paragraph}{{\sf (setf poly$-$with$-$sugar$-$poly)}}{29}
+\contentsline {paragraph}{{\sf (setf poly$-$with$-$sugar$-$sugar)}}{29}
+\contentsline {paragraph}{{\sf (setf poly$-$with$-$sugar$-$tail)}}{29}
+\contentsline {paragraph}{{\sf monom$-$sugar}}{30}
+\contentsline {paragraph}{{\sf coefficient$-$sugar}}{30}
+\contentsline {paragraph}{{\sf term$-$sugar}}{30}
+\contentsline {paragraph}{{\sf poly$-$add$-$sugar}}{30}
+\contentsline {paragraph}{{\sf scalar$-$times$-$poly$-$with$-$sugar}}{30}
+\contentsline {paragraph}{{\sf term$-$times$-$poly$-$with$-$sugar}}{30}
+\contentsline {paragraph}{{\sf monom$-$times$-$poly$-$with$-$sugar}}{30}
+\contentsline {paragraph}{{\sf minus$-$poly$-$with$-$sugar}}{30}
+\contentsline {paragraph}{{\sf poly$-$with$-$sugar+}}{30}
+\contentsline {paragraph}{{\sf poly$-$with$-$sugar$-$}}{30}
+\contentsline {paragraph}{{\sf poly$-$with$-$sugar$-$op}}{30}
+\contentsline {paragraph}{{\sf poly$-$with$-$sugar$-$nreverse}}{30}
+\contentsline {paragraph}{{\sf poly$-$with$-$sugar$-$append}}{30}
+\contentsline {paragraph}{{\sf poly$-$with$-$sugar$-$zerop}}{30}
+\contentsline {paragraph}{{\sf poly$-$with$-$sugar$-$lm}}{31}
+\contentsline {paragraph}{{\sf poly$-$with$-$sugar$-$lc}}{31}
+\contentsline {paragraph}{{\sf poly$-$with$-$sugar$-$lt}}{31}
+\contentsline {paragraph}{{\sf poly$-$print}}{31}
+\contentsline {paragraph}{{\sf poly$-$print$-$1}}{31}
+\contentsline {paragraph}{{\sf poly$-$print$-$2}}{31}
+\contentsline {paragraph}{{\sf print$-$term}}{31}
+\contentsline {paragraph}{{\sf print$-$monom}}{31}
+\contentsline {paragraph}{{\sf num}}{31}
+\contentsline {paragraph}{{\sf denom}}{31}
+\contentsline {paragraph}{{\sf rat$-$simplify$-$2}}{31}
+\contentsline {paragraph}{{\sf rat$-$simplify}}{31}
+\contentsline {paragraph}{{\sf rat+}}{31}
+\contentsline {paragraph}{{\sf rat$-$}}{32}
+\contentsline {paragraph}{{\sf rat*}}{32}
+\contentsline {paragraph}{{\sf rat/}}{32}
+\contentsline {paragraph}{{\sf scalar$-$times$-$rat}}{32}
+\contentsline {paragraph}{{\sf scalar$-$div$-$rat}}{32}
+\contentsline {paragraph}{{\sf rat$-$zerop}}{32}
+\contentsline {paragraph}{{\sf rat$-$uminus}}{32}
+\contentsline {paragraph}{{\sf rat$-$expt}}{32}
+\contentsline {paragraph}{{\sf rat$-$constant}}{32}
+\contentsline {paragraph}{{\sf rat$-$to$-$poly}}{32}
+\contentsline {paragraph}{{\sf ratpoly+}}{32}
+\contentsline {paragraph}{{\sf ratpoly$-$}}{32}
+\contentsline {paragraph}{{\sf ratpoly$-$uminus}}{32}
+\contentsline {paragraph}{{\sf ratpoly*}}{32}
+\contentsline {paragraph}{{\sf scalar$-$times$-$ratpoly}}{33}
+\contentsline {paragraph}{{\sf rat$-$times$-$ratpoly}}{33}
+\contentsline {paragraph}{{\sf ratpoly$-$divide}}{33}
+\contentsline {paragraph}{{\sf ratpoly$-$remainder}}{33}
+\contentsline {paragraph}{{\sf ratpoly$-$gcd}}{33}
+\contentsline {paragraph}{{\sf ratpoly$-$diff}}{33}
+\contentsline {paragraph}{{\sf ratpoly$-$square$-$free}}{33}
+\contentsline {paragraph}{{\sf ratpoly$-$normalize}}{33}
+\contentsline {paragraph}{{\sf ratpoly$-$resultant}}{33}
+\contentsline {paragraph}{{\sf deg}}{33}
+\contentsline {paragraph}{{\sf lead}}{33}
+\contentsline {paragraph}{{\sf ratpoly$-$discriminant}}{33}
+\contentsline {paragraph}{{\sf ratpoly$-$print}}{33}
+\contentsline {paragraph}{{\sf poly$-$to$-$ratpoly}}{33}
+\contentsline {paragraph}{{\sf poly$-$to$-$poly1}}{34}
+\contentsline {paragraph}{{\sf poly1$-$to$-$ratpoly}}{34}
+\contentsline {paragraph}{{\sf ratpoly$-$to$-$poly1}}{34}
+\contentsline {paragraph}{{\sf poly1$-$to$-$poly}}{34}
+\contentsline {paragraph}{{\sf ratpoly$-$to$-$poly}}{34}
+\contentsline {paragraph}{{\sf poly$-$resultant}}{34}
+\contentsline {paragraph}{{\sf term*}}{34}
+\contentsline {paragraph}{{\sf term/}}{34}
+\contentsline {paragraph}{{\sf monom$-$times$-$term}}{34}
+\contentsline {paragraph}{{\sf term$-$divides$-$p}}{34}
+\contentsline {paragraph}{{\sf term$-$monom}}{34}
+\contentsline {paragraph}{{\sf term$-$coefficient}}{34}
+\contentsline {paragraph}{{\sf (setf term$-$monom)}}{34}
+\contentsline {paragraph}{{\sf (setf term$-$coefficient)}}{34}
+\contentsline {paragraph}{{\sf xgcd}}{35}
+\contentsline {section}{\numberline {A}All examples produced by the {\tt all-examples} utility}{35}
Index: /trunk/latex-doc/manual/images.aux
===================================================================
--- /trunk/latex-doc/manual/images.aux	(revision 8)
+++ /trunk/latex-doc/manual/images.aux	(revision 8)
@@ -0,0 +1,1 @@
+\relax 
Index: /trunk/latex-doc/manual/images.log
===================================================================
--- /trunk/latex-doc/manual/images.log	(revision 8)
+++ /trunk/latex-doc/manual/images.log	(revision 8)
@@ -0,0 +1,118 @@
+This is TeX, Version 3.14159 (C version 6.1) (format=latex 97.4.20)  21 MAR 1998 12:17
+**./images.tex
+(images.tex
+LaTeX2e <1996/12/01> patch level 1
+Babel <v3.6h> and hyphenation patterns for american, german, loaded.
+
+(/usr/lib/texmf/texmf/tex/latex/base/article.cls
+Document Class: article 1996/10/31 v1.3u Standard LaTeX document class
+(/usr/lib/texmf/texmf/tex/latex/base/size10.clo
+File: size10.clo 1996/10/31 v1.3u Standard LaTeX file (size option)
+)
+\c@part=\count79
+\c@section=\count80
+\c@subsection=\count81
+\c@subsubsection=\count82
+\c@paragraph=\count83
+\c@subparagraph=\count84
+\c@figure=\count85
+\c@table=\count86
+\abovecaptionskip=\skip41
+\belowcaptionskip=\skip42
+\bibindent=\dimen102
+) (/usr/lib/texmf/texmf/tex/latex/graphics/color.sty
+Package: color 1997/01/07 v1.0d Standard LaTeX Color (DPC)
+(/usr/lib/texmf/texmf/tex/latex/config/color.cfg)
+Package color Info: Driver file: dvips.def on input line 128.
+(/usr/lib/texmf/texmf/tex/latex/graphics/dvips.def
+File: dvips.def 1996/12/12 v3.0d Driver-dependant file (DPC,SPQR)
+) (/usr/lib/texmf/texmf/tex/latex/graphics/dvipsnam.def
+File: dvipsnam.def 1996/12/12 v3.0d Driver-dependant file (DPC,SPQR)
+)) (/usr/lib/texmf/texmf/tex/latex/misc/fullpage.sty
+Style Option FULLPAGE Version 2 as of 15 Dec 1988
+) (/home/marek/CGB/latex-doc/man.sty Preloading the manual format for the CGB p
+ackage)
+\formnamelen=\skip43
+\pboxargslen=\skip44
+\typelen=\skip45
+\sizebox=\box26
+\lthtmlwrite=\write3
+(images.aux)
+LaTeX Font Info:    Checking defaults for OML/cmm/m/it on input line 89.
+LaTeX Font Info:    ... okay on input line 89.
+LaTeX Font Info:    Checking defaults for T1/cmr/m/n on input line 89.
+LaTeX Font Info:    ... okay on input line 89.
+LaTeX Font Info:    Checking defaults for OT1/cmr/m/n on input line 89.
+LaTeX Font Info:    ... okay on input line 89.
+LaTeX Font Info:    Checking defaults for OMS/cmsy/m/n on input line 89.
+LaTeX Font Info:    ... okay on input line 89.
+LaTeX Font Info:    Checking defaults for OMX/cmex/m/n on input line 89.
+LaTeX Font Info:    ... okay on input line 89.
+LaTeX Font Info:    Checking defaults for U/cmr/m/n on input line 89.
+LaTeX Font Info:    ... okay on input line 89.
+latex2htmlLength hsize=451.0pt
+latex2htmlLength vsize=673.20255pt
+latex2htmlLength hoffset=0.0pt
+latex2htmlLength voffset=0.0pt
+latex2htmlLength topmargin=0.0pt
+latex2htmlLength topskip=0.00002pt
+latex2htmlLength headheight=0.0pt
+latex2htmlLength headsep=0.0pt
+latex2htmlLength parskip=0.0pt plus 1.0pt
+latex2htmlLength oddsidemargin=0.0pt
+latex2htmlLength evensidemargin=0.0pt
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <7> on input line 108.
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <5> on input line 108.
+l2hSize :tex2html_wrap_inline22131:7.5pt::7.5pt::320.43936pt.
+[1
+
+
+]
+Underfull \hbox (badness 3396) in paragraph at lines 1164--1164
+\OT1/cmr/m/it/10 (elimination$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 order k :pr
+imary$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 order #'lex$\OML/cmm/m/it/10 >$ \OT
+1/cmr/m/it/10 :secondary$\OMS/cmsy/m/n/10 ^^@$\OT1/cmr/m/it/10 order
+ []
+
+l2hSize :tex2html_wrap_inline22277:19.5pt::19.5pt::297.77266pt.
+[2
+
+
+]
+l2hSize :tex2html_wrap_inline22388:13.5pt::13.5pt::264.93924pt.
+[3
+
+
+]
+l2hSize :tex2html_wrap_inline22395:6.94444pt::6.94444pt::204.52245pt.
+[4
+
+
+]
+l2hSize :tex2html_wrap_inline22401:6.94444pt::6.94444pt::214.18913pt.
+[5
+
+
+]
+l2hSize :tex2html_wrap_inline22868:7.5pt::7.5pt::347.3283pt.
+[6
+
+
+]
+l2hSize :tex2html_wrap_inline22871:7.5pt::7.5pt::312.43935pt.
+[7
+
+
+] (images.aux) ) 
+Here is how much of TeX's memory you used:
+ 543 strings out of 10906
+ 6492 string characters out of 72187
+ 46898 words of memory out of 262141
+ 3464 multiletter control sequences out of 9500
+ 4291 words of font info for 16 fonts, out of 150000 for 255
+ 14 hyphenation exceptions out of 607
+ 23i,5n,19p,231b,217s stack positions out of 300i,40n,60p,3000b,4000s
+
+Output written on images.dvi (7 pages, 2208 bytes).
Index: /trunk/latex-doc/manual/images.pl
===================================================================
--- /trunk/latex-doc/manual/images.pl	(revision 8)
+++ /trunk/latex-doc/manual/images.pl	(revision 8)
@@ -0,0 +1,1293 @@
+# LaTeX2HTML 97.1 (release) (July 13th, 1997)
+# Associate images original text with physical files.
+
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfppredstarttop_inline-_inlinereduction_ipred(elimination_inline-_inlineorder_inline-_inline1pred))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="476" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img34.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f p pred start top$-$reduction$-$only ring {\sf \&aux} (pred
+ (elimination$-$order$-$1
+ pred)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emf_inline-_inlinewith_inline-_inlinesugarg_inline-_inlinewith_inline-_inlinesugarpredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="484" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img51.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f$-$with$-$sugar g$-$with$-$sugar pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empoly_inline-_inlinelistvarssf&key(streaminline-_inlinepartnil)(mark_inline-_inlinecoefficientsnil)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="442" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img73.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly$-$list vars {\sf \&key} (stream
+ t) (beg
+ t) (print$-$green$-$part
+ nil) (mark$-$coefficients
+ nil) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfflsf&optional(pred#'lex_inline>_inline)(ring*coefficient_inline-_inlinering*)sf&aux(s(lengthfl))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="571" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img114.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f fl {\sf \&optional} (pred \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) {\sf \&aux} (s
+ (length
+ fl)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emf_inline-_inlineno_inline-_inlinesugarprnespace(lengthf_inline-_inlineno_inline-_inlinesugar)))bmf}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="443" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img52.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f$-$no$-$sugar pred start top$-$reduction$-$only ring {\sf \&aux} (s (1$-$\space (length f$-$no$-$sugar))) b m f \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emsf&restargs}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="576" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img7.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em {\sf \&rest} args \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emtermforderring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="426" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img89.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term f order ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emabcd}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="562" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img141.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b c d \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcondtermrestpgporderring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="448" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img76.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond term restp end gp order ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfgmain_inline-_inlineorderparameter_inline-_inlineorderring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="530" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img87.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g main$-$order parameter$-$order ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empolynsf&optional(pred#'lex_inline>_inline)(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="540" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img159.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly n {\sf \&optional} (pred
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emnumber_inline-_inlineor_inline-_inlinepolyn}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="495" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img175.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em number$-$or$-$poly n \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empnring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="521" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img177.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p n ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emtermfring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="396" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img196.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term f ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emsystemvarsparamssf&key(suppress_inline-_partnil)(mark_inline-_inlinecoefficientsnil)sf&aux(label0)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="474" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img77.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em system vars params {\sf \&key} (suppress$-$...
+ ...rint$-$green$-$part
+ nil) (mark$-$coefficients
+ nil) {\sf \&aux} (label
+ 0) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfi}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="543" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img125.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f i \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empolyvarssf&key(streamt)(begt)(print_inliinline-_inlinepartnil)(mark_inline-_inlinecoefficientsnil)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="475" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img72.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly vars {\sf \&key} (stream
+ t) (beg
+ t) (print$-$green$-$part
+ nil) (mark$-$coefficients
+ nil) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfnsf&optional(order#'lex_inline>_inline)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="459" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img117.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f n {\sf \&optional} (order \char93 'lex$\gt$) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfm}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="496" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img120.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f m \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emc1c2mabpredringsf&auxna1a2}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="529" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img12.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c1 c2 m a b pred ring {\sf \&aux} n a1 a2 \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emexprvarlohisf&optional(step1)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="577" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img180.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr var lo hi {\sf \&optional} (step 1) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfgpred}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="526" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img14.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g pred \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfijsf&optional(order#'lex_inline>_inline)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="572" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img124.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f i j {\sf \&optional} (order \char93 'lex$\gt$) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcfring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="419" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img90.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c f ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfgsf&optional(order#'lex_inline>_inline)(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="480" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img115.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g {\sf \&optional} (order
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfgpredtop_inline-_inlinereduction_inline-_inlineonlyring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="487" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img26.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g pred top$-$reduction$-$only ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empqsf&optional(pred#'lex_inline>_inline)(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="570" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img157.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q {\sf \&optional} (pred \char93 'lex$\gt$) (ring *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfxsf&optional(order#'lex_inline>_inline)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="461" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img118.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f x {\sf \&optional} (order \char93 'lex$\gt$) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfflvarssf&key(streamt)(printt)(order#'lene-_inlinevaluet)sf&aux(vars(read_inline-_inlinevarsvars))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="468" HEIGHT="70" ALIGN="MIDDLE" BORDER="0"
+ SRC="img56.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f fl vars {\sf \&key} (stream
+ t) (print
+ t...
+ ...ient$-$ring*) (suppress$-$value
+ t) {\sf \&aux} (vars
+ (read$-$vars
+ vars)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{em(sf&restassumptions)(sf&restconclusions)sf&key(order*prover_inline-_inlineorder*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="549" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img148.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em ({\sf \&rest} assumptions) ({\sf \&rest}
+ conclusions) {\sf \&key} (order
+ *prover$-$order*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcoefficient}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="395" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img218.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em coefficient \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empvarssf&aux(ht(make_inline-_inlinehash_inline-_inlinetable:test#'equal:size16))stack}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="517" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img164.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p vars {\sf \&aux} (ht
+ (make$-$hash$-$table
+ :test
+ \char93 'equal
+ :size
+ 16)) stack \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emexprvarsorderringsf&aux(n(lengthvars))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="521" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img172.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr vars order ring {\sf \&aux} (n (length vars)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empvarssf&optional(streamt)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="516" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img202.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p vars {\sf \&optional} (stream t) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emsf&reststatements}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="507" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img144.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em {\sf \&rest} statements \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcpsf&optional(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="481" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img153.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c p {\sf \&optional} (ring *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emmonom}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="414" HEIGHT="14" ALIGN="BOTTOM" BORDER="0"
+ SRC="img217.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em monom \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcpoly}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="451" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img71.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cpoly \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emexprvarssf&optional(order#'lex_inline>_inline)(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="543" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img173.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr vars {\sf \&optional} (order
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcondparams}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="533" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img78.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond params \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{em'gebauer_inline-_inlinemoeller_inline-_is_inline-_inlineuse_inline-_inlinemock_inline-_inlinespoly}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="384" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img3.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em 'gebauer$-$moeller$-$merge$-$pairs$-$use$-$mock$-$spoly \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcoverorderring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="506" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img98.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cover order ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfideal_inline-_inlinelistvarssf&key(orde_inline-_inlinealistgvarsorder))ideal_inline-_inlinelist))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="417" HEIGHT="130" ALIGN="MIDDLE" BORDER="0"
+ SRC="img62.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f ideal$-$list vars {\sf \&key} (order
+ \ch...
+ ...da (g) (parse$-$string$-$to$-$sorted$-$alist g vars order))
+ ideal$-$list)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emm}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="511" HEIGHT="14" ALIGN="BOTTOM" BORDER="0"
+ SRC="img192.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfpredstarttop_inline-_inlinereduction_inline-_inlineonlyringsf&auxbgf1}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="494" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img47.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f pred start top$-$reduction$-$only ring {\sf \&aux} b g f1 \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcondorderring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="510" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img99.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond order ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfvarsparamsmain_inline-_inlineorderparamx(k(lengthvars))(vars_inline-_inlineparams(appvarsparams))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="412" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img107.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f vars params main$-$order parameter$-$order {\sf \&aux} (k
+ (length
+ vars)) (vars$-$params
+ (append
+ vars
+ params)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcn}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="520" HEIGHT="14" ALIGN="BOTTOM" BORDER="0"
+ SRC="img208.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c n \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emnsf&aux(basis(copy_inline-_inlinetree(mainline-_inlinelistn:initial_inline-_inlineelement0)1))))))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="514" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img174.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em n {\sf \&aux} (basis
+ (copy$-$tree
+ (make$-...
+ ...
+ (list 'quote
+ (list
+ (cons
+ (make$-$list n :initial$-$element 0)
+ 1)))))) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empolyring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="495" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img194.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfplistvarssf&key(order#'lex_inline>_inlio_inline-_inlinesorted_inline-_inlinealistplistvarsorder))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="395" HEIGHT="110" ALIGN="MIDDLE" BORDER="0"
+ SRC="img61.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f plist vars {\sf \&key} (order
+ \char93 'l...
+ ...order)) (plist
+ (parse$-$string$-$to$-$sorted$-$alist
+ plist
+ vars
+ order)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emsf}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="466" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img128.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em s f \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{em(make_inline-_inlinering:+#'+:_inline-_iinatorx)))):numerator#'numerator:denominator#'denominator)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="475" HEIGHT="110" ALIGN="MIDDLE" BORDER="0"
+ SRC="img111.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em (make$-$ring :+ \char93 '+ :$-$\space \char...
+ ...or x))))
+ :numerator \char93 'numerator :denominator
+ \char93 'denominator) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{em'buchberger}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="480" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img4.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em 'buchberger \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emnksf&optional(coeff1)sf&aux(v(make_inline-_inlinelistn:initial_inline-_inlineelement0))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="497" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img121.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em n k {\sf \&optional} (coeff
+ 1) {\sf \&aux} (v
+ (make$-$list
+ n
+ :initial$-$element
+ 0)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emftermgpredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="461" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img199.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f term g pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfksf&optional(l1)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="516" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img122.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f k {\sf \&optional} (l 1) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emdimnvars}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="503" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img134.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em dim nvars \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfgsf&optional(pred#'lex_inline>_inline)(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="545" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img28.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g {\sf \&optional} (pred \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{em(make_inline-_inlinering:+#'+:_inline-_inlinelength:numerator#'numerator:denominator#'denominator)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="482" HEIGHT="90" ALIGN="MIDDLE" BORDER="0"
+ SRC="img110.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em (make$-$ring :+ \char93 '+ :$-$\space \char...
+ ...$-$length :numerator \char93 'numerator
+ :denominator \char93 'denominator) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emksf&key(primary_inline-_inlineorder#'lexinline)(secondary_inline-_inlineorder#'lex_inline>_inline)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="488" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img151.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em k {\sf \&key} (primary$-$order
+ \char93 'lex$\gt$) (secondary$-$order
+ \char93 'lex$\gt$) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empsf&aux(l(degp))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="466" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img210.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p {\sf \&aux} (l (deg p)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emvarssf&optionalstream}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="508" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img166.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em vars {\sf \&optional} stream \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emflistsf&optional(cond(listnilnil))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="503" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img69.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em flist {\sf \&optional} (cond (list nil nil)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emsf&optionalstream}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="576" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img162.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em {\sf \&optional} stream \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{em'buchberger_inline-_inlinemerge_inline-_inlinepairs_inline-_inlinesmallest_inline-_inlinelcm}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="425" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img2.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em 'buchberger$-$merge$-$pairs$-$smallest$-$lcm \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfmgpredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="553" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img158.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f m g pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="437" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img197.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emexpr(varlohisf&optional(step1))sf&restmore}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="598" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img181.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr (var lo hi {\sf \&optional} (step 1)) {\sf \&rest} more \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empk}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="492" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img23.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p k \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emexprvarlst}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="587" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img184.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr var lst \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfsf&optional(pred#'lex_inline>_inline)(sline-_inlineonlynil)(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="559" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img6.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (pred \char93 'lex$\gt$) (start
+ 0) (top$-$reduction$-$only
+ nil) (ring
+ *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfpredstarttop_inline-_inlinereduction_in_inlineonlyringsf&aux(s(1_inline-_inlinespace(lengthf)))bm}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="535" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img11.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f pred start top$-$reduction$-$only ring {\sf \&aux} (s (1$-$\space (length f))) b m \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empairgmsf&aux(i(firstpair))(j(secondpair))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="533" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img18.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em pair g m {\sf \&aux} (i (first pair)) (j (second pair)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfvars}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="522" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img135.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f vars \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emtermk}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="489" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img22.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term k \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emab}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="504" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img140.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emgsmain_inline-_inlineorderparameter_inline-_inlineorderreducegreen_inline-_inlinereducering}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="460" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img101.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em gs main$-$order parameter$-$order reduce green$-$reduce ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emterm1term2sf&optional(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="571" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img213.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term1 term2 {\sf \&optional} (ring *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emmterm}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="465" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img214.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m term \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcondparamssf&optional(order#'lex_inline>_inline)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="527" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img96.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond params {\sf \&optional} (order \char93 'lex$\gt$) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emc1c2}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="570" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img92.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c1 c2 \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emppredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="547" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img20.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcondflparameter_inline-_inlineorderring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="421" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img105.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond fl parameter$-$order ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{em*ring_inline-_inlineof_inline-_inlineintegers*}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="492" HEIGHT="30" ALIGN="MIDDLE" BORDER="0"
+ SRC="img113.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em *ring$-$of$-$integers* \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emsf&restconclusions}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="504" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img146.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em {\sf \&rest} conclusions \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emp}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emtermfsf&optional(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="488" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img154.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term f {\sf \&optional} (ring *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emflistksf&key(primary_inline-_inlineorderline-_inlineonlynil)(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="491" HEIGHT="90" ALIGN="MIDDLE" BORDER="0"
+ SRC="img25.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em flist k {\sf \&key} (primary$-$order
+ \char...
+ ...ondary$-$order)) (top$-$reduction$-$only
+ nil) (ring
+ *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{embcgmpredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="343" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img53.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c g m pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfpvarssf&key(order#'lex_inline>_inline)(ineto_inline-_inlinesorted_inline-_inlinealistpvarsorder))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="424" HEIGHT="110" ALIGN="MIDDLE" BORDER="0"
+ SRC="img60.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f p vars {\sf \&key} (order
+ \char93 'lex$\...
+ ...
+ vars
+ order)) (p
+ (parse$-$string$-$to$-$sorted$-$alist
+ p
+ vars
+ order)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emplistvarssf&key(order#'lex_inline>_inlininering*)(printt)sf&aux(vars(read_inline-_inlinevarsvars))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="507" HEIGHT="70" ALIGN="MIDDLE" BORDER="0"
+ SRC="img57.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist vars {\sf \&key} (order
+ \char93 'lex...
+ ...g
+ *coefficient$-$ring*) (print
+ t) {\sf \&aux} (vars
+ (read$-$vars
+ vars)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcondpmain_inline-_inlineorderparameter_iine-_inlineorderringsf&aux(open(list(listcondnilp)))closed}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="485" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img103.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond p main$-$order parameter$-$order ring {\sf \&aux} (open
+ (list
+ (list
+ cond
+ nil
+ p))) closed \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emterm}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="558" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img216.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empairmain_inline-_inlineorderparameter_ine-_inlineorderreducegreen_inline-_inlinereduceringsf&auxgs}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="546" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img102.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em pair main$-$order parameter$-$order reduce green$-$reduce ring {\sf \&aux} gs \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emppred}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="523" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img44.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p pred \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emm1m2}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="552" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img186.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m1 m2 \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emf1f2predtop_inline-_inlinereduction_inline-_inlineonlyring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="530" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img31.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f1 f2 pred top$-$reduction$-$only ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfgpredstarttop_inline-_inlinereduction_iex_inline>_inlinespace:secondary_inline-_inlineorderpred))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="497" HEIGHT="70" ALIGN="MIDDLE" BORDER="0"
+ SRC="img40.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g pred start top$-$reduction$-$only ring ...
+ ...$order k :primary$-$order \char93 'lex$\gt$\space :secondary$-$order pred)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emsymbolnumber}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="577" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img139.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em symbol number \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empsf&optional(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="430" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img65.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p {\sf \&optional} (ring
+ *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcoverparamssf&optional(order#'lex_inline>_inline)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="523" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img97.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cover params {\sf \&optional} (order \char93 'lex$\gt$) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfgvarssf&key(order#'lex_inline>_inline)(ineto_inline-_inlinesorted_inline-_inlinealistgvarsorder))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="435" HEIGHT="90" ALIGN="MIDDLE" BORDER="0"
+ SRC="img59.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g vars {\sf \&key} (order
+ \char93 'lex$\...
+ ...
+ vars
+ order)) (g
+ (parse$-$string$-$to$-$sorted$-$alist
+ g
+ vars
+ order)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emgspred}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="541" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img79.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em gs pred \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emmonomvarssf&aux(tab(pairlisvars(make_inl-_inlinelist(lengthvars):initial_inline-_inlineelement0)))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="564" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img165.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em monom vars {\sf \&aux} (tab
+ (pairlis vars
+ (make$-$list (length vars)
+ :initial$-$element 0))) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emscalarp}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="490" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img206.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em scalar p \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emalgorithm}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="429" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img5.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em algorithm \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{embcgpredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="301" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img15.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c g pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emplistsf&restrest}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="438" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img68.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist {\sf \&rest} rest \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfgpredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="576" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img8.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empqsf&optional(start0)((lengthp))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="580" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img149.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q {\sf \&optional} (start 0) (end (length p)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empsf&aux(htab(make_inline-_inlinehash_inline-_inlinetable))q}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="505" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img212.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p {\sf \&aux} (htab (make$-$hash$-$table)) q \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfgsf&optional(order#'lex_inline>_inline)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="435" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img116.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g {\sf \&optional} (order \char93 'lex$\gt$) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfg}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="469" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img187.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfplistringsf&aux(k(lengthplist))(d(+k(length(caaarplist))))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="465" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img37.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f plist ring {\sf \&aux} (k
+ (length plist)) (d
+ (+
+ k
+ (length
+ (caaar
+ plist)))) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emijfbs}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="471" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img85.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em i j f b s \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfplistpredstarttop_inline-_inlinereduction_inline-_inlineonlyring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="447" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img39.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f plist pred start top$-$reduction$-$only ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcgmpredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="359" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img54.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c g m pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{embbnewgpredsf&optional(sort_inline-_inlinefirstnil)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="518" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img83.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b bnew g pred {\sf \&optional} (sort$-$first nil) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="492" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img193.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emplistsf&aux(k(lengthplist))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="472" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img36.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist {\sf \&aux} (k (length plist)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emsf&bodybody}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="627" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img182.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em {\sf \&body} body \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emexpr(varlst)sf&restmore}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="608" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img183.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr (var lst) {\sf \&rest} more \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empn}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="549" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img207.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p n \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfsf&optional(order#'lex_inline>_inline)(m(lengthf))(n(length(caaaarf)))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="554" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img137.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (order \char93 'lex$\gt$) (m
+ (length f)) (n
+ (length
+ (caaaar f))) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emtermf}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="472" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img130.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term f \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empoly_inline-_inlineor_inline-_inlinepoly_inline-_inlinelistsf&optional(order#'lex_inline>_inline)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="544" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img171.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly$-$or$-$poly$-$list {\sf \&optional} (order \char93 'lex$\gt$) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emgbhpredringsf&auxcdeb_inline-_inlinenewg_inline-_inlinenewpair}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="564" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img48.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em g b h pred ring {\sf \&aux} c d e b$-$new g$-$new pair \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emgpredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="465" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img42.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em g pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emnil}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="495" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img1.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em nil \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcpring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="389" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img195.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c p ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emstring_inline-_inlineor_inline-_inlinelist}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="542" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img66.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em string$-$or$-$list \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emabc}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="598" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img142.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b c \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfideal_inline-_inlinelistpredstarttop_inline-_inlinereduction_inline-_inlineonlyring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="468" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img41.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f ideal$-$list pred start top$-$reduction$-$only ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emgfpredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="520" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img43.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em g f pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emg1g2sf&optional(pred#'lex_inline>_inline)(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="510" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img29.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em g1 g2 {\sf \&optional} (pred
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empolysf&optional(pred#'lex_inline>_inline)(start0)((unless(nullpoly)(length(caarpoly))))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="544" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img156.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly {\sf \&optional} (pred
+ \char93 'lex$\gt$) (start
+ 0) (end
+ (unless
+ (null poly)
+ (length
+ (caar poly)))) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emvarssf&optional(order#'lex_inline>_inline)(streamt)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="453" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img168.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em vars {\sf \&optional} (order
+ \char93 'lex$\gt$) (stream t) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emporder}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="523" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img170.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p order \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emplistvarsstreamsf&optional(begt)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="516" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img203.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist vars stream {\sf \&optional} (beg t) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfgvarssf&key(top_inline-_inlinereductionineto_inline-_inlinesorted_inline-_inlinealistgvarsorder))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="478" HEIGHT="90" ALIGN="MIDDLE" BORDER="0"
+ SRC="img63.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g vars {\sf \&key} (top$-$reduction$-$onl...
+ ...
+ vars
+ order)) (g
+ (parse$-$string$-$to$-$sorted$-$alist
+ g
+ vars
+ order)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{em(sf&restassumptions)(sf&restconclusions)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="526" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img147.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em ({\sf \&rest} assumptions) ({\sf \&rest} conclusions) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empairgsf&aux(i(firstpair))(j(secondpair))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="533" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img17.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em pair g {\sf \&aux} (i (first pair)) (j (second pair)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{ems}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="587" HEIGHT="14" ALIGN="BOTTOM" BORDER="0"
+ SRC="img209.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em s \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emplnorderring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="532" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img179.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p l n order ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcondpgporderring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="522" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img75.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond p end gp order ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emmk}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="470" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img21.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m k \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfsf&optional(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="529" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img155.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (ring *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empqnorderring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="561" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img176.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q n order ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emplistring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="500" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img19.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfflmain_inline-_inlineorderparameter_inlineordertop_inline-_inlinereduction_inline-_inlineonlyring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="474" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img86.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f fl main$-$order parameter$-$order top$-$reduction$-$only ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emabsf&optional(order#'lex_inline>_inline)sf&aux(n(lengthb))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="423" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img131.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b {\sf \&optional} (order
+ \char93 'lex$\gt$) {\sf \&aux} (n
+ (length
+ b)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emnumdenom}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="505" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img205.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em num denom \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empoly}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="348" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img189.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfpring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="444" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img38.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f p ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emmethodsf&aux(strategy_inline-_inlinefn(esmallest_inline-_inlinecoefficient_inline-_inlinelength)))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="551" HEIGHT="173" ALIGN="MIDDLE" BORDER="0"
+ SRC="img16.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em method {\sf \&aux} (strategy$-$fn
+ (ecase
+ ...
+ ...ar93 'buchberger$-$merge$-$pairs$-$use$-$smallest$-$coefficient$-$length))) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfflpredtop_inline-_inlinereduction_inline-_inlineonlyring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="520" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img10.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f fl pred top$-$reduction$-$only ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emplistvars}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="539" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img163.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist vars \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emtail}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="355" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img191.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em tail \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emnsf&optional(kn)sf&aux(result1)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="556" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img119.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em n {\sf \&optional} (k n) {\sf \&aux} (result 1) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empplistpredtop_inline-_inlinereduction_inline-_inlineonlyring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="511" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img33.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p plist pred top$-$reduction$-$only ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emplistksf&key(key#'identity)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="493" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img24.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist k {\sf \&key} (key \char93 'identity) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emplistmonomsf&optional(pred#'lex_inline>_inline)(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="527" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img160.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist monom {\sf \&optional} (pred
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emindlst}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="573" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img185.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em ind lst \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfj}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="517" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img126.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f j \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emgsparameter_inline-_inlineorderring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="411" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img106.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em gs parameter$-$order ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empqring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="566" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img178.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empgsf&optional(pred#'lex_inline>_inline)(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="490" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img30.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p g {\sf \&optional} (pred
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emmsf&optional(start0)((lengthm))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="522" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img150.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m {\sf \&optional} (start 0) (end (length m)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfgredpred}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="503" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img45.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f gred pred \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfvarsparamssf&key(cover(list(list"[]""[]ine-_inlinecovercoverparamsparameter_inline-_inlineorder))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="447" HEIGHT="150" ALIGN="MIDDLE" BORDER="0"
+ SRC="img95.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f vars params {\sf \&key} (cover
+ (list
+ (l...
+ ...meter$-$order)) (cover
+ (string$-$cover
+ cover
+ params
+ parameter$-$order)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emstrvarssf&optional(order#'lex_inline>_inline)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="401" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img169.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em str vars {\sf \&optional} (order
+ \char93 'lex$\gt$) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emstrvars}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="456" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img167.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em str vars \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emhring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="354" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img55.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em h ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emppredringsf&aux(p(remove_inline-_inlineif#'poly_inline-_inlineconstant_inline-_inlinepp))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="513" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img108.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p pred ring {\sf \&aux} (p
+ (remove$-$if
+ \char93 'poly$-$constant$-$p
+ p)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empqpredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="478" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img198.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="446" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img9.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empqmain_inline-_inlineorderparameter_inline-_inlineorderring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="508" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img93.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q main$-$order parameter$-$order ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empq}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="427" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img200.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emabsf&optional(order#'lex_inline>_inline)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="348" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img132.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b {\sf \&optional} (order
+ \char93 'lex$\gt$) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emb}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="574" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img188.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emsugar}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="340" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img190.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em sugar \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emsf&restassumptions}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="498" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img145.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em {\sf \&rest} assumptions \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfsf&optional(m(lengthf))(n(length(caaaarf)))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="514" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img136.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (m (length f)) (n (length (caaaar f))) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emf}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="549" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img88.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfvarsparamssf&key(cond'([][]))(main_inlinline-_inlinecondcondparamsparameter_inline-_inlineorder))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="492" HEIGHT="130" ALIGN="MIDDLE" BORDER="0"
+ SRC="img100.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f vars params {\sf \&key} (cond
+ '([] [])) ...
+ ...arameter$-$order)) (cond
+ (string$-$cond
+ cond
+ params
+ parameter$-$order)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emtermring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="455" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img94.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emmodulus}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="467" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img112.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em modulus \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emf1f2sf&optional(pred#'lex_inline>_inline)(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="515" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img32.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f1 f2 {\sf \&optional} (pred
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emlvarssf&optional(streamt)beg}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="534" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img204.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em l vars {\sf \&optional} (stream t) beg \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{em#'grevlex_inline>_inlinespace}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="510" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img138.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em \char93 'grevlex$\gt$\space \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfvarssf&key(order#'lex_inline>_inline)(sineto_inline-_inlinesorted_inline-_inlinealistfvarsorder))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="488" HEIGHT="70" ALIGN="MIDDLE" BORDER="0"
+ SRC="img64.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f vars {\sf \&key} (order
+ \char93 'lex$\gt...
+ ...$-$vars
+ vars)) (f
+ (parse$-$string$-$to$-$sorted$-$alist
+ f
+ vars
+ order)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empsf&optional(m(list0))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="524" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img161.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p {\sf \&optional} (m (list 0)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emxy}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="580" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img219.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em x y \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emmf}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="453" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img129.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m f \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfsf&optional(cond(listnilnil))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="536" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img70.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (cond (list nil nil)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfflpredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="511" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img46.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f fl pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emterm1term2}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="498" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img215.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term1 term2 \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emabr}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="522" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img143.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b r \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{em+_inline-_inlinespace*gcdlcmzeropunitlengthsignumnumeratordenominator}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="565" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img109.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em + $-$\space * / gcd lcm zerop unit length signum numerator denominator \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfsf&optional(k1)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="512" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img27.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (k 1) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emijf}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="471" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img84.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em i j f \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empolyksf&key(key#'identity)(main_inline-_(parameter_inline-_inlineorder#'lex_inline>_inline)sf&auxl}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="471" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img67.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly k {\sf \&key} (key
+ \char93 'identity)...
+ ...er
+ \char93 'lex$\gt$) (parameter$-$order
+ \char93 'lex$\gt$) {\sf \&aux} l \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfsf&optional(cond(listnilnil))(order#'lex_inline>_inline)(ring*coefficient_inline-_inlinering*)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="543" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img74.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (cond (list nil nil)) (order
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emplistn}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="514" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img35.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist n \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emorder}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="466" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img152.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em order \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emlstj}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="550" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img127.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em lst j \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emf_inline-_inlinewith_inline-_inlinesugarg_inline-_inlinewith_inline-_inlinesugarring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="527" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img50.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f$-$with$-$sugar g$-$with$-$sugar ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emasf&optional(order#'lex_inline>_inline)(identity_inline-_inlinematrix(lengtha)(length(caaaara)))))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="463" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img133.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a {\sf \&optional} (order
+ \char93 'lex$\gt$) (b
+ (list
+ (identity$-$matrix
+ (length a)
+ (length
+ (caaaar a))))) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emplistvarssf&optional(streamt)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="537" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img201.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist vars {\sf \&optional} (stream t) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emterm1term2orderring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="509" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img91.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term1 term2 order ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emcondfparameter_inline-_inlineorderring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="413" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img104.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond f parameter$-$order ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfsf&key(cover(list'(nilnil)))(main_inlin(determinefcondparameter_inline-_inlineorderring))cover)))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="499" HEIGHT="130" ALIGN="MIDDLE" BORDER="0"
+ SRC="img82.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&key} (cover (list '(nil nil))) (ma...
+ ...char93 '(lambda (cond) (determine f cond parameter$-$order ring))
+ cover))) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{embcpredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="261" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img49.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{empvarssf&optional(streamt)(begt)(p_inline-_inlineorigp)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="518" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img211.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p vars {\sf \&optional} (stream t) (beg t) (p$-$orig p) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emgamma}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="472" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img81.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em gamma \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{embgpredring}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="451" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img13.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b g pred ring \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emflistvarsksf&key(streamt)(key#'identity)ne-_inlineorder))sf&aux(vars(read_inline-_inlinevarsvars))}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="439" HEIGHT="110" ALIGN="MIDDLE" BORDER="0"
+ SRC="img58.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em flist vars k {\sf \&key} (stream
+ t) (key
+ ...
+ ...ondary$-$order
+ secondary$-$order)) {\sf \&aux} (vars
+ (read$-$vars
+ vars)) \/}$">|; 
+
+$key = q/{_inline}textstyleparbox{pboxargslen}{emfsf&optional(order#'lex_inline>_inline)sf&aux(resultnil)}{_inline}MSF=2.5;AAT;/;
+$cached_env_img{$key} = q|<IMG WIDTH="528" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img123.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (order \char93 'lex$\gt$) {\sf \&aux} (result nil) \/}$">|; 
+
+1;
+
Index: /trunk/latex-doc/manual/images.tex
===================================================================
--- /trunk/latex-doc/manual/images.tex	(revision 8)
+++ /trunk/latex-doc/manual/images.tex	(revision 8)
@@ -0,0 +1,7427 @@
+\batchmode
+\documentclass{article}
+\makeatletter
+\usepackage[dvips]{color}
+\usepackage{fullpage}
+\usepackage{man}
+
+\newlength {\formnamelen}
+ 	
+\newlength {\pboxargslen}
+ 	
+\newlength {\typelen}
+ 		
+		
+
+\title{CGBLisp User Guide and Manual}
+\author{Marek Rychlik}
+
+\pagecolor {white}
+ 
+
+\newcommand{\namestyle}{\sf}
+
+\newcommand{\argsstyle}{\em}
+
+\newenvironment{lisp:documentation}[3]{\paragraph{{\sf #1}}
+\settowidth{\formnamelen}{\sf #1}
+\settowidth{\typelen}{\em #2\/}
+\setlength{\pboxargslen}{\linewidth}
+\addtolength{\pboxargslen}{-1\formnamelen}
+\addtolength{\pboxargslen}{-1.5\typelen}
+\parbox[t]{\pboxargslen}{\em #3\/} \hfill[{\em #2\/}]
+\begin{quote}}{\end{quote}}
+
+\makeatother
+\ifx\AtBeginDocument\undefined \newcommand{\AtBeginDocument}[1]{}\fi
+\newenvironment{tex2html_wrap}{}{}
+\newbox\sizebox
+\setlength{\hoffset}{0pt}\setlength{\voffset}{0pt}
+\addtolength{\textheight}{\footskip}\setlength{\footskip}{0pt}
+\addtolength{\textheight}{\topmargin}\setlength{\topmargin}{0pt}
+\addtolength{\textheight}{\headheight}\setlength{\headheight}{0pt}
+\addtolength{\textheight}{\headsep}\setlength{\headsep}{0pt}
+\setlength{\textwidth}{451pt}
+\newwrite\lthtmlwrite
+\makeatletter
+\let\realnormalsize=\normalsize
+\topskip=0pt
+\def\preveqno{}\let\real@float=\@float \let\realend@float=\end@float
+\def\@float{\let\@savefreelist\@freelist\real@float}
+\def\end@float{\realend@float\global\let\@freelist\@savefreelist}
+\let\real@dbflt=\@dbflt \let\end@dblfloat=\end@float
+\let\@largefloatcheck=\relax
+\def\@dbflt{\let\@savefreelist\@freelist\real@dbflt}
+\def\adjustnormalsize{\def\normalsize{\mathsurround=0pt \realnormalsize\parindent=0pt\abovedisplayskip=0pt\belowdisplayskip=0pt}\normalsize}
+\def\lthtmltypeout#1{{\let\protect\string\immediate\write\lthtmlwrite{#1}}}%
+\newcommand\lthtmlhboxmathA{\adjustnormalsize\setbox\sizebox=\hbox\bgroup}%
+\newcommand\lthtmlvboxmathA{\adjustnormalsize\setbox\sizebox=\vbox\bgroup%
+ \let\ifinner=\iffalse }%
+\newcommand\lthtmlboxmathZ{\@next\next\@currlist{}{\def\next{\voidb@x}}%
+ \expandafter\box\next\egroup}%
+\newcommand\lthtmlmathtype[1]{\def\lthtmlmathenv{#1}}%
+\newcommand\lthtmllogmath{\lthtmltypeout{l2hSize %
+:\lthtmlmathenv:\the\ht\sizebox::\the\dp\sizebox::\the\wd\sizebox.\preveqno}}%
+\newcommand\lthtmlfigureA[1]{\let\@savefreelist\@freelist
+       \lthtmlmathtype{#1}\lthtmlvboxmathA}%
+\newcommand\lthtmlfigureZ{\lthtmlboxmathZ\lthtmllogmath\copy\sizebox
+       \global\let\@freelist\@savefreelist}%
+\newcommand\lthtmldisplayA[1]{\lthtmlmathtype{#1}\lthtmlvboxmathA}%
+\newcommand\lthtmldisplayB[1]{\edef\preveqno{(\theequation)}%
+  \lthtmldisplayA{#1}\let\@eqnnum\relax}%
+\newcommand\lthtmldisplayZ{\lthtmlboxmathZ\lthtmllogmath\lthtmlsetmath}%
+\newcommand\lthtmlinlinemathA[1]{\lthtmlmathtype{#1}\lthtmlhboxmathA  \vrule height1.5ex width0pt }%
+\newcommand\lthtmlinlinemathZ{\egroup\expandafter\ifdim\dp\sizebox>0pt %
+  \expandafter\centerinlinemath\fi\lthtmllogmath\lthtmlsetmath}
+\def\lthtmlsetmath{\hbox{\vrule width.5pt\vtop{\vbox{%
+  \kern.5pt\kern1.25 pt\hbox{\hglue.5pt\copy\sizebox\hglue1.25 pt}\kern.5pt%
+  \ifdim\dp\sizebox>0pt\kern1.25 pt\fi}%
+  \ifdim\hsize>\wd\sizebox \hrule depth1pt\fi}}}
+\def\centerinlinemath{\dimen1=\ht\sizebox
+  \ifdim\dimen1<\dp\sizebox \ht\sizebox=\dp\sizebox
+  \else \dp\sizebox=\ht\sizebox \fi}
+
+\def\lthtmlcheckvsize{\ifdim\ht\sizebox<\vsize\expandafter\vfill
+  \else\expandafter\vss\fi}%
+\makeatletter
+
+
+\begin{document}
+\pagestyle{empty}\thispagestyle{empty}%
+\lthtmltypeout{latex2htmlLength hsize=\the\hsize}%
+\lthtmltypeout{latex2htmlLength vsize=\the\vsize}%
+\lthtmltypeout{latex2htmlLength hoffset=\the\hoffset}%
+\lthtmltypeout{latex2htmlLength voffset=\the\voffset}%
+\lthtmltypeout{latex2htmlLength topmargin=\the\topmargin}%
+\lthtmltypeout{latex2htmlLength topskip=\the\topskip}%
+\lthtmltypeout{latex2htmlLength headheight=\the\headheight}%
+\lthtmltypeout{latex2htmlLength headsep=\the\headsep}%
+\lthtmltypeout{latex2htmlLength parskip=\the\parskip}%
+\lthtmltypeout{latex2htmlLength oddsidemargin=\the\oddsidemargin}%
+\makeatletter
+\if@twoside\lthtmltypeout{latex2htmlLength evensidemargin=\the\evensidemargin}%
+\else\lthtmltypeout{latex2htmlLength evensidemargin=\the\oddsidemargin}\fi%
+\makeatother
+\stepcounter{section}
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf *grobner$-$debug*}
+%
+
+
+\settowidth {\typelen}{\em VARIABLE\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf *buchberger$-$merge$-$pairs*}
+%
+
+
+\settowidth {\typelen}{\em VARIABLE\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf *gebauer$-$moeller$-$merge$-$pairs*}
+%
+
+
+\settowidth {\typelen}{\em VARIABLE\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf *grobner$-$function*}
+%
+
+
+\settowidth {\typelen}{\em VARIABLE\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf select$-$grobner$-$algorithm}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf grobner}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf debug$-$cgb}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf spoly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf grobner$-$primitive$-$part}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf grobner$-$content}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf normal$-$form}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf buchberger}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+{\newpage\clearpage
+\lthtmlinlinemathA{tex2html_wrap_inline22131}%
+$\textstyle\parbox{\pboxargslen}{\em f pred start top$-$reduction$-$only ring {\sf \&aux} (s (1$-$\space (length f))) b m \/}$%
+\lthtmlinlinemathZ
+\hfill\lthtmlcheckvsize\clearpage}
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf grobner$-$op}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf buchberger$-$sort$-$pairs}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf mock$-$spoly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf buchberger$-$merge$-$pairs$-$use$-$mock$-$spoly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf buchberger$-$merge$-$pairs$-$smallest$-$lcm}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf buchberger$-$merge$-$pairs$-$use$-$smallest$-$degree}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf buchberger$-$merge$-$pairs$-$use$-$smallest$-$length}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf buchberger$-$merge$-$pairs$-$use$-$smallest$-$coefficient$-$length}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf buchberger$-$set$-$pair$-$heuristic}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf criterion$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf criterion$-$2}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf normalize$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf normalize$-$basis}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf reduction}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf reduced$-$grobner}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$depends$-$p}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf term$-$depends$-$p}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$depends$-$p}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ring$-$intersection}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf elimination$-$ideal}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ideal$-$intersection}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$contract}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$lcm}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf grobner$-$gcd}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf grobner$-$equal}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf grobner$-$subsetp}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf grobner$-$member}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ideal$-$equal}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ideal$-$subsetp}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ideal$-$member}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ideal$-$saturation$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf add$-$variables}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf extend$-$polynomials}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf saturation$-$extension}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf polysaturation$-$extension}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf saturation$-$extension$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ideal$-$polysaturation$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ideal$-$saturation}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+{\newpage\clearpage
+\lthtmlinlinemathA{tex2html_wrap_inline22277}%
+$\textstyle\parbox{\pboxargslen}{\em f g pred start top$-$reduction$-$only ring {\sf \&aux} (k (length g)) (pred (elimination$-$order k :primary$-$order \#'lex$>$\space :secondary$-$order pred)) \/}$%
+\lthtmlinlinemathZ
+\hfill\lthtmlcheckvsize\clearpage}
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ideal$-$polysaturation}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf buchberger$-$criterion}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf grobner$-$test}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf minimization}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf add$-$minimized}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colon$-$ideal}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colon$-$ideal$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf pseudo$-$divide}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf gebauer$-$moeller}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf update}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf gebauer$-$moeller$-$merge$-$pairs$-$use$-$mock$-$spoly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf gebauer$-$moeller$-$merge$-$pairs$-$smallest$-$lcm}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$degree}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$length}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf gebauer$-$moeller$-$merge$-$pairs$-$use$-$smallest$-$coefficient$-$length}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf gebauer$-$moeller$-$set$-$pair$-$heuristic}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf spoly$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf spoly$-$with$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf normal$-$form$-$with$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf buchberger$-$with$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+{\newpage\clearpage
+\lthtmlinlinemathA{tex2html_wrap_inline22388}%
+$\textstyle\parbox{\pboxargslen}{\em f$-$no$-$sugar pred start top$-$reduction$-$only ring {\sf \&aux} (s (1$-$\space (length f$-$no$-$sugar))) b m f \/}$%
+\lthtmlinlinemathZ
+\hfill\lthtmlcheckvsize\clearpage}
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf buchberger$-$with$-$sugar$-$merge$-$pairs}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+{\newpage\clearpage
+\lthtmlinlinemathA{tex2html_wrap_inline22395}%
+$\textstyle\parbox{\pboxargslen}{\em b c g m pred ring \/}$%
+\lthtmlinlinemathZ
+\hfill\lthtmlcheckvsize\clearpage}
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf buchberger$-$with$-$sugar$-$sort$-$pairs}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+{\newpage\clearpage
+\lthtmlinlinemathA{tex2html_wrap_inline22401}%
+$\textstyle\parbox{\pboxargslen}{\em c g m pred ring \/}$%
+\lthtmlinlinemathZ
+\hfill\lthtmlcheckvsize\clearpage}
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf criterion$-$1$-$with$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf criterion$-$2$-$with$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf gebauer$-$moeller$-$with$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf update$-$with$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf gebauer$-$moeller$-$with$-$sugar$-$merge$-$pairs}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf grobner$-$primitive$-$part$-$with$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{section}
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$normal$-$form}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$grobner}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$elimination$-$ideal}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$ideal$-$intersection}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$poly$-$lcm}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$ideal$-$saturation$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$ideal$-$polysaturation$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$ideal$-$saturation}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$ideal$-$polysaturation}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$colon$-$ideal}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$read$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$rational$-$to$-$integer}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf read$-$vars}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{section}
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf *colored$-$poly$-$debug*}
+%
+
+
+\settowidth {\typelen}{\em VARIABLE\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf debug$-$cgb}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf make$-$colored$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf make$-$colored$-$poly$-$list}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf color$-$poly$-$list}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf color$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colored$-$poly$-$to$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colored$-$poly$-$print}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colored$-$poly$-$print$-$list}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf determine}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf determine$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf determine$-$white$-$term}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf cond$-$system$-$print}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf cond$-$print}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf add$-$pairs}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf cond$-$part}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf cond$-$hm}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf delete$-$green$-$polys}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf grobner$-$system}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf reorder$-$pairs}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colored$-$criterion$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colored$-$criterion$-$2}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf cond$-$normal$-$form}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf cond$-$spoly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf cond$-$lm}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf cond$-$lc}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colored$-$term$-$times$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colored$-$scalar$-$times$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colored$-$term*}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf color*}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf color+}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf color$-$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colored$-$poly+}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colored$-$poly$-$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colored$-$term$-$uminus}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colored$-$minus$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$grobner$-$system}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$cond}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$cover}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf saturate$-$cover}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf saturate$-$cond}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf string$-$determine}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf tidy$-$grobner$-$system}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf tidy$-$pair}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf tidy$-$cond}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf colored$-$reduction}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf green$-$reduce$-$colored$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf green$-$reduce$-$colored$-$list}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf cond$-$system$-$green$-$reduce}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf parse$-$to$-$colored$-$poly$-$list}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf red$-$reduction}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{section}
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ring}
+%
+
+
+\settowidth {\typelen}{\em STRUCTURE\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf *ring$-$of$-$integers*}
+%
+
+
+\settowidth {\typelen}{\em VARIABLE\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf *field$-$of$-$rationals*}
+%
+
+
+\settowidth {\typelen}{\em VARIABLE\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf field$-$modulo$-$prime}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf *coefficient$-$ring*}
+%
+
+
+\settowidth {\typelen}{\em VARIABLE\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{section}
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf divide}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$exact$-$divide}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{section}
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$scalar$-$composition}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$composition}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$dynamic$-$power}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$scalar$-$evaluate}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$evaluate}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf factorial}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$scalar$-$diff}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$diff}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf standard$-$vector}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf scalar$-$partial}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf partial}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf determinant}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf minor}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf drop$-$row}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf drop$-$column}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf drop$-$elt}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf matrix$-$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf scalar$-$times$-$matrix}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$times$-$matrix}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf term$-$times$-$matrix}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$list$-$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf scalar$-$times$-$poly$-$list}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$times$-$poly$-$list}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf term$-$times$-$poly$-$list}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf characteristic$-$combination}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf characteristic$-$combination$-$poly$-$list}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf characteristic$-$matrix}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf characteristic$-$polynomial}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf identity$-$matrix}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf print$-$matrix}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf jacobi$-$matrix}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf jacobian}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{section}
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf *prover$-$order*}
+%
+
+
+\settowidth {\typelen}{\em VARIABLE\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf csym}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf real$-$identical$-$points}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf identical$-$points}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf perpendicular}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf parallel}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf collinear}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf equidistant}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf euclidean$-$distance}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf midpoint}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf translate$-$statements}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf translate$-$assumptions}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf translate$-$conclusions}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf translate$-$theorem}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf prove$-$theorem}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{section}
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf lex$>$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+{\newpage\clearpage
+\lthtmlinlinemathA{tex2html_wrap_inline22868}%
+$\textstyle\parbox{\pboxargslen}{\em p q {\sf \&optional} (start 0) (end (length p)) \/}$%
+\lthtmlinlinemathZ
+\hfill\lthtmlcheckvsize\clearpage}
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf total$-$degree}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+{\newpage\clearpage
+\lthtmlinlinemathA{tex2html_wrap_inline22871}%
+$\textstyle\parbox{\pboxargslen}{\em m {\sf \&optional} (start 0) (end (length m)) \/}$%
+\lthtmlinlinemathZ
+\hfill\lthtmlcheckvsize\clearpage}
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf grlex$>$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf grevlex$>$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf revlex$>$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf invlex$>$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf elimination$-$order}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf elimination$-$order$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{section}
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf scalar$-$times$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf term$-$times$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$times$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf minus$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf sort$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly+}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly*}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$op}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$expt}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$mexpt}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$constant$-$p}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$extend}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$extend$-$end}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$zerop}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf lt}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf lm}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf lc}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{section}
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf parse}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf alist$-$form}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf alist$-$form$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf powers}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf parse$-$to$-$alist}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf parse$-$string$-$to$-$alist}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf parse$-$to$-$sorted$-$alist}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf parse$-$string$-$to$-$sorted$-$alist}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf sort$-$poly$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf sort$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$eval$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$eval}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$basis}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf convert$-$number}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf \$poly+}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf \$poly$-$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf \$minus$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf \$poly*}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf \$poly/}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf \$poly$-$expt}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{section}
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf makelist$-$1}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf makelist}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf sum}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf list$-$of}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf list$-$of$-$1}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf union$-$of}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf union$-$of$-$1}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf set$-$of}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf set$-$of$-$1}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf select}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom/}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom*}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf nmonom*}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$divides$-$p}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$divisible$-$by$-$p}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$rel$-$prime}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$equal}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$lcm}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$gcd}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$gcd}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$pseudo$-$divide}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$pseudo$-$remainder}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf mdeg}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf lcoeff}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf lrest}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf lpart}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$primitive$-$part}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$content}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$with$-$sugar$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$with$-$sugar$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$with$-$sugar$-$tail}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf (setf poly$-$with$-$sugar$-$poly)}
+%
+
+
+\settowidth {\typelen}{\em SETF MAPPING\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf (setf poly$-$with$-$sugar$-$sugar)}
+%
+
+
+\settowidth {\typelen}{\em SETF MAPPING\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf (setf poly$-$with$-$sugar$-$tail)}
+%
+
+
+\settowidth {\typelen}{\em SETF MAPPING\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf coefficient$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf term$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$add$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf scalar$-$times$-$poly$-$with$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf term$-$times$-$poly$-$with$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$times$-$poly$-$with$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf minus$-$poly$-$with$-$sugar}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$with$-$sugar+}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$with$-$sugar$-$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$with$-$sugar$-$op}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$with$-$sugar$-$nreverse}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$with$-$sugar$-$append}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$with$-$sugar$-$zerop}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$with$-$sugar$-$lm}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$with$-$sugar$-$lc}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$with$-$sugar$-$lt}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$print}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$print$-$1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$print$-$2}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf print$-$term}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf print$-$monom}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf num}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf denom}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf rat$-$simplify$-$2}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf rat$-$simplify}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf rat+}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf rat$-$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf rat*}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf rat/}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf scalar$-$times$-$rat}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf scalar$-$div$-$rat}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf rat$-$zerop}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf rat$-$uminus}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf rat$-$expt}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf rat$-$constant}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf rat$-$to$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly+}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly$-$}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly$-$uminus}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly*}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf scalar$-$times$-$ratpoly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf rat$-$times$-$ratpoly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly$-$divide}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly$-$remainder}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly$-$gcd}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly$-$diff}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly$-$square$-$free}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly$-$normalize}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly$-$resultant}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf deg}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf lead}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly$-$discriminant}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly$-$print}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$to$-$ratpoly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$to$-$poly1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly1$-$to$-$ratpoly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly$-$to$-$poly1}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly1$-$to$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf ratpoly$-$to$-$poly}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf poly$-$resultant}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf term*}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf term/}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf monom$-$times$-$term}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf term$-$divides$-$p}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf term$-$monom}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf term$-$coefficient}
+%
+
+
+\settowidth {\typelen}{\em MACRO\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf (setf term$-$monom)}
+%
+
+
+\settowidth {\typelen}{\em SETF MAPPING\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf (setf term$-$coefficient)}
+%
+
+
+\settowidth {\typelen}{\em SETF MAPPING\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\stepcounter{paragraph}
+
+\settowidth {\formnamelen}{\sf xgcd}
+%
+
+
+\settowidth {\typelen}{\em FUNCTION\/}
+%
+
+
+\setlength {\pboxargslen}{\linewidth}
+%
+
+
+\addtolength {\pboxargslen}{-1\formnamelen}
+%
+
+
+\addtolength {\pboxargslen}{-1.5\typelen}
+%
+
+\appendix
+\stepcounter{section}
+
+\end{document}
Index: /trunk/latex-doc/manual/index.html
===================================================================
--- /trunk/latex-doc/manual/index.html	(revision 8)
+++ /trunk/latex-doc/manual/index.html	(revision 8)
@@ -0,0 +1,2216 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>CGBLisp User Guide and Manual</TITLE>
+<META NAME="description" CONTENT="CGBLisp User Guide and Manual">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node1.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html2"
+ HREF="node1.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif_gr.gif"> 
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif_gr.gif"> 
+<A NAME="tex2html1"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html3"
+ HREF="node1.html">Contents</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<H1 ALIGN="CENTER">CGBLisp User Guide and Manual</H1>
+<P ALIGN="CENTER"><STRONG>Marek Rychlik</STRONG></P>
+<P ALIGN="LEFT"></P>
+<BR><HR>
+<!--Table of Child-Links-->
+<A NAME="CHILD_LINKS">&#160;</A>
+<UL>
+<LI><A NAME="tex2html4"
+ HREF="node1.html#SECTION00010000000000000000">
+Contents</A>
+<LI><A NAME="tex2html5"
+ HREF="node2.html#SECTION00020000000000000000">
+The Gr&#246;bner Basis package</A>
+<UL>
+<LI><A NAME="tex2html6"
+ HREF="node2.html#SECTION00020010000000000000">
+<I>*grobner<MATH CLASS="INLINE">
+-
+</MATH>debug*</I></A>
+<LI><A NAME="tex2html7"
+ HREF="node2.html#SECTION00020020000000000000">
+<I>*buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs*</I></A>
+<LI><A NAME="tex2html8"
+ HREF="node2.html#SECTION00020030000000000000">
+<I>*gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs*</I></A>
+<LI><A NAME="tex2html9"
+ HREF="node2.html#SECTION00020040000000000000">
+<I>*grobner<MATH CLASS="INLINE">
+-
+</MATH>function*</I></A>
+<LI><A NAME="tex2html10"
+ HREF="node2.html#SECTION00020050000000000000">
+<I>select<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>algorithm</I></A>
+<LI><A NAME="tex2html11"
+ HREF="node2.html#SECTION00020060000000000000">
+<I>grobner</I></A>
+<LI><A NAME="tex2html12"
+ HREF="node2.html#SECTION00020070000000000000">
+<I>debug<MATH CLASS="INLINE">
+-
+</MATH>cgb</I></A>
+<LI><A NAME="tex2html13"
+ HREF="node2.html#SECTION00020080000000000000">
+<I>spoly</I></A>
+<LI><A NAME="tex2html14"
+ HREF="node2.html#SECTION00020090000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+<LI><A NAME="tex2html15"
+ HREF="node2.html#SECTION000200100000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>content</I></A>
+<LI><A NAME="tex2html16"
+ HREF="node2.html#SECTION000200110000000000000">
+<I>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html17"
+ HREF="node2.html#SECTION000200120000000000000">
+<I>buchberger</I></A>
+<LI><A NAME="tex2html18"
+ HREF="node2.html#SECTION000200130000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+<LI><A NAME="tex2html19"
+ HREF="node2.html#SECTION000200140000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>sort<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html20"
+ HREF="node2.html#SECTION000200150000000000000">
+<I>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html21"
+ HREF="node2.html#SECTION000200160000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html22"
+ HREF="node2.html#SECTION000200170000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html23"
+ HREF="node2.html#SECTION000200180000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+<LI><A NAME="tex2html24"
+ HREF="node2.html#SECTION000200190000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html25"
+ HREF="node2.html#SECTION000200200000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>coefficient<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html26"
+ HREF="node2.html#SECTION000200210000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>set<MATH CLASS="INLINE">
+-
+</MATH>pair<MATH CLASS="INLINE">
+-
+</MATH>heuristic</I></A>
+<LI><A NAME="tex2html27"
+ HREF="node2.html#SECTION000200220000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html28"
+ HREF="node2.html#SECTION000200230000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html29"
+ HREF="node2.html#SECTION000200240000000000000">
+<I>normalize<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html30"
+ HREF="node2.html#SECTION000200250000000000000">
+<I>normalize<MATH CLASS="INLINE">
+-
+</MATH>basis</I></A>
+<LI><A NAME="tex2html31"
+ HREF="node2.html#SECTION000200260000000000000">
+<I>reduction</I></A>
+<LI><A NAME="tex2html32"
+ HREF="node2.html#SECTION000200270000000000000">
+<I>reduced<MATH CLASS="INLINE">
+-
+</MATH>grobner</I></A>
+<LI><A NAME="tex2html33"
+ HREF="node2.html#SECTION000200280000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html34"
+ HREF="node2.html#SECTION000200290000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html35"
+ HREF="node2.html#SECTION000200300000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html36"
+ HREF="node2.html#SECTION000200310000000000000">
+<I>ring<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+<LI><A NAME="tex2html37"
+ HREF="node2.html#SECTION000200320000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html38"
+ HREF="node2.html#SECTION000200330000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+<LI><A NAME="tex2html39"
+ HREF="node2.html#SECTION000200340000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>contract</I></A>
+<LI><A NAME="tex2html40"
+ HREF="node2.html#SECTION000200350000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html41"
+ HREF="node2.html#SECTION000200360000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html42"
+ HREF="node2.html#SECTION000200370000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+<LI><A NAME="tex2html43"
+ HREF="node2.html#SECTION000200380000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>subsetp</I></A>
+<LI><A NAME="tex2html44"
+ HREF="node2.html#SECTION000200390000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>member</I></A>
+<LI><A NAME="tex2html45"
+ HREF="node2.html#SECTION000200400000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+<LI><A NAME="tex2html46"
+ HREF="node2.html#SECTION000200410000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>subsetp</I></A>
+<LI><A NAME="tex2html47"
+ HREF="node2.html#SECTION000200420000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>member</I></A>
+<LI><A NAME="tex2html48"
+ HREF="node2.html#SECTION000200430000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html49"
+ HREF="node2.html#SECTION000200440000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>variables</I></A>
+<LI><A NAME="tex2html50"
+ HREF="node2.html#SECTION000200450000000000000">
+<I>extend<MATH CLASS="INLINE">
+-
+</MATH>polynomials</I></A>
+<LI><A NAME="tex2html51"
+ HREF="node2.html#SECTION000200460000000000000">
+<I>saturation<MATH CLASS="INLINE">
+-
+</MATH>extension</I></A>
+<LI><A NAME="tex2html52"
+ HREF="node2.html#SECTION000200470000000000000">
+<I>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>extension</I></A>
+<LI><A NAME="tex2html53"
+ HREF="node2.html#SECTION000200480000000000000">
+<I>saturation<MATH CLASS="INLINE">
+-
+</MATH>extension<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html54"
+ HREF="node2.html#SECTION000200490000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html55"
+ HREF="node2.html#SECTION000200500000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation</I></A>
+<LI><A NAME="tex2html56"
+ HREF="node2.html#SECTION000200510000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation</I></A>
+<LI><A NAME="tex2html57"
+ HREF="node2.html#SECTION000200520000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>criterion</I></A>
+<LI><A NAME="tex2html58"
+ HREF="node2.html#SECTION000200530000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>test</I></A>
+<LI><A NAME="tex2html59"
+ HREF="node2.html#SECTION000200540000000000000">
+<I>minimization</I></A>
+<LI><A NAME="tex2html60"
+ HREF="node2.html#SECTION000200550000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>minimized</I></A>
+<LI><A NAME="tex2html61"
+ HREF="node2.html#SECTION000200560000000000000">
+<I>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html62"
+ HREF="node2.html#SECTION000200570000000000000">
+<I>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html63"
+ HREF="node2.html#SECTION000200580000000000000">
+<I>pseudo<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+<LI><A NAME="tex2html64"
+ HREF="node2.html#SECTION000200590000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller</I></A>
+<LI><A NAME="tex2html65"
+ HREF="node2.html#SECTION000200600000000000000">
+<I>update</I></A>
+<LI><A NAME="tex2html66"
+ HREF="node2.html#SECTION000200610000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html67"
+ HREF="node2.html#SECTION000200620000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html68"
+ HREF="node2.html#SECTION000200630000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+<LI><A NAME="tex2html69"
+ HREF="node2.html#SECTION000200640000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html70"
+ HREF="node2.html#SECTION000200650000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>coefficient<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html71"
+ HREF="node2.html#SECTION000200660000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>set<MATH CLASS="INLINE">
+-
+</MATH>pair<MATH CLASS="INLINE">
+-
+</MATH>heuristic</I></A>
+<LI><A NAME="tex2html72"
+ HREF="node2.html#SECTION000200670000000000000">
+<I>spoly<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html73"
+ HREF="node2.html#SECTION000200680000000000000">
+<I>spoly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html74"
+ HREF="node2.html#SECTION000200690000000000000">
+<I>normal<MATH CLASS="INLINE">
+-
+</MATH>form<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html75"
+ HREF="node2.html#SECTION000200700000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html76"
+ HREF="node2.html#SECTION000200710000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html77"
+ HREF="node2.html#SECTION000200720000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sort<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html78"
+ HREF="node2.html#SECTION000200730000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>1<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html79"
+ HREF="node2.html#SECTION000200740000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>2<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html80"
+ HREF="node2.html#SECTION000200750000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html81"
+ HREF="node2.html#SECTION000200760000000000000">
+<I>update<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html82"
+ HREF="node2.html#SECTION000200770000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html83"
+ HREF="node2.html#SECTION000200780000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</UL>
+<LI><A NAME="tex2html84"
+ HREF="node3.html#SECTION00030000000000000000">
+The String Interface to the Gr&#246;bner Basis package</A>
+<UL>
+<LI><A NAME="tex2html85"
+ HREF="node3.html#SECTION00030010000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html86"
+ HREF="node3.html#SECTION00030020000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>grobner</I></A>
+<LI><A NAME="tex2html87"
+ HREF="node3.html#SECTION00030030000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>elimination<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html88"
+ HREF="node3.html#SECTION00030040000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+<LI><A NAME="tex2html89"
+ HREF="node3.html#SECTION00030050000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html90"
+ HREF="node3.html#SECTION00030060000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html91"
+ HREF="node3.html#SECTION00030070000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html92"
+ HREF="node3.html#SECTION00030080000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation</I></A>
+<LI><A NAME="tex2html93"
+ HREF="node3.html#SECTION00030090000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation</I></A>
+<LI><A NAME="tex2html94"
+ HREF="node3.html#SECTION000300100000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html95"
+ HREF="node3.html#SECTION000300110000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>read<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html96"
+ HREF="node3.html#SECTION000300120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>rational<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>integer</I></A>
+<LI><A NAME="tex2html97"
+ HREF="node3.html#SECTION000300130000000000000">
+<I>read<MATH CLASS="INLINE">
+-
+</MATH>vars</I></A>
+</UL>
+<LI><A NAME="tex2html98"
+ HREF="node4.html#SECTION00040000000000000000">
+The Comprehensive Gr&#246;bner basis package</A>
+<UL>
+<LI><A NAME="tex2html99"
+ HREF="node4.html#SECTION00040010000000000000">
+<I>*colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>debug*</I></A>
+<LI><A NAME="tex2html100"
+ HREF="node4.html#SECTION00040020000000000000">
+<I>debug<MATH CLASS="INLINE">
+-
+</MATH>cgb</I></A>
+<LI><A NAME="tex2html101"
+ HREF="node4.html#SECTION00040030000000000000">
+<I>make<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html102"
+ HREF="node4.html#SECTION00040040000000000000">
+<I>make<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html103"
+ HREF="node4.html#SECTION00040050000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html104"
+ HREF="node4.html#SECTION00040060000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html105"
+ HREF="node4.html#SECTION00040070000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html106"
+ HREF="node4.html#SECTION00040080000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html107"
+ HREF="node4.html#SECTION00040090000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html108"
+ HREF="node4.html#SECTION000400100000000000000">
+<I>determine</I></A>
+<LI><A NAME="tex2html109"
+ HREF="node4.html#SECTION000400110000000000000">
+<I>determine<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html110"
+ HREF="node4.html#SECTION000400120000000000000">
+<I>determine<MATH CLASS="INLINE">
+-
+</MATH>white<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+<LI><A NAME="tex2html111"
+ HREF="node4.html#SECTION000400130000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>system<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html112"
+ HREF="node4.html#SECTION000400140000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html113"
+ HREF="node4.html#SECTION000400150000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html114"
+ HREF="node4.html#SECTION000400160000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+<LI><A NAME="tex2html115"
+ HREF="node4.html#SECTION000400170000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>hm</I></A>
+<LI><A NAME="tex2html116"
+ HREF="node4.html#SECTION000400180000000000000">
+<I>delete<MATH CLASS="INLINE">
+-
+</MATH>green<MATH CLASS="INLINE">
+-
+</MATH>polys</I></A>
+<LI><A NAME="tex2html117"
+ HREF="node4.html#SECTION000400190000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+<LI><A NAME="tex2html118"
+ HREF="node4.html#SECTION000400200000000000000">
+<I>reorder<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html119"
+ HREF="node4.html#SECTION000400210000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>criterion<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html120"
+ HREF="node4.html#SECTION000400220000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>criterion<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html121"
+ HREF="node4.html#SECTION000400230000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html122"
+ HREF="node4.html#SECTION000400240000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html123"
+ HREF="node4.html#SECTION000400250000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>lm</I></A>
+<LI><A NAME="tex2html124"
+ HREF="node4.html#SECTION000400260000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>lc</I></A>
+<LI><A NAME="tex2html125"
+ HREF="node4.html#SECTION000400270000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html126"
+ HREF="node4.html#SECTION000400280000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html127"
+ HREF="node4.html#SECTION000400290000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term*</I></A>
+<LI><A NAME="tex2html128"
+ HREF="node4.html#SECTION000400300000000000000">
+<I>color*</I></A>
+<LI><A NAME="tex2html129"
+ HREF="node4.html#SECTION000400310000000000000">
+<I>color+</I></A>
+<LI><A NAME="tex2html130"
+ HREF="node4.html#SECTION000400320000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html131"
+ HREF="node4.html#SECTION000400330000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly+</I></A>
+<LI><A NAME="tex2html132"
+ HREF="node4.html#SECTION000400340000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html133"
+ HREF="node4.html#SECTION000400350000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+<LI><A NAME="tex2html134"
+ HREF="node4.html#SECTION000400360000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html135"
+ HREF="node4.html#SECTION000400370000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+<LI><A NAME="tex2html136"
+ HREF="node4.html#SECTION000400380000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+<LI><A NAME="tex2html137"
+ HREF="node4.html#SECTION000400390000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>cover</I></A>
+<LI><A NAME="tex2html138"
+ HREF="node4.html#SECTION000400400000000000000">
+<I>saturate<MATH CLASS="INLINE">
+-
+</MATH>cover</I></A>
+<LI><A NAME="tex2html139"
+ HREF="node4.html#SECTION000400410000000000000">
+<I>saturate<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+<LI><A NAME="tex2html140"
+ HREF="node4.html#SECTION000400420000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>determine</I></A>
+<LI><A NAME="tex2html141"
+ HREF="node4.html#SECTION000400430000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+<LI><A NAME="tex2html142"
+ HREF="node4.html#SECTION000400440000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>pair</I></A>
+<LI><A NAME="tex2html143"
+ HREF="node4.html#SECTION000400450000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+<LI><A NAME="tex2html144"
+ HREF="node4.html#SECTION000400460000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>reduction</I></A>
+<LI><A NAME="tex2html145"
+ HREF="node4.html#SECTION000400470000000000000">
+<I>green<MATH CLASS="INLINE">
+-
+</MATH>reduce<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html146"
+ HREF="node4.html#SECTION000400480000000000000">
+<I>green<MATH CLASS="INLINE">
+-
+</MATH>reduce<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html147"
+ HREF="node4.html#SECTION000400490000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>system<MATH CLASS="INLINE">
+-
+</MATH>green<MATH CLASS="INLINE">
+-
+</MATH>reduce</I></A>
+<LI><A NAME="tex2html148"
+ HREF="node4.html#SECTION000400500000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html149"
+ HREF="node4.html#SECTION000400510000000000000">
+<I>red<MATH CLASS="INLINE">
+-
+</MATH>reduction</I></A>
+</UL>
+<LI><A NAME="tex2html150"
+ HREF="node5.html#SECTION00050000000000000000">
+The Coefficient Ring package</A>
+<UL>
+<LI><A NAME="tex2html151"
+ HREF="node5.html#SECTION00050010000000000000">
+<I>ring</I></A>
+<LI><A NAME="tex2html152"
+ HREF="node5.html#SECTION00050020000000000000">
+<I>*ring<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>integers*</I></A>
+<LI><A NAME="tex2html153"
+ HREF="node5.html#SECTION00050030000000000000">
+<I>*field<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>rationals*</I></A>
+<LI><A NAME="tex2html154"
+ HREF="node5.html#SECTION00050040000000000000">
+<I>field<MATH CLASS="INLINE">
+-
+</MATH>modulo<MATH CLASS="INLINE">
+-
+</MATH>prime</I></A>
+<LI><A NAME="tex2html155"
+ HREF="node5.html#SECTION00050050000000000000">
+<I>*coefficient<MATH CLASS="INLINE">
+-
+</MATH>ring*</I></A>
+</UL>
+<LI><A NAME="tex2html156"
+ HREF="node6.html#SECTION00060000000000000000">
+The Division Package</A>
+<UL>
+<LI><A NAME="tex2html157"
+ HREF="node6.html#SECTION00060010000000000000">
+<I>divide</I></A>
+<LI><A NAME="tex2html158"
+ HREF="node6.html#SECTION00060020000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>exact<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+</UL>
+<LI><A NAME="tex2html159"
+ HREF="node7.html#SECTION00070000000000000000">
+The Dynamical Systems package</A>
+<UL>
+<LI><A NAME="tex2html160"
+ HREF="node7.html#SECTION00070010000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>composition</I></A>
+<LI><A NAME="tex2html161"
+ HREF="node7.html#SECTION00070020000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>composition</I></A>
+<LI><A NAME="tex2html162"
+ HREF="node7.html#SECTION00070030000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>dynamic<MATH CLASS="INLINE">
+-
+</MATH>power</I></A>
+<LI><A NAME="tex2html163"
+ HREF="node7.html#SECTION00070040000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>evaluate</I></A>
+<LI><A NAME="tex2html164"
+ HREF="node7.html#SECTION00070050000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>evaluate</I></A>
+<LI><A NAME="tex2html165"
+ HREF="node7.html#SECTION00070060000000000000">
+<I>factorial</I></A>
+<LI><A NAME="tex2html166"
+ HREF="node7.html#SECTION00070070000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+<LI><A NAME="tex2html167"
+ HREF="node7.html#SECTION00070080000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+<LI><A NAME="tex2html168"
+ HREF="node7.html#SECTION00070090000000000000">
+<I>standard<MATH CLASS="INLINE">
+-
+</MATH>vector</I></A>
+<LI><A NAME="tex2html169"
+ HREF="node7.html#SECTION000700100000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>partial</I></A>
+<LI><A NAME="tex2html170"
+ HREF="node7.html#SECTION000700110000000000000">
+<I>partial</I></A>
+<LI><A NAME="tex2html171"
+ HREF="node7.html#SECTION000700120000000000000">
+<I>determinant</I></A>
+<LI><A NAME="tex2html172"
+ HREF="node7.html#SECTION000700130000000000000">
+<I>minor</I></A>
+<LI><A NAME="tex2html173"
+ HREF="node7.html#SECTION000700140000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>row</I></A>
+<LI><A NAME="tex2html174"
+ HREF="node7.html#SECTION000700150000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>column</I></A>
+<LI><A NAME="tex2html175"
+ HREF="node7.html#SECTION000700160000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>elt</I></A>
+<LI><A NAME="tex2html176"
+ HREF="node7.html#SECTION000700170000000000000">
+<I>matrix<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html177"
+ HREF="node7.html#SECTION000700180000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html178"
+ HREF="node7.html#SECTION000700190000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html179"
+ HREF="node7.html#SECTION000700200000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html180"
+ HREF="node7.html#SECTION000700210000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>list<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html181"
+ HREF="node7.html#SECTION000700220000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html182"
+ HREF="node7.html#SECTION000700230000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html183"
+ HREF="node7.html#SECTION000700240000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html184"
+ HREF="node7.html#SECTION000700250000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>combination</I></A>
+<LI><A NAME="tex2html185"
+ HREF="node7.html#SECTION000700260000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>combination<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html186"
+ HREF="node7.html#SECTION000700270000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html187"
+ HREF="node7.html#SECTION000700280000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>polynomial</I></A>
+<LI><A NAME="tex2html188"
+ HREF="node7.html#SECTION000700290000000000000">
+<I>identity<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html189"
+ HREF="node7.html#SECTION000700300000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html190"
+ HREF="node7.html#SECTION000700310000000000000">
+<I>jacobi<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html191"
+ HREF="node7.html#SECTION000700320000000000000">
+<I>jacobian</I></A>
+</UL>
+<LI><A NAME="tex2html192"
+ HREF="node8.html#SECTION00080000000000000000">
+The Geometric Theorem Prover package</A>
+<UL>
+<LI><A NAME="tex2html193"
+ HREF="node8.html#SECTION00080010000000000000">
+<I>*prover<MATH CLASS="INLINE">
+-
+</MATH>order*</I></A>
+<LI><A NAME="tex2html194"
+ HREF="node8.html#SECTION00080020000000000000">
+<I>csym</I></A>
+<LI><A NAME="tex2html195"
+ HREF="node8.html#SECTION00080030000000000000">
+<I>real<MATH CLASS="INLINE">
+-
+</MATH>identical<MATH CLASS="INLINE">
+-
+</MATH>points</I></A>
+<LI><A NAME="tex2html196"
+ HREF="node8.html#SECTION00080040000000000000">
+<I>identical<MATH CLASS="INLINE">
+-
+</MATH>points</I></A>
+<LI><A NAME="tex2html197"
+ HREF="node8.html#SECTION00080050000000000000">
+<I>perpendicular</I></A>
+<LI><A NAME="tex2html198"
+ HREF="node8.html#SECTION00080060000000000000">
+<I>parallel</I></A>
+<LI><A NAME="tex2html199"
+ HREF="node8.html#SECTION00080070000000000000">
+<I>collinear</I></A>
+<LI><A NAME="tex2html200"
+ HREF="node8.html#SECTION00080080000000000000">
+<I>equidistant</I></A>
+<LI><A NAME="tex2html201"
+ HREF="node8.html#SECTION00080090000000000000">
+<I>euclidean<MATH CLASS="INLINE">
+-
+</MATH>distance</I></A>
+<LI><A NAME="tex2html202"
+ HREF="node8.html#SECTION000800100000000000000">
+<I>midpoint</I></A>
+<LI><A NAME="tex2html203"
+ HREF="node8.html#SECTION000800110000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>statements</I></A>
+<LI><A NAME="tex2html204"
+ HREF="node8.html#SECTION000800120000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>assumptions</I></A>
+<LI><A NAME="tex2html205"
+ HREF="node8.html#SECTION000800130000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>conclusions</I></A>
+<LI><A NAME="tex2html206"
+ HREF="node8.html#SECTION000800140000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>theorem</I></A>
+<LI><A NAME="tex2html207"
+ HREF="node8.html#SECTION000800150000000000000">
+<I>prove<MATH CLASS="INLINE">
+-
+</MATH>theorem</I></A>
+</UL>
+<LI><A NAME="tex2html208"
+ HREF="node9.html#SECTION00090000000000000000">
+The Monomial Order Package</A>
+<UL>
+<LI><A NAME="tex2html209"
+ HREF="node9.html#SECTION00090010000000000000">
+<I>lex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html210"
+ HREF="node9.html#SECTION00090020000000000000">
+<I>total<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+<LI><A NAME="tex2html211"
+ HREF="node9.html#SECTION00090030000000000000">
+<I>grlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html212"
+ HREF="node9.html#SECTION00090040000000000000">
+<I>grevlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html213"
+ HREF="node9.html#SECTION00090050000000000000">
+<I>revlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html214"
+ HREF="node9.html#SECTION00090060000000000000">
+<I>invlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html215"
+ HREF="node9.html#SECTION00090070000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>order</I></A>
+<LI><A NAME="tex2html216"
+ HREF="node9.html#SECTION00090080000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>order<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</UL>
+<LI><A NAME="tex2html217"
+ HREF="node10.html#SECTION000100000000000000000">
+The Polynomial Package</A>
+<UL>
+<LI><A NAME="tex2html218"
+ HREF="node10.html#SECTION000100010000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html219"
+ HREF="node10.html#SECTION000100020000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html220"
+ HREF="node10.html#SECTION000100030000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html221"
+ HREF="node10.html#SECTION000100040000000000000">
+<I>minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html222"
+ HREF="node10.html#SECTION000100050000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html223"
+ HREF="node10.html#SECTION000100060000000000000">
+<I>poly+</I></A>
+<LI><A NAME="tex2html224"
+ HREF="node10.html#SECTION000100070000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html225"
+ HREF="node10.html#SECTION000100080000000000000">
+<I>poly*</I></A>
+<LI><A NAME="tex2html226"
+ HREF="node10.html#SECTION000100090000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+<LI><A NAME="tex2html227"
+ HREF="node10.html#SECTION0001000100000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+<LI><A NAME="tex2html228"
+ HREF="node10.html#SECTION0001000110000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>mexpt</I></A>
+<LI><A NAME="tex2html229"
+ HREF="node10.html#SECTION0001000120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>constant<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html230"
+ HREF="node10.html#SECTION0001000130000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>extend</I></A>
+<LI><A NAME="tex2html231"
+ HREF="node10.html#SECTION0001000140000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>extend<MATH CLASS="INLINE">
+-
+</MATH>end</I></A>
+<LI><A NAME="tex2html232"
+ HREF="node10.html#SECTION0001000150000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+<LI><A NAME="tex2html233"
+ HREF="node10.html#SECTION0001000160000000000000">
+<I>lt</I></A>
+<LI><A NAME="tex2html234"
+ HREF="node10.html#SECTION0001000170000000000000">
+<I>lm</I></A>
+<LI><A NAME="tex2html235"
+ HREF="node10.html#SECTION0001000180000000000000">
+<I>lc</I></A>
+</UL>
+<LI><A NAME="tex2html236"
+ HREF="node11.html#SECTION000110000000000000000">
+The Parser Package</A>
+<UL>
+<LI><A NAME="tex2html237"
+ HREF="node11.html#SECTION000110010000000000000">
+<I>parse</I></A>
+<LI><A NAME="tex2html238"
+ HREF="node11.html#SECTION000110020000000000000">
+<I>alist<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html239"
+ HREF="node11.html#SECTION000110030000000000000">
+<I>alist<MATH CLASS="INLINE">
+-
+</MATH>form<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html240"
+ HREF="node11.html#SECTION000110040000000000000">
+<I>powers</I></A>
+<LI><A NAME="tex2html241"
+ HREF="node11.html#SECTION000110050000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html242"
+ HREF="node11.html#SECTION000110060000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>string<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html243"
+ HREF="node11.html#SECTION000110070000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>sorted<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html244"
+ HREF="node11.html#SECTION000110080000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>string<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>sorted<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html245"
+ HREF="node11.html#SECTION000110090000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html246"
+ HREF="node11.html#SECTION0001100100000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html247"
+ HREF="node11.html#SECTION0001100110000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>eval<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html248"
+ HREF="node11.html#SECTION0001100120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>eval</I></A>
+<LI><A NAME="tex2html249"
+ HREF="node11.html#SECTION0001100130000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>basis</I></A>
+<LI><A NAME="tex2html250"
+ HREF="node11.html#SECTION0001100140000000000000">
+<I>convert<MATH CLASS="INLINE">
+-
+</MATH>number</I></A>
+<LI><A NAME="tex2html251"
+ HREF="node11.html#SECTION0001100150000000000000">
+<I>$poly+</I></A>
+<LI><A NAME="tex2html252"
+ HREF="node11.html#SECTION0001100160000000000000">
+<I>$poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html253"
+ HREF="node11.html#SECTION0001100170000000000000">
+<I>$minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html254"
+ HREF="node11.html#SECTION0001100180000000000000">
+<I>$poly*</I></A>
+<LI><A NAME="tex2html255"
+ HREF="node11.html#SECTION0001100190000000000000">
+<I>$poly/</I></A>
+<LI><A NAME="tex2html256"
+ HREF="node11.html#SECTION0001100200000000000000">
+<I>$poly<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+</UL>
+<LI><A NAME="tex2html257"
+ HREF="node12.html#SECTION000120000000000000000">
+Other packages</A>
+<UL>
+<LI><A NAME="tex2html258"
+ HREF="node12.html#SECTION000120010000000000000">
+<I>makelist<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html259"
+ HREF="node12.html#SECTION000120020000000000000">
+<I>makelist</I></A>
+<LI><A NAME="tex2html260"
+ HREF="node12.html#SECTION000120030000000000000">
+<I>sum</I></A>
+<LI><A NAME="tex2html261"
+ HREF="node12.html#SECTION000120040000000000000">
+<I>list<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+<LI><A NAME="tex2html262"
+ HREF="node12.html#SECTION000120050000000000000">
+<I>list<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html263"
+ HREF="node12.html#SECTION000120060000000000000">
+<I>union<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+<LI><A NAME="tex2html264"
+ HREF="node12.html#SECTION000120070000000000000">
+<I>union<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html265"
+ HREF="node12.html#SECTION000120080000000000000">
+<I>set<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+<LI><A NAME="tex2html266"
+ HREF="node12.html#SECTION000120090000000000000">
+<I>set<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html267"
+ HREF="node12.html#SECTION0001200100000000000000">
+<I>select</I></A>
+<LI><A NAME="tex2html268"
+ HREF="node12.html#SECTION0001200110000000000000">
+<I>monom/</I></A>
+<LI><A NAME="tex2html269"
+ HREF="node12.html#SECTION0001200120000000000000">
+<I>monom*</I></A>
+<LI><A NAME="tex2html270"
+ HREF="node12.html#SECTION0001200130000000000000">
+<I>nmonom*</I></A>
+<LI><A NAME="tex2html271"
+ HREF="node12.html#SECTION0001200140000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>divides<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html272"
+ HREF="node12.html#SECTION0001200150000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>divisible<MATH CLASS="INLINE">
+-
+</MATH>by<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html273"
+ HREF="node12.html#SECTION0001200160000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>rel<MATH CLASS="INLINE">
+-
+</MATH>prime</I></A>
+<LI><A NAME="tex2html274"
+ HREF="node12.html#SECTION0001200170000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+<LI><A NAME="tex2html275"
+ HREF="node12.html#SECTION0001200180000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html276"
+ HREF="node12.html#SECTION0001200190000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html277"
+ HREF="node12.html#SECTION0001200200000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html278"
+ HREF="node12.html#SECTION0001200210000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>pseudo<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+<LI><A NAME="tex2html279"
+ HREF="node12.html#SECTION0001200220000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>pseudo<MATH CLASS="INLINE">
+-
+</MATH>remainder</I></A>
+<LI><A NAME="tex2html280"
+ HREF="node12.html#SECTION0001200230000000000000">
+<I>mdeg</I></A>
+<LI><A NAME="tex2html281"
+ HREF="node12.html#SECTION0001200240000000000000">
+<I>lcoeff</I></A>
+<LI><A NAME="tex2html282"
+ HREF="node12.html#SECTION0001200250000000000000">
+<I>lrest</I></A>
+<LI><A NAME="tex2html283"
+ HREF="node12.html#SECTION0001200260000000000000">
+<I>lpart</I></A>
+<LI><A NAME="tex2html284"
+ HREF="node12.html#SECTION0001200270000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+<LI><A NAME="tex2html285"
+ HREF="node12.html#SECTION0001200280000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>content</I></A>
+<LI><A NAME="tex2html286"
+ HREF="node12.html#SECTION0001200290000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html287"
+ HREF="node12.html#SECTION0001200300000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html288"
+ HREF="node12.html#SECTION0001200310000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>tail</I></A>
+<LI><A NAME="tex2html289"
+ HREF="node12.html#SECTION0001200320000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>poly)</I></A>
+<LI><A NAME="tex2html290"
+ HREF="node12.html#SECTION0001200330000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sugar)</I></A>
+<LI><A NAME="tex2html291"
+ HREF="node12.html#SECTION0001200340000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>tail)</I></A>
+<LI><A NAME="tex2html292"
+ HREF="node12.html#SECTION0001200350000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html293"
+ HREF="node12.html#SECTION0001200360000000000000">
+<I>coefficient<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html294"
+ HREF="node12.html#SECTION0001200370000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html295"
+ HREF="node12.html#SECTION0001200380000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>add<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html296"
+ HREF="node12.html#SECTION0001200390000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html297"
+ HREF="node12.html#SECTION0001200400000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html298"
+ HREF="node12.html#SECTION0001200410000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html299"
+ HREF="node12.html#SECTION0001200420000000000000">
+<I>minus<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html300"
+ HREF="node12.html#SECTION0001200430000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar+</I></A>
+<LI><A NAME="tex2html301"
+ HREF="node12.html#SECTION0001200440000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html302"
+ HREF="node12.html#SECTION0001200450000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+<LI><A NAME="tex2html303"
+ HREF="node12.html#SECTION0001200460000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>nreverse</I></A>
+<LI><A NAME="tex2html304"
+ HREF="node12.html#SECTION0001200470000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>append</I></A>
+<LI><A NAME="tex2html305"
+ HREF="node12.html#SECTION0001200480000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+<LI><A NAME="tex2html306"
+ HREF="node12.html#SECTION0001200490000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lm</I></A>
+<LI><A NAME="tex2html307"
+ HREF="node12.html#SECTION0001200500000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lc</I></A>
+<LI><A NAME="tex2html308"
+ HREF="node12.html#SECTION0001200510000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lt</I></A>
+<LI><A NAME="tex2html309"
+ HREF="node12.html#SECTION0001200520000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html310"
+ HREF="node12.html#SECTION0001200530000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html311"
+ HREF="node12.html#SECTION0001200540000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html312"
+ HREF="node12.html#SECTION0001200550000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+<LI><A NAME="tex2html313"
+ HREF="node12.html#SECTION0001200560000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>monom</I></A>
+<LI><A NAME="tex2html314"
+ HREF="node12.html#SECTION0001200570000000000000">
+<I>num</I></A>
+<LI><A NAME="tex2html315"
+ HREF="node12.html#SECTION0001200580000000000000">
+<I>denom</I></A>
+<LI><A NAME="tex2html316"
+ HREF="node12.html#SECTION0001200590000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>simplify<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html317"
+ HREF="node12.html#SECTION0001200600000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>simplify</I></A>
+<LI><A NAME="tex2html318"
+ HREF="node12.html#SECTION0001200610000000000000">
+<I>rat+</I></A>
+<LI><A NAME="tex2html319"
+ HREF="node12.html#SECTION0001200620000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html320"
+ HREF="node12.html#SECTION0001200630000000000000">
+<I>rat*</I></A>
+<LI><A NAME="tex2html321"
+ HREF="node12.html#SECTION0001200640000000000000">
+<I>rat/</I></A>
+<LI><A NAME="tex2html322"
+ HREF="node12.html#SECTION0001200650000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>rat</I></A>
+<LI><A NAME="tex2html323"
+ HREF="node12.html#SECTION0001200660000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>div<MATH CLASS="INLINE">
+-
+</MATH>rat</I></A>
+<LI><A NAME="tex2html324"
+ HREF="node12.html#SECTION0001200670000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+<LI><A NAME="tex2html325"
+ HREF="node12.html#SECTION0001200680000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+<LI><A NAME="tex2html326"
+ HREF="node12.html#SECTION0001200690000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+<LI><A NAME="tex2html327"
+ HREF="node12.html#SECTION0001200700000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>constant</I></A>
+<LI><A NAME="tex2html328"
+ HREF="node12.html#SECTION0001200710000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html329"
+ HREF="node12.html#SECTION0001200720000000000000">
+<I>ratpoly+</I></A>
+<LI><A NAME="tex2html330"
+ HREF="node12.html#SECTION0001200730000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html331"
+ HREF="node12.html#SECTION0001200740000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+<LI><A NAME="tex2html332"
+ HREF="node12.html#SECTION0001200750000000000000">
+<I>ratpoly*</I></A>
+<LI><A NAME="tex2html333"
+ HREF="node12.html#SECTION0001200760000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html334"
+ HREF="node12.html#SECTION0001200770000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html335"
+ HREF="node12.html#SECTION0001200780000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+<LI><A NAME="tex2html336"
+ HREF="node12.html#SECTION0001200790000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>remainder</I></A>
+<LI><A NAME="tex2html337"
+ HREF="node12.html#SECTION0001200800000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html338"
+ HREF="node12.html#SECTION0001200810000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+<LI><A NAME="tex2html339"
+ HREF="node12.html#SECTION0001200820000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>square<MATH CLASS="INLINE">
+-
+</MATH>free</I></A>
+<LI><A NAME="tex2html340"
+ HREF="node12.html#SECTION0001200830000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>normalize</I></A>
+<LI><A NAME="tex2html341"
+ HREF="node12.html#SECTION0001200840000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>resultant</I></A>
+<LI><A NAME="tex2html342"
+ HREF="node12.html#SECTION0001200850000000000000">
+<I>deg</I></A>
+<LI><A NAME="tex2html343"
+ HREF="node12.html#SECTION0001200860000000000000">
+<I>lead</I></A>
+<LI><A NAME="tex2html344"
+ HREF="node12.html#SECTION0001200870000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>discriminant</I></A>
+<LI><A NAME="tex2html345"
+ HREF="node12.html#SECTION0001200880000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html346"
+ HREF="node12.html#SECTION0001200890000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html347"
+ HREF="node12.html#SECTION0001200900000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly1</I></A>
+<LI><A NAME="tex2html348"
+ HREF="node12.html#SECTION0001200910000000000000">
+<I>poly1<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html349"
+ HREF="node12.html#SECTION0001200920000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly1</I></A>
+<LI><A NAME="tex2html350"
+ HREF="node12.html#SECTION0001200930000000000000">
+<I>poly1<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html351"
+ HREF="node12.html#SECTION0001200940000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html352"
+ HREF="node12.html#SECTION0001200950000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>resultant</I></A>
+<LI><A NAME="tex2html353"
+ HREF="node12.html#SECTION0001200960000000000000">
+<I>term*</I></A>
+<LI><A NAME="tex2html354"
+ HREF="node12.html#SECTION0001200970000000000000">
+<I>term/</I></A>
+<LI><A NAME="tex2html355"
+ HREF="node12.html#SECTION0001200980000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+<LI><A NAME="tex2html356"
+ HREF="node12.html#SECTION0001200990000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>divides<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html357"
+ HREF="node12.html#SECTION00012001000000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>monom</I></A>
+<LI><A NAME="tex2html358"
+ HREF="node12.html#SECTION00012001010000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>coefficient</I></A>
+<LI><A NAME="tex2html359"
+ HREF="node12.html#SECTION00012001020000000000000">
+<I>(setf term<MATH CLASS="INLINE">
+-
+</MATH>monom)</I></A>
+<LI><A NAME="tex2html360"
+ HREF="node12.html#SECTION00012001030000000000000">
+<I>(setf term<MATH CLASS="INLINE">
+-
+</MATH>coefficient)</I></A>
+<LI><A NAME="tex2html361"
+ HREF="node12.html#SECTION00012001040000000000000">
+<I>xgcd</I></A>
+</UL>
+<LI><A NAME="tex2html362"
+ HREF="node13.html#SECTION000130000000000000000">
+All examples produced by the <TT>all-examples</TT> utility</A>
+<LI><A NAME="tex2html363"
+ HREF="node14.html#SECTION000140000000000000000">
+About this document ... </A>
+</UL>
+<!--End of Table of Child-Links-->
+<BR><HR>
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/manual.css
===================================================================
--- /trunk/latex-doc/manual/manual.css	(revision 8)
+++ /trunk/latex-doc/manual/manual.css	(revision 8)
@@ -0,0 +1,10 @@
+
+SMALL.TINY		{ font-size : xx-small }
+SMALL.SCRIPTSIZE	{ font-size : xx-small }
+SMALL.FOOTNOTESIZE	{ font-size : x-small  }
+SMALL.SMALL		{ font-size : small    }
+BIG.LARGE		{ font-size : large    }
+BIG.XLARGE		{ font-size : x-large  }
+BIG.XXLARGE		{ font-size : xx-large }
+BIG.HUGE		{ font-size : xx-large }
+BIG.XHUGE		{ font-size : xx-large }
Index: /trunk/latex-doc/manual/manual.html
===================================================================
--- /trunk/latex-doc/manual/manual.html	(revision 8)
+++ /trunk/latex-doc/manual/manual.html	(revision 8)
@@ -0,0 +1,2216 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>CGBLisp User Guide and Manual</TITLE>
+<META NAME="description" CONTENT="CGBLisp User Guide and Manual">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node1.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html2"
+ HREF="node1.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif_gr.gif"> 
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif_gr.gif"> 
+<A NAME="tex2html1"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html3"
+ HREF="node1.html">Contents</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<H1 ALIGN="CENTER">CGBLisp User Guide and Manual</H1>
+<P ALIGN="CENTER"><STRONG>Marek Rychlik</STRONG></P>
+<P ALIGN="LEFT"></P>
+<BR><HR>
+<!--Table of Child-Links-->
+<A NAME="CHILD_LINKS">&#160;</A>
+<UL>
+<LI><A NAME="tex2html4"
+ HREF="node1.html#SECTION00010000000000000000">
+Contents</A>
+<LI><A NAME="tex2html5"
+ HREF="node2.html#SECTION00020000000000000000">
+The Gr&#246;bner Basis package</A>
+<UL>
+<LI><A NAME="tex2html6"
+ HREF="node2.html#SECTION00020010000000000000">
+<I>*grobner<MATH CLASS="INLINE">
+-
+</MATH>debug*</I></A>
+<LI><A NAME="tex2html7"
+ HREF="node2.html#SECTION00020020000000000000">
+<I>*buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs*</I></A>
+<LI><A NAME="tex2html8"
+ HREF="node2.html#SECTION00020030000000000000">
+<I>*gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs*</I></A>
+<LI><A NAME="tex2html9"
+ HREF="node2.html#SECTION00020040000000000000">
+<I>*grobner<MATH CLASS="INLINE">
+-
+</MATH>function*</I></A>
+<LI><A NAME="tex2html10"
+ HREF="node2.html#SECTION00020050000000000000">
+<I>select<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>algorithm</I></A>
+<LI><A NAME="tex2html11"
+ HREF="node2.html#SECTION00020060000000000000">
+<I>grobner</I></A>
+<LI><A NAME="tex2html12"
+ HREF="node2.html#SECTION00020070000000000000">
+<I>debug<MATH CLASS="INLINE">
+-
+</MATH>cgb</I></A>
+<LI><A NAME="tex2html13"
+ HREF="node2.html#SECTION00020080000000000000">
+<I>spoly</I></A>
+<LI><A NAME="tex2html14"
+ HREF="node2.html#SECTION00020090000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+<LI><A NAME="tex2html15"
+ HREF="node2.html#SECTION000200100000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>content</I></A>
+<LI><A NAME="tex2html16"
+ HREF="node2.html#SECTION000200110000000000000">
+<I>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html17"
+ HREF="node2.html#SECTION000200120000000000000">
+<I>buchberger</I></A>
+<LI><A NAME="tex2html18"
+ HREF="node2.html#SECTION000200130000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+<LI><A NAME="tex2html19"
+ HREF="node2.html#SECTION000200140000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>sort<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html20"
+ HREF="node2.html#SECTION000200150000000000000">
+<I>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html21"
+ HREF="node2.html#SECTION000200160000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html22"
+ HREF="node2.html#SECTION000200170000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html23"
+ HREF="node2.html#SECTION000200180000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+<LI><A NAME="tex2html24"
+ HREF="node2.html#SECTION000200190000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html25"
+ HREF="node2.html#SECTION000200200000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>coefficient<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html26"
+ HREF="node2.html#SECTION000200210000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>set<MATH CLASS="INLINE">
+-
+</MATH>pair<MATH CLASS="INLINE">
+-
+</MATH>heuristic</I></A>
+<LI><A NAME="tex2html27"
+ HREF="node2.html#SECTION000200220000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html28"
+ HREF="node2.html#SECTION000200230000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html29"
+ HREF="node2.html#SECTION000200240000000000000">
+<I>normalize<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html30"
+ HREF="node2.html#SECTION000200250000000000000">
+<I>normalize<MATH CLASS="INLINE">
+-
+</MATH>basis</I></A>
+<LI><A NAME="tex2html31"
+ HREF="node2.html#SECTION000200260000000000000">
+<I>reduction</I></A>
+<LI><A NAME="tex2html32"
+ HREF="node2.html#SECTION000200270000000000000">
+<I>reduced<MATH CLASS="INLINE">
+-
+</MATH>grobner</I></A>
+<LI><A NAME="tex2html33"
+ HREF="node2.html#SECTION000200280000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html34"
+ HREF="node2.html#SECTION000200290000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html35"
+ HREF="node2.html#SECTION000200300000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html36"
+ HREF="node2.html#SECTION000200310000000000000">
+<I>ring<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+<LI><A NAME="tex2html37"
+ HREF="node2.html#SECTION000200320000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html38"
+ HREF="node2.html#SECTION000200330000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+<LI><A NAME="tex2html39"
+ HREF="node2.html#SECTION000200340000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>contract</I></A>
+<LI><A NAME="tex2html40"
+ HREF="node2.html#SECTION000200350000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html41"
+ HREF="node2.html#SECTION000200360000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html42"
+ HREF="node2.html#SECTION000200370000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+<LI><A NAME="tex2html43"
+ HREF="node2.html#SECTION000200380000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>subsetp</I></A>
+<LI><A NAME="tex2html44"
+ HREF="node2.html#SECTION000200390000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>member</I></A>
+<LI><A NAME="tex2html45"
+ HREF="node2.html#SECTION000200400000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+<LI><A NAME="tex2html46"
+ HREF="node2.html#SECTION000200410000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>subsetp</I></A>
+<LI><A NAME="tex2html47"
+ HREF="node2.html#SECTION000200420000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>member</I></A>
+<LI><A NAME="tex2html48"
+ HREF="node2.html#SECTION000200430000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html49"
+ HREF="node2.html#SECTION000200440000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>variables</I></A>
+<LI><A NAME="tex2html50"
+ HREF="node2.html#SECTION000200450000000000000">
+<I>extend<MATH CLASS="INLINE">
+-
+</MATH>polynomials</I></A>
+<LI><A NAME="tex2html51"
+ HREF="node2.html#SECTION000200460000000000000">
+<I>saturation<MATH CLASS="INLINE">
+-
+</MATH>extension</I></A>
+<LI><A NAME="tex2html52"
+ HREF="node2.html#SECTION000200470000000000000">
+<I>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>extension</I></A>
+<LI><A NAME="tex2html53"
+ HREF="node2.html#SECTION000200480000000000000">
+<I>saturation<MATH CLASS="INLINE">
+-
+</MATH>extension<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html54"
+ HREF="node2.html#SECTION000200490000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html55"
+ HREF="node2.html#SECTION000200500000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation</I></A>
+<LI><A NAME="tex2html56"
+ HREF="node2.html#SECTION000200510000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation</I></A>
+<LI><A NAME="tex2html57"
+ HREF="node2.html#SECTION000200520000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>criterion</I></A>
+<LI><A NAME="tex2html58"
+ HREF="node2.html#SECTION000200530000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>test</I></A>
+<LI><A NAME="tex2html59"
+ HREF="node2.html#SECTION000200540000000000000">
+<I>minimization</I></A>
+<LI><A NAME="tex2html60"
+ HREF="node2.html#SECTION000200550000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>minimized</I></A>
+<LI><A NAME="tex2html61"
+ HREF="node2.html#SECTION000200560000000000000">
+<I>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html62"
+ HREF="node2.html#SECTION000200570000000000000">
+<I>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html63"
+ HREF="node2.html#SECTION000200580000000000000">
+<I>pseudo<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+<LI><A NAME="tex2html64"
+ HREF="node2.html#SECTION000200590000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller</I></A>
+<LI><A NAME="tex2html65"
+ HREF="node2.html#SECTION000200600000000000000">
+<I>update</I></A>
+<LI><A NAME="tex2html66"
+ HREF="node2.html#SECTION000200610000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html67"
+ HREF="node2.html#SECTION000200620000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html68"
+ HREF="node2.html#SECTION000200630000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+<LI><A NAME="tex2html69"
+ HREF="node2.html#SECTION000200640000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html70"
+ HREF="node2.html#SECTION000200650000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>coefficient<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html71"
+ HREF="node2.html#SECTION000200660000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>set<MATH CLASS="INLINE">
+-
+</MATH>pair<MATH CLASS="INLINE">
+-
+</MATH>heuristic</I></A>
+<LI><A NAME="tex2html72"
+ HREF="node2.html#SECTION000200670000000000000">
+<I>spoly<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html73"
+ HREF="node2.html#SECTION000200680000000000000">
+<I>spoly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html74"
+ HREF="node2.html#SECTION000200690000000000000">
+<I>normal<MATH CLASS="INLINE">
+-
+</MATH>form<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html75"
+ HREF="node2.html#SECTION000200700000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html76"
+ HREF="node2.html#SECTION000200710000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html77"
+ HREF="node2.html#SECTION000200720000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sort<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html78"
+ HREF="node2.html#SECTION000200730000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>1<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html79"
+ HREF="node2.html#SECTION000200740000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>2<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html80"
+ HREF="node2.html#SECTION000200750000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html81"
+ HREF="node2.html#SECTION000200760000000000000">
+<I>update<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html82"
+ HREF="node2.html#SECTION000200770000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html83"
+ HREF="node2.html#SECTION000200780000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</UL>
+<LI><A NAME="tex2html84"
+ HREF="node3.html#SECTION00030000000000000000">
+The String Interface to the Gr&#246;bner Basis package</A>
+<UL>
+<LI><A NAME="tex2html85"
+ HREF="node3.html#SECTION00030010000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html86"
+ HREF="node3.html#SECTION00030020000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>grobner</I></A>
+<LI><A NAME="tex2html87"
+ HREF="node3.html#SECTION00030030000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>elimination<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html88"
+ HREF="node3.html#SECTION00030040000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+<LI><A NAME="tex2html89"
+ HREF="node3.html#SECTION00030050000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html90"
+ HREF="node3.html#SECTION00030060000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html91"
+ HREF="node3.html#SECTION00030070000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html92"
+ HREF="node3.html#SECTION00030080000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation</I></A>
+<LI><A NAME="tex2html93"
+ HREF="node3.html#SECTION00030090000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation</I></A>
+<LI><A NAME="tex2html94"
+ HREF="node3.html#SECTION000300100000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html95"
+ HREF="node3.html#SECTION000300110000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>read<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html96"
+ HREF="node3.html#SECTION000300120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>rational<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>integer</I></A>
+<LI><A NAME="tex2html97"
+ HREF="node3.html#SECTION000300130000000000000">
+<I>read<MATH CLASS="INLINE">
+-
+</MATH>vars</I></A>
+</UL>
+<LI><A NAME="tex2html98"
+ HREF="node4.html#SECTION00040000000000000000">
+The Comprehensive Gr&#246;bner basis package</A>
+<UL>
+<LI><A NAME="tex2html99"
+ HREF="node4.html#SECTION00040010000000000000">
+<I>*colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>debug*</I></A>
+<LI><A NAME="tex2html100"
+ HREF="node4.html#SECTION00040020000000000000">
+<I>debug<MATH CLASS="INLINE">
+-
+</MATH>cgb</I></A>
+<LI><A NAME="tex2html101"
+ HREF="node4.html#SECTION00040030000000000000">
+<I>make<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html102"
+ HREF="node4.html#SECTION00040040000000000000">
+<I>make<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html103"
+ HREF="node4.html#SECTION00040050000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html104"
+ HREF="node4.html#SECTION00040060000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html105"
+ HREF="node4.html#SECTION00040070000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html106"
+ HREF="node4.html#SECTION00040080000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html107"
+ HREF="node4.html#SECTION00040090000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html108"
+ HREF="node4.html#SECTION000400100000000000000">
+<I>determine</I></A>
+<LI><A NAME="tex2html109"
+ HREF="node4.html#SECTION000400110000000000000">
+<I>determine<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html110"
+ HREF="node4.html#SECTION000400120000000000000">
+<I>determine<MATH CLASS="INLINE">
+-
+</MATH>white<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+<LI><A NAME="tex2html111"
+ HREF="node4.html#SECTION000400130000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>system<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html112"
+ HREF="node4.html#SECTION000400140000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html113"
+ HREF="node4.html#SECTION000400150000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html114"
+ HREF="node4.html#SECTION000400160000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+<LI><A NAME="tex2html115"
+ HREF="node4.html#SECTION000400170000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>hm</I></A>
+<LI><A NAME="tex2html116"
+ HREF="node4.html#SECTION000400180000000000000">
+<I>delete<MATH CLASS="INLINE">
+-
+</MATH>green<MATH CLASS="INLINE">
+-
+</MATH>polys</I></A>
+<LI><A NAME="tex2html117"
+ HREF="node4.html#SECTION000400190000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+<LI><A NAME="tex2html118"
+ HREF="node4.html#SECTION000400200000000000000">
+<I>reorder<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html119"
+ HREF="node4.html#SECTION000400210000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>criterion<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html120"
+ HREF="node4.html#SECTION000400220000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>criterion<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html121"
+ HREF="node4.html#SECTION000400230000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html122"
+ HREF="node4.html#SECTION000400240000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html123"
+ HREF="node4.html#SECTION000400250000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>lm</I></A>
+<LI><A NAME="tex2html124"
+ HREF="node4.html#SECTION000400260000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>lc</I></A>
+<LI><A NAME="tex2html125"
+ HREF="node4.html#SECTION000400270000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html126"
+ HREF="node4.html#SECTION000400280000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html127"
+ HREF="node4.html#SECTION000400290000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term*</I></A>
+<LI><A NAME="tex2html128"
+ HREF="node4.html#SECTION000400300000000000000">
+<I>color*</I></A>
+<LI><A NAME="tex2html129"
+ HREF="node4.html#SECTION000400310000000000000">
+<I>color+</I></A>
+<LI><A NAME="tex2html130"
+ HREF="node4.html#SECTION000400320000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html131"
+ HREF="node4.html#SECTION000400330000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly+</I></A>
+<LI><A NAME="tex2html132"
+ HREF="node4.html#SECTION000400340000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html133"
+ HREF="node4.html#SECTION000400350000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+<LI><A NAME="tex2html134"
+ HREF="node4.html#SECTION000400360000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html135"
+ HREF="node4.html#SECTION000400370000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+<LI><A NAME="tex2html136"
+ HREF="node4.html#SECTION000400380000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+<LI><A NAME="tex2html137"
+ HREF="node4.html#SECTION000400390000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>cover</I></A>
+<LI><A NAME="tex2html138"
+ HREF="node4.html#SECTION000400400000000000000">
+<I>saturate<MATH CLASS="INLINE">
+-
+</MATH>cover</I></A>
+<LI><A NAME="tex2html139"
+ HREF="node4.html#SECTION000400410000000000000">
+<I>saturate<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+<LI><A NAME="tex2html140"
+ HREF="node4.html#SECTION000400420000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>determine</I></A>
+<LI><A NAME="tex2html141"
+ HREF="node4.html#SECTION000400430000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+<LI><A NAME="tex2html142"
+ HREF="node4.html#SECTION000400440000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>pair</I></A>
+<LI><A NAME="tex2html143"
+ HREF="node4.html#SECTION000400450000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+<LI><A NAME="tex2html144"
+ HREF="node4.html#SECTION000400460000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>reduction</I></A>
+<LI><A NAME="tex2html145"
+ HREF="node4.html#SECTION000400470000000000000">
+<I>green<MATH CLASS="INLINE">
+-
+</MATH>reduce<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html146"
+ HREF="node4.html#SECTION000400480000000000000">
+<I>green<MATH CLASS="INLINE">
+-
+</MATH>reduce<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html147"
+ HREF="node4.html#SECTION000400490000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>system<MATH CLASS="INLINE">
+-
+</MATH>green<MATH CLASS="INLINE">
+-
+</MATH>reduce</I></A>
+<LI><A NAME="tex2html148"
+ HREF="node4.html#SECTION000400500000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html149"
+ HREF="node4.html#SECTION000400510000000000000">
+<I>red<MATH CLASS="INLINE">
+-
+</MATH>reduction</I></A>
+</UL>
+<LI><A NAME="tex2html150"
+ HREF="node5.html#SECTION00050000000000000000">
+The Coefficient Ring package</A>
+<UL>
+<LI><A NAME="tex2html151"
+ HREF="node5.html#SECTION00050010000000000000">
+<I>ring</I></A>
+<LI><A NAME="tex2html152"
+ HREF="node5.html#SECTION00050020000000000000">
+<I>*ring<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>integers*</I></A>
+<LI><A NAME="tex2html153"
+ HREF="node5.html#SECTION00050030000000000000">
+<I>*field<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>rationals*</I></A>
+<LI><A NAME="tex2html154"
+ HREF="node5.html#SECTION00050040000000000000">
+<I>field<MATH CLASS="INLINE">
+-
+</MATH>modulo<MATH CLASS="INLINE">
+-
+</MATH>prime</I></A>
+<LI><A NAME="tex2html155"
+ HREF="node5.html#SECTION00050050000000000000">
+<I>*coefficient<MATH CLASS="INLINE">
+-
+</MATH>ring*</I></A>
+</UL>
+<LI><A NAME="tex2html156"
+ HREF="node6.html#SECTION00060000000000000000">
+The Division Package</A>
+<UL>
+<LI><A NAME="tex2html157"
+ HREF="node6.html#SECTION00060010000000000000">
+<I>divide</I></A>
+<LI><A NAME="tex2html158"
+ HREF="node6.html#SECTION00060020000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>exact<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+</UL>
+<LI><A NAME="tex2html159"
+ HREF="node7.html#SECTION00070000000000000000">
+The Dynamical Systems package</A>
+<UL>
+<LI><A NAME="tex2html160"
+ HREF="node7.html#SECTION00070010000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>composition</I></A>
+<LI><A NAME="tex2html161"
+ HREF="node7.html#SECTION00070020000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>composition</I></A>
+<LI><A NAME="tex2html162"
+ HREF="node7.html#SECTION00070030000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>dynamic<MATH CLASS="INLINE">
+-
+</MATH>power</I></A>
+<LI><A NAME="tex2html163"
+ HREF="node7.html#SECTION00070040000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>evaluate</I></A>
+<LI><A NAME="tex2html164"
+ HREF="node7.html#SECTION00070050000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>evaluate</I></A>
+<LI><A NAME="tex2html165"
+ HREF="node7.html#SECTION00070060000000000000">
+<I>factorial</I></A>
+<LI><A NAME="tex2html166"
+ HREF="node7.html#SECTION00070070000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+<LI><A NAME="tex2html167"
+ HREF="node7.html#SECTION00070080000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+<LI><A NAME="tex2html168"
+ HREF="node7.html#SECTION00070090000000000000">
+<I>standard<MATH CLASS="INLINE">
+-
+</MATH>vector</I></A>
+<LI><A NAME="tex2html169"
+ HREF="node7.html#SECTION000700100000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>partial</I></A>
+<LI><A NAME="tex2html170"
+ HREF="node7.html#SECTION000700110000000000000">
+<I>partial</I></A>
+<LI><A NAME="tex2html171"
+ HREF="node7.html#SECTION000700120000000000000">
+<I>determinant</I></A>
+<LI><A NAME="tex2html172"
+ HREF="node7.html#SECTION000700130000000000000">
+<I>minor</I></A>
+<LI><A NAME="tex2html173"
+ HREF="node7.html#SECTION000700140000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>row</I></A>
+<LI><A NAME="tex2html174"
+ HREF="node7.html#SECTION000700150000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>column</I></A>
+<LI><A NAME="tex2html175"
+ HREF="node7.html#SECTION000700160000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>elt</I></A>
+<LI><A NAME="tex2html176"
+ HREF="node7.html#SECTION000700170000000000000">
+<I>matrix<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html177"
+ HREF="node7.html#SECTION000700180000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html178"
+ HREF="node7.html#SECTION000700190000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html179"
+ HREF="node7.html#SECTION000700200000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html180"
+ HREF="node7.html#SECTION000700210000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>list<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html181"
+ HREF="node7.html#SECTION000700220000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html182"
+ HREF="node7.html#SECTION000700230000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html183"
+ HREF="node7.html#SECTION000700240000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html184"
+ HREF="node7.html#SECTION000700250000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>combination</I></A>
+<LI><A NAME="tex2html185"
+ HREF="node7.html#SECTION000700260000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>combination<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html186"
+ HREF="node7.html#SECTION000700270000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html187"
+ HREF="node7.html#SECTION000700280000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>polynomial</I></A>
+<LI><A NAME="tex2html188"
+ HREF="node7.html#SECTION000700290000000000000">
+<I>identity<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html189"
+ HREF="node7.html#SECTION000700300000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html190"
+ HREF="node7.html#SECTION000700310000000000000">
+<I>jacobi<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html191"
+ HREF="node7.html#SECTION000700320000000000000">
+<I>jacobian</I></A>
+</UL>
+<LI><A NAME="tex2html192"
+ HREF="node8.html#SECTION00080000000000000000">
+The Geometric Theorem Prover package</A>
+<UL>
+<LI><A NAME="tex2html193"
+ HREF="node8.html#SECTION00080010000000000000">
+<I>*prover<MATH CLASS="INLINE">
+-
+</MATH>order*</I></A>
+<LI><A NAME="tex2html194"
+ HREF="node8.html#SECTION00080020000000000000">
+<I>csym</I></A>
+<LI><A NAME="tex2html195"
+ HREF="node8.html#SECTION00080030000000000000">
+<I>real<MATH CLASS="INLINE">
+-
+</MATH>identical<MATH CLASS="INLINE">
+-
+</MATH>points</I></A>
+<LI><A NAME="tex2html196"
+ HREF="node8.html#SECTION00080040000000000000">
+<I>identical<MATH CLASS="INLINE">
+-
+</MATH>points</I></A>
+<LI><A NAME="tex2html197"
+ HREF="node8.html#SECTION00080050000000000000">
+<I>perpendicular</I></A>
+<LI><A NAME="tex2html198"
+ HREF="node8.html#SECTION00080060000000000000">
+<I>parallel</I></A>
+<LI><A NAME="tex2html199"
+ HREF="node8.html#SECTION00080070000000000000">
+<I>collinear</I></A>
+<LI><A NAME="tex2html200"
+ HREF="node8.html#SECTION00080080000000000000">
+<I>equidistant</I></A>
+<LI><A NAME="tex2html201"
+ HREF="node8.html#SECTION00080090000000000000">
+<I>euclidean<MATH CLASS="INLINE">
+-
+</MATH>distance</I></A>
+<LI><A NAME="tex2html202"
+ HREF="node8.html#SECTION000800100000000000000">
+<I>midpoint</I></A>
+<LI><A NAME="tex2html203"
+ HREF="node8.html#SECTION000800110000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>statements</I></A>
+<LI><A NAME="tex2html204"
+ HREF="node8.html#SECTION000800120000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>assumptions</I></A>
+<LI><A NAME="tex2html205"
+ HREF="node8.html#SECTION000800130000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>conclusions</I></A>
+<LI><A NAME="tex2html206"
+ HREF="node8.html#SECTION000800140000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>theorem</I></A>
+<LI><A NAME="tex2html207"
+ HREF="node8.html#SECTION000800150000000000000">
+<I>prove<MATH CLASS="INLINE">
+-
+</MATH>theorem</I></A>
+</UL>
+<LI><A NAME="tex2html208"
+ HREF="node9.html#SECTION00090000000000000000">
+The Monomial Order Package</A>
+<UL>
+<LI><A NAME="tex2html209"
+ HREF="node9.html#SECTION00090010000000000000">
+<I>lex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html210"
+ HREF="node9.html#SECTION00090020000000000000">
+<I>total<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+<LI><A NAME="tex2html211"
+ HREF="node9.html#SECTION00090030000000000000">
+<I>grlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html212"
+ HREF="node9.html#SECTION00090040000000000000">
+<I>grevlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html213"
+ HREF="node9.html#SECTION00090050000000000000">
+<I>revlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html214"
+ HREF="node9.html#SECTION00090060000000000000">
+<I>invlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html215"
+ HREF="node9.html#SECTION00090070000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>order</I></A>
+<LI><A NAME="tex2html216"
+ HREF="node9.html#SECTION00090080000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>order<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</UL>
+<LI><A NAME="tex2html217"
+ HREF="node10.html#SECTION000100000000000000000">
+The Polynomial Package</A>
+<UL>
+<LI><A NAME="tex2html218"
+ HREF="node10.html#SECTION000100010000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html219"
+ HREF="node10.html#SECTION000100020000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html220"
+ HREF="node10.html#SECTION000100030000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html221"
+ HREF="node10.html#SECTION000100040000000000000">
+<I>minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html222"
+ HREF="node10.html#SECTION000100050000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html223"
+ HREF="node10.html#SECTION000100060000000000000">
+<I>poly+</I></A>
+<LI><A NAME="tex2html224"
+ HREF="node10.html#SECTION000100070000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html225"
+ HREF="node10.html#SECTION000100080000000000000">
+<I>poly*</I></A>
+<LI><A NAME="tex2html226"
+ HREF="node10.html#SECTION000100090000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+<LI><A NAME="tex2html227"
+ HREF="node10.html#SECTION0001000100000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+<LI><A NAME="tex2html228"
+ HREF="node10.html#SECTION0001000110000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>mexpt</I></A>
+<LI><A NAME="tex2html229"
+ HREF="node10.html#SECTION0001000120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>constant<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html230"
+ HREF="node10.html#SECTION0001000130000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>extend</I></A>
+<LI><A NAME="tex2html231"
+ HREF="node10.html#SECTION0001000140000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>extend<MATH CLASS="INLINE">
+-
+</MATH>end</I></A>
+<LI><A NAME="tex2html232"
+ HREF="node10.html#SECTION0001000150000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+<LI><A NAME="tex2html233"
+ HREF="node10.html#SECTION0001000160000000000000">
+<I>lt</I></A>
+<LI><A NAME="tex2html234"
+ HREF="node10.html#SECTION0001000170000000000000">
+<I>lm</I></A>
+<LI><A NAME="tex2html235"
+ HREF="node10.html#SECTION0001000180000000000000">
+<I>lc</I></A>
+</UL>
+<LI><A NAME="tex2html236"
+ HREF="node11.html#SECTION000110000000000000000">
+The Parser Package</A>
+<UL>
+<LI><A NAME="tex2html237"
+ HREF="node11.html#SECTION000110010000000000000">
+<I>parse</I></A>
+<LI><A NAME="tex2html238"
+ HREF="node11.html#SECTION000110020000000000000">
+<I>alist<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html239"
+ HREF="node11.html#SECTION000110030000000000000">
+<I>alist<MATH CLASS="INLINE">
+-
+</MATH>form<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html240"
+ HREF="node11.html#SECTION000110040000000000000">
+<I>powers</I></A>
+<LI><A NAME="tex2html241"
+ HREF="node11.html#SECTION000110050000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html242"
+ HREF="node11.html#SECTION000110060000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>string<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html243"
+ HREF="node11.html#SECTION000110070000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>sorted<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html244"
+ HREF="node11.html#SECTION000110080000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>string<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>sorted<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html245"
+ HREF="node11.html#SECTION000110090000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html246"
+ HREF="node11.html#SECTION0001100100000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html247"
+ HREF="node11.html#SECTION0001100110000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>eval<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html248"
+ HREF="node11.html#SECTION0001100120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>eval</I></A>
+<LI><A NAME="tex2html249"
+ HREF="node11.html#SECTION0001100130000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>basis</I></A>
+<LI><A NAME="tex2html250"
+ HREF="node11.html#SECTION0001100140000000000000">
+<I>convert<MATH CLASS="INLINE">
+-
+</MATH>number</I></A>
+<LI><A NAME="tex2html251"
+ HREF="node11.html#SECTION0001100150000000000000">
+<I>$poly+</I></A>
+<LI><A NAME="tex2html252"
+ HREF="node11.html#SECTION0001100160000000000000">
+<I>$poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html253"
+ HREF="node11.html#SECTION0001100170000000000000">
+<I>$minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html254"
+ HREF="node11.html#SECTION0001100180000000000000">
+<I>$poly*</I></A>
+<LI><A NAME="tex2html255"
+ HREF="node11.html#SECTION0001100190000000000000">
+<I>$poly/</I></A>
+<LI><A NAME="tex2html256"
+ HREF="node11.html#SECTION0001100200000000000000">
+<I>$poly<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+</UL>
+<LI><A NAME="tex2html257"
+ HREF="node12.html#SECTION000120000000000000000">
+Other packages</A>
+<UL>
+<LI><A NAME="tex2html258"
+ HREF="node12.html#SECTION000120010000000000000">
+<I>makelist<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html259"
+ HREF="node12.html#SECTION000120020000000000000">
+<I>makelist</I></A>
+<LI><A NAME="tex2html260"
+ HREF="node12.html#SECTION000120030000000000000">
+<I>sum</I></A>
+<LI><A NAME="tex2html261"
+ HREF="node12.html#SECTION000120040000000000000">
+<I>list<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+<LI><A NAME="tex2html262"
+ HREF="node12.html#SECTION000120050000000000000">
+<I>list<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html263"
+ HREF="node12.html#SECTION000120060000000000000">
+<I>union<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+<LI><A NAME="tex2html264"
+ HREF="node12.html#SECTION000120070000000000000">
+<I>union<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html265"
+ HREF="node12.html#SECTION000120080000000000000">
+<I>set<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+<LI><A NAME="tex2html266"
+ HREF="node12.html#SECTION000120090000000000000">
+<I>set<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html267"
+ HREF="node12.html#SECTION0001200100000000000000">
+<I>select</I></A>
+<LI><A NAME="tex2html268"
+ HREF="node12.html#SECTION0001200110000000000000">
+<I>monom/</I></A>
+<LI><A NAME="tex2html269"
+ HREF="node12.html#SECTION0001200120000000000000">
+<I>monom*</I></A>
+<LI><A NAME="tex2html270"
+ HREF="node12.html#SECTION0001200130000000000000">
+<I>nmonom*</I></A>
+<LI><A NAME="tex2html271"
+ HREF="node12.html#SECTION0001200140000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>divides<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html272"
+ HREF="node12.html#SECTION0001200150000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>divisible<MATH CLASS="INLINE">
+-
+</MATH>by<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html273"
+ HREF="node12.html#SECTION0001200160000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>rel<MATH CLASS="INLINE">
+-
+</MATH>prime</I></A>
+<LI><A NAME="tex2html274"
+ HREF="node12.html#SECTION0001200170000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+<LI><A NAME="tex2html275"
+ HREF="node12.html#SECTION0001200180000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html276"
+ HREF="node12.html#SECTION0001200190000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html277"
+ HREF="node12.html#SECTION0001200200000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html278"
+ HREF="node12.html#SECTION0001200210000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>pseudo<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+<LI><A NAME="tex2html279"
+ HREF="node12.html#SECTION0001200220000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>pseudo<MATH CLASS="INLINE">
+-
+</MATH>remainder</I></A>
+<LI><A NAME="tex2html280"
+ HREF="node12.html#SECTION0001200230000000000000">
+<I>mdeg</I></A>
+<LI><A NAME="tex2html281"
+ HREF="node12.html#SECTION0001200240000000000000">
+<I>lcoeff</I></A>
+<LI><A NAME="tex2html282"
+ HREF="node12.html#SECTION0001200250000000000000">
+<I>lrest</I></A>
+<LI><A NAME="tex2html283"
+ HREF="node12.html#SECTION0001200260000000000000">
+<I>lpart</I></A>
+<LI><A NAME="tex2html284"
+ HREF="node12.html#SECTION0001200270000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+<LI><A NAME="tex2html285"
+ HREF="node12.html#SECTION0001200280000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>content</I></A>
+<LI><A NAME="tex2html286"
+ HREF="node12.html#SECTION0001200290000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html287"
+ HREF="node12.html#SECTION0001200300000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html288"
+ HREF="node12.html#SECTION0001200310000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>tail</I></A>
+<LI><A NAME="tex2html289"
+ HREF="node12.html#SECTION0001200320000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>poly)</I></A>
+<LI><A NAME="tex2html290"
+ HREF="node12.html#SECTION0001200330000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sugar)</I></A>
+<LI><A NAME="tex2html291"
+ HREF="node12.html#SECTION0001200340000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>tail)</I></A>
+<LI><A NAME="tex2html292"
+ HREF="node12.html#SECTION0001200350000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html293"
+ HREF="node12.html#SECTION0001200360000000000000">
+<I>coefficient<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html294"
+ HREF="node12.html#SECTION0001200370000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html295"
+ HREF="node12.html#SECTION0001200380000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>add<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html296"
+ HREF="node12.html#SECTION0001200390000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html297"
+ HREF="node12.html#SECTION0001200400000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html298"
+ HREF="node12.html#SECTION0001200410000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html299"
+ HREF="node12.html#SECTION0001200420000000000000">
+<I>minus<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html300"
+ HREF="node12.html#SECTION0001200430000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar+</I></A>
+<LI><A NAME="tex2html301"
+ HREF="node12.html#SECTION0001200440000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html302"
+ HREF="node12.html#SECTION0001200450000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+<LI><A NAME="tex2html303"
+ HREF="node12.html#SECTION0001200460000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>nreverse</I></A>
+<LI><A NAME="tex2html304"
+ HREF="node12.html#SECTION0001200470000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>append</I></A>
+<LI><A NAME="tex2html305"
+ HREF="node12.html#SECTION0001200480000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+<LI><A NAME="tex2html306"
+ HREF="node12.html#SECTION0001200490000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lm</I></A>
+<LI><A NAME="tex2html307"
+ HREF="node12.html#SECTION0001200500000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lc</I></A>
+<LI><A NAME="tex2html308"
+ HREF="node12.html#SECTION0001200510000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lt</I></A>
+<LI><A NAME="tex2html309"
+ HREF="node12.html#SECTION0001200520000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html310"
+ HREF="node12.html#SECTION0001200530000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html311"
+ HREF="node12.html#SECTION0001200540000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html312"
+ HREF="node12.html#SECTION0001200550000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+<LI><A NAME="tex2html313"
+ HREF="node12.html#SECTION0001200560000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>monom</I></A>
+<LI><A NAME="tex2html314"
+ HREF="node12.html#SECTION0001200570000000000000">
+<I>num</I></A>
+<LI><A NAME="tex2html315"
+ HREF="node12.html#SECTION0001200580000000000000">
+<I>denom</I></A>
+<LI><A NAME="tex2html316"
+ HREF="node12.html#SECTION0001200590000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>simplify<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html317"
+ HREF="node12.html#SECTION0001200600000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>simplify</I></A>
+<LI><A NAME="tex2html318"
+ HREF="node12.html#SECTION0001200610000000000000">
+<I>rat+</I></A>
+<LI><A NAME="tex2html319"
+ HREF="node12.html#SECTION0001200620000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html320"
+ HREF="node12.html#SECTION0001200630000000000000">
+<I>rat*</I></A>
+<LI><A NAME="tex2html321"
+ HREF="node12.html#SECTION0001200640000000000000">
+<I>rat/</I></A>
+<LI><A NAME="tex2html322"
+ HREF="node12.html#SECTION0001200650000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>rat</I></A>
+<LI><A NAME="tex2html323"
+ HREF="node12.html#SECTION0001200660000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>div<MATH CLASS="INLINE">
+-
+</MATH>rat</I></A>
+<LI><A NAME="tex2html324"
+ HREF="node12.html#SECTION0001200670000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+<LI><A NAME="tex2html325"
+ HREF="node12.html#SECTION0001200680000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+<LI><A NAME="tex2html326"
+ HREF="node12.html#SECTION0001200690000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+<LI><A NAME="tex2html327"
+ HREF="node12.html#SECTION0001200700000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>constant</I></A>
+<LI><A NAME="tex2html328"
+ HREF="node12.html#SECTION0001200710000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html329"
+ HREF="node12.html#SECTION0001200720000000000000">
+<I>ratpoly+</I></A>
+<LI><A NAME="tex2html330"
+ HREF="node12.html#SECTION0001200730000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html331"
+ HREF="node12.html#SECTION0001200740000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+<LI><A NAME="tex2html332"
+ HREF="node12.html#SECTION0001200750000000000000">
+<I>ratpoly*</I></A>
+<LI><A NAME="tex2html333"
+ HREF="node12.html#SECTION0001200760000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html334"
+ HREF="node12.html#SECTION0001200770000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html335"
+ HREF="node12.html#SECTION0001200780000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+<LI><A NAME="tex2html336"
+ HREF="node12.html#SECTION0001200790000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>remainder</I></A>
+<LI><A NAME="tex2html337"
+ HREF="node12.html#SECTION0001200800000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html338"
+ HREF="node12.html#SECTION0001200810000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+<LI><A NAME="tex2html339"
+ HREF="node12.html#SECTION0001200820000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>square<MATH CLASS="INLINE">
+-
+</MATH>free</I></A>
+<LI><A NAME="tex2html340"
+ HREF="node12.html#SECTION0001200830000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>normalize</I></A>
+<LI><A NAME="tex2html341"
+ HREF="node12.html#SECTION0001200840000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>resultant</I></A>
+<LI><A NAME="tex2html342"
+ HREF="node12.html#SECTION0001200850000000000000">
+<I>deg</I></A>
+<LI><A NAME="tex2html343"
+ HREF="node12.html#SECTION0001200860000000000000">
+<I>lead</I></A>
+<LI><A NAME="tex2html344"
+ HREF="node12.html#SECTION0001200870000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>discriminant</I></A>
+<LI><A NAME="tex2html345"
+ HREF="node12.html#SECTION0001200880000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html346"
+ HREF="node12.html#SECTION0001200890000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html347"
+ HREF="node12.html#SECTION0001200900000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly1</I></A>
+<LI><A NAME="tex2html348"
+ HREF="node12.html#SECTION0001200910000000000000">
+<I>poly1<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html349"
+ HREF="node12.html#SECTION0001200920000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly1</I></A>
+<LI><A NAME="tex2html350"
+ HREF="node12.html#SECTION0001200930000000000000">
+<I>poly1<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html351"
+ HREF="node12.html#SECTION0001200940000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html352"
+ HREF="node12.html#SECTION0001200950000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>resultant</I></A>
+<LI><A NAME="tex2html353"
+ HREF="node12.html#SECTION0001200960000000000000">
+<I>term*</I></A>
+<LI><A NAME="tex2html354"
+ HREF="node12.html#SECTION0001200970000000000000">
+<I>term/</I></A>
+<LI><A NAME="tex2html355"
+ HREF="node12.html#SECTION0001200980000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+<LI><A NAME="tex2html356"
+ HREF="node12.html#SECTION0001200990000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>divides<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html357"
+ HREF="node12.html#SECTION00012001000000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>monom</I></A>
+<LI><A NAME="tex2html358"
+ HREF="node12.html#SECTION00012001010000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>coefficient</I></A>
+<LI><A NAME="tex2html359"
+ HREF="node12.html#SECTION00012001020000000000000">
+<I>(setf term<MATH CLASS="INLINE">
+-
+</MATH>monom)</I></A>
+<LI><A NAME="tex2html360"
+ HREF="node12.html#SECTION00012001030000000000000">
+<I>(setf term<MATH CLASS="INLINE">
+-
+</MATH>coefficient)</I></A>
+<LI><A NAME="tex2html361"
+ HREF="node12.html#SECTION00012001040000000000000">
+<I>xgcd</I></A>
+</UL>
+<LI><A NAME="tex2html362"
+ HREF="node13.html#SECTION000130000000000000000">
+All examples produced by the <TT>all-examples</TT> utility</A>
+<LI><A NAME="tex2html363"
+ HREF="node14.html#SECTION000140000000000000000">
+About this document ... </A>
+</UL>
+<!--End of Table of Child-Links-->
+<BR><HR>
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node1.html
===================================================================
--- /trunk/latex-doc/manual/node1.html	(revision 8)
+++ /trunk/latex-doc/manual/node1.html	(revision 8)
@@ -0,0 +1,2220 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>Contents</TITLE>
+<META NAME="description" CONTENT="Contents">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node2.html">
+<LINK REL="previous" HREF="manual.html">
+<LINK REL="up" HREF="manual.html">
+<LINK REL="next" HREF="node2.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html372"
+ HREF="node2.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html370"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html364"
+ HREF="manual.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A>   
+<BR>
+<B> Next:</B> <A NAME="tex2html373"
+ HREF="node2.html">The Gr&#246;bner Basis package</A>
+<B> Up:</B> <A NAME="tex2html371"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html365"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<BR>
+<H2><A NAME="SECTION00010000000000000000">
+Contents</A>
+</H2>
+<!--Table of Contents-->
+<UL>
+<LI><A NAME="tex2html374"
+ HREF="node1.html#SECTION00010000000000000000">
+Contents</A>
+<LI><A NAME="tex2html375"
+ HREF="node2.html#SECTION00020000000000000000">
+The Gr&#246;bner Basis package</A>
+<UL>
+<LI><A NAME="tex2html376"
+ HREF="node2.html#SECTION00020010000000000000">
+<I>*grobner<MATH CLASS="INLINE">
+-
+</MATH>debug*</I></A>
+<LI><A NAME="tex2html377"
+ HREF="node2.html#SECTION00020020000000000000">
+<I>*buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs*</I></A>
+<LI><A NAME="tex2html378"
+ HREF="node2.html#SECTION00020030000000000000">
+<I>*gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs*</I></A>
+<LI><A NAME="tex2html379"
+ HREF="node2.html#SECTION00020040000000000000">
+<I>*grobner<MATH CLASS="INLINE">
+-
+</MATH>function*</I></A>
+<LI><A NAME="tex2html380"
+ HREF="node2.html#SECTION00020050000000000000">
+<I>select<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>algorithm</I></A>
+<LI><A NAME="tex2html381"
+ HREF="node2.html#SECTION00020060000000000000">
+<I>grobner</I></A>
+<LI><A NAME="tex2html382"
+ HREF="node2.html#SECTION00020070000000000000">
+<I>debug<MATH CLASS="INLINE">
+-
+</MATH>cgb</I></A>
+<LI><A NAME="tex2html383"
+ HREF="node2.html#SECTION00020080000000000000">
+<I>spoly</I></A>
+<LI><A NAME="tex2html384"
+ HREF="node2.html#SECTION00020090000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+<LI><A NAME="tex2html385"
+ HREF="node2.html#SECTION000200100000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>content</I></A>
+<LI><A NAME="tex2html386"
+ HREF="node2.html#SECTION000200110000000000000">
+<I>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html387"
+ HREF="node2.html#SECTION000200120000000000000">
+<I>buchberger</I></A>
+<LI><A NAME="tex2html388"
+ HREF="node2.html#SECTION000200130000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+<LI><A NAME="tex2html389"
+ HREF="node2.html#SECTION000200140000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>sort<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html390"
+ HREF="node2.html#SECTION000200150000000000000">
+<I>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html391"
+ HREF="node2.html#SECTION000200160000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html392"
+ HREF="node2.html#SECTION000200170000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html393"
+ HREF="node2.html#SECTION000200180000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+<LI><A NAME="tex2html394"
+ HREF="node2.html#SECTION000200190000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html395"
+ HREF="node2.html#SECTION000200200000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>coefficient<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html396"
+ HREF="node2.html#SECTION000200210000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>set<MATH CLASS="INLINE">
+-
+</MATH>pair<MATH CLASS="INLINE">
+-
+</MATH>heuristic</I></A>
+<LI><A NAME="tex2html397"
+ HREF="node2.html#SECTION000200220000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html398"
+ HREF="node2.html#SECTION000200230000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html399"
+ HREF="node2.html#SECTION000200240000000000000">
+<I>normalize<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html400"
+ HREF="node2.html#SECTION000200250000000000000">
+<I>normalize<MATH CLASS="INLINE">
+-
+</MATH>basis</I></A>
+<LI><A NAME="tex2html401"
+ HREF="node2.html#SECTION000200260000000000000">
+<I>reduction</I></A>
+<LI><A NAME="tex2html402"
+ HREF="node2.html#SECTION000200270000000000000">
+<I>reduced<MATH CLASS="INLINE">
+-
+</MATH>grobner</I></A>
+<LI><A NAME="tex2html403"
+ HREF="node2.html#SECTION000200280000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html404"
+ HREF="node2.html#SECTION000200290000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html405"
+ HREF="node2.html#SECTION000200300000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html406"
+ HREF="node2.html#SECTION000200310000000000000">
+<I>ring<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+<LI><A NAME="tex2html407"
+ HREF="node2.html#SECTION000200320000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html408"
+ HREF="node2.html#SECTION000200330000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+<LI><A NAME="tex2html409"
+ HREF="node2.html#SECTION000200340000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>contract</I></A>
+<LI><A NAME="tex2html410"
+ HREF="node2.html#SECTION000200350000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html411"
+ HREF="node2.html#SECTION000200360000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html412"
+ HREF="node2.html#SECTION000200370000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+<LI><A NAME="tex2html413"
+ HREF="node2.html#SECTION000200380000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>subsetp</I></A>
+<LI><A NAME="tex2html414"
+ HREF="node2.html#SECTION000200390000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>member</I></A>
+<LI><A NAME="tex2html415"
+ HREF="node2.html#SECTION000200400000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+<LI><A NAME="tex2html416"
+ HREF="node2.html#SECTION000200410000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>subsetp</I></A>
+<LI><A NAME="tex2html417"
+ HREF="node2.html#SECTION000200420000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>member</I></A>
+<LI><A NAME="tex2html418"
+ HREF="node2.html#SECTION000200430000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html419"
+ HREF="node2.html#SECTION000200440000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>variables</I></A>
+<LI><A NAME="tex2html420"
+ HREF="node2.html#SECTION000200450000000000000">
+<I>extend<MATH CLASS="INLINE">
+-
+</MATH>polynomials</I></A>
+<LI><A NAME="tex2html421"
+ HREF="node2.html#SECTION000200460000000000000">
+<I>saturation<MATH CLASS="INLINE">
+-
+</MATH>extension</I></A>
+<LI><A NAME="tex2html422"
+ HREF="node2.html#SECTION000200470000000000000">
+<I>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>extension</I></A>
+<LI><A NAME="tex2html423"
+ HREF="node2.html#SECTION000200480000000000000">
+<I>saturation<MATH CLASS="INLINE">
+-
+</MATH>extension<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html424"
+ HREF="node2.html#SECTION000200490000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html425"
+ HREF="node2.html#SECTION000200500000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation</I></A>
+<LI><A NAME="tex2html426"
+ HREF="node2.html#SECTION000200510000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation</I></A>
+<LI><A NAME="tex2html427"
+ HREF="node2.html#SECTION000200520000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>criterion</I></A>
+<LI><A NAME="tex2html428"
+ HREF="node2.html#SECTION000200530000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>test</I></A>
+<LI><A NAME="tex2html429"
+ HREF="node2.html#SECTION000200540000000000000">
+<I>minimization</I></A>
+<LI><A NAME="tex2html430"
+ HREF="node2.html#SECTION000200550000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>minimized</I></A>
+<LI><A NAME="tex2html431"
+ HREF="node2.html#SECTION000200560000000000000">
+<I>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html432"
+ HREF="node2.html#SECTION000200570000000000000">
+<I>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html433"
+ HREF="node2.html#SECTION000200580000000000000">
+<I>pseudo<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+<LI><A NAME="tex2html434"
+ HREF="node2.html#SECTION000200590000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller</I></A>
+<LI><A NAME="tex2html435"
+ HREF="node2.html#SECTION000200600000000000000">
+<I>update</I></A>
+<LI><A NAME="tex2html436"
+ HREF="node2.html#SECTION000200610000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html437"
+ HREF="node2.html#SECTION000200620000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html438"
+ HREF="node2.html#SECTION000200630000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+<LI><A NAME="tex2html439"
+ HREF="node2.html#SECTION000200640000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html440"
+ HREF="node2.html#SECTION000200650000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>coefficient<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html441"
+ HREF="node2.html#SECTION000200660000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>set<MATH CLASS="INLINE">
+-
+</MATH>pair<MATH CLASS="INLINE">
+-
+</MATH>heuristic</I></A>
+<LI><A NAME="tex2html442"
+ HREF="node2.html#SECTION000200670000000000000">
+<I>spoly<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html443"
+ HREF="node2.html#SECTION000200680000000000000">
+<I>spoly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html444"
+ HREF="node2.html#SECTION000200690000000000000">
+<I>normal<MATH CLASS="INLINE">
+-
+</MATH>form<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html445"
+ HREF="node2.html#SECTION000200700000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html446"
+ HREF="node2.html#SECTION000200710000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html447"
+ HREF="node2.html#SECTION000200720000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sort<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html448"
+ HREF="node2.html#SECTION000200730000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>1<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html449"
+ HREF="node2.html#SECTION000200740000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>2<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html450"
+ HREF="node2.html#SECTION000200750000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html451"
+ HREF="node2.html#SECTION000200760000000000000">
+<I>update<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html452"
+ HREF="node2.html#SECTION000200770000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html453"
+ HREF="node2.html#SECTION000200780000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</UL>
+<LI><A NAME="tex2html454"
+ HREF="node3.html#SECTION00030000000000000000">
+The String Interface to the Gr&#246;bner Basis package</A>
+<UL>
+<LI><A NAME="tex2html455"
+ HREF="node3.html#SECTION00030010000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html456"
+ HREF="node3.html#SECTION00030020000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>grobner</I></A>
+<LI><A NAME="tex2html457"
+ HREF="node3.html#SECTION00030030000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>elimination<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html458"
+ HREF="node3.html#SECTION00030040000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+<LI><A NAME="tex2html459"
+ HREF="node3.html#SECTION00030050000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html460"
+ HREF="node3.html#SECTION00030060000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html461"
+ HREF="node3.html#SECTION00030070000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html462"
+ HREF="node3.html#SECTION00030080000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation</I></A>
+<LI><A NAME="tex2html463"
+ HREF="node3.html#SECTION00030090000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation</I></A>
+<LI><A NAME="tex2html464"
+ HREF="node3.html#SECTION000300100000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html465"
+ HREF="node3.html#SECTION000300110000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>read<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html466"
+ HREF="node3.html#SECTION000300120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>rational<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>integer</I></A>
+<LI><A NAME="tex2html467"
+ HREF="node3.html#SECTION000300130000000000000">
+<I>read<MATH CLASS="INLINE">
+-
+</MATH>vars</I></A>
+</UL>
+<LI><A NAME="tex2html468"
+ HREF="node4.html#SECTION00040000000000000000">
+The Comprehensive Gr&#246;bner basis package</A>
+<UL>
+<LI><A NAME="tex2html469"
+ HREF="node4.html#SECTION00040010000000000000">
+<I>*colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>debug*</I></A>
+<LI><A NAME="tex2html470"
+ HREF="node4.html#SECTION00040020000000000000">
+<I>debug<MATH CLASS="INLINE">
+-
+</MATH>cgb</I></A>
+<LI><A NAME="tex2html471"
+ HREF="node4.html#SECTION00040030000000000000">
+<I>make<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html472"
+ HREF="node4.html#SECTION00040040000000000000">
+<I>make<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html473"
+ HREF="node4.html#SECTION00040050000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html474"
+ HREF="node4.html#SECTION00040060000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html475"
+ HREF="node4.html#SECTION00040070000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html476"
+ HREF="node4.html#SECTION00040080000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html477"
+ HREF="node4.html#SECTION00040090000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html478"
+ HREF="node4.html#SECTION000400100000000000000">
+<I>determine</I></A>
+<LI><A NAME="tex2html479"
+ HREF="node4.html#SECTION000400110000000000000">
+<I>determine<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html480"
+ HREF="node4.html#SECTION000400120000000000000">
+<I>determine<MATH CLASS="INLINE">
+-
+</MATH>white<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+<LI><A NAME="tex2html481"
+ HREF="node4.html#SECTION000400130000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>system<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html482"
+ HREF="node4.html#SECTION000400140000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html483"
+ HREF="node4.html#SECTION000400150000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html484"
+ HREF="node4.html#SECTION000400160000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+<LI><A NAME="tex2html485"
+ HREF="node4.html#SECTION000400170000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>hm</I></A>
+<LI><A NAME="tex2html486"
+ HREF="node4.html#SECTION000400180000000000000">
+<I>delete<MATH CLASS="INLINE">
+-
+</MATH>green<MATH CLASS="INLINE">
+-
+</MATH>polys</I></A>
+<LI><A NAME="tex2html487"
+ HREF="node4.html#SECTION000400190000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+<LI><A NAME="tex2html488"
+ HREF="node4.html#SECTION000400200000000000000">
+<I>reorder<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html489"
+ HREF="node4.html#SECTION000400210000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>criterion<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html490"
+ HREF="node4.html#SECTION000400220000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>criterion<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html491"
+ HREF="node4.html#SECTION000400230000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html492"
+ HREF="node4.html#SECTION000400240000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html493"
+ HREF="node4.html#SECTION000400250000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>lm</I></A>
+<LI><A NAME="tex2html494"
+ HREF="node4.html#SECTION000400260000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>lc</I></A>
+<LI><A NAME="tex2html495"
+ HREF="node4.html#SECTION000400270000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html496"
+ HREF="node4.html#SECTION000400280000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html497"
+ HREF="node4.html#SECTION000400290000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term*</I></A>
+<LI><A NAME="tex2html498"
+ HREF="node4.html#SECTION000400300000000000000">
+<I>color*</I></A>
+<LI><A NAME="tex2html499"
+ HREF="node4.html#SECTION000400310000000000000">
+<I>color+</I></A>
+<LI><A NAME="tex2html500"
+ HREF="node4.html#SECTION000400320000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html501"
+ HREF="node4.html#SECTION000400330000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly+</I></A>
+<LI><A NAME="tex2html502"
+ HREF="node4.html#SECTION000400340000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html503"
+ HREF="node4.html#SECTION000400350000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+<LI><A NAME="tex2html504"
+ HREF="node4.html#SECTION000400360000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html505"
+ HREF="node4.html#SECTION000400370000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+<LI><A NAME="tex2html506"
+ HREF="node4.html#SECTION000400380000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+<LI><A NAME="tex2html507"
+ HREF="node4.html#SECTION000400390000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>cover</I></A>
+<LI><A NAME="tex2html508"
+ HREF="node4.html#SECTION000400400000000000000">
+<I>saturate<MATH CLASS="INLINE">
+-
+</MATH>cover</I></A>
+<LI><A NAME="tex2html509"
+ HREF="node4.html#SECTION000400410000000000000">
+<I>saturate<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+<LI><A NAME="tex2html510"
+ HREF="node4.html#SECTION000400420000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>determine</I></A>
+<LI><A NAME="tex2html511"
+ HREF="node4.html#SECTION000400430000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+<LI><A NAME="tex2html512"
+ HREF="node4.html#SECTION000400440000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>pair</I></A>
+<LI><A NAME="tex2html513"
+ HREF="node4.html#SECTION000400450000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+<LI><A NAME="tex2html514"
+ HREF="node4.html#SECTION000400460000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>reduction</I></A>
+<LI><A NAME="tex2html515"
+ HREF="node4.html#SECTION000400470000000000000">
+<I>green<MATH CLASS="INLINE">
+-
+</MATH>reduce<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html516"
+ HREF="node4.html#SECTION000400480000000000000">
+<I>green<MATH CLASS="INLINE">
+-
+</MATH>reduce<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html517"
+ HREF="node4.html#SECTION000400490000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>system<MATH CLASS="INLINE">
+-
+</MATH>green<MATH CLASS="INLINE">
+-
+</MATH>reduce</I></A>
+<LI><A NAME="tex2html518"
+ HREF="node4.html#SECTION000400500000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html519"
+ HREF="node4.html#SECTION000400510000000000000">
+<I>red<MATH CLASS="INLINE">
+-
+</MATH>reduction</I></A>
+</UL>
+<LI><A NAME="tex2html520"
+ HREF="node5.html#SECTION00050000000000000000">
+The Coefficient Ring package</A>
+<UL>
+<LI><A NAME="tex2html521"
+ HREF="node5.html#SECTION00050010000000000000">
+<I>ring</I></A>
+<LI><A NAME="tex2html522"
+ HREF="node5.html#SECTION00050020000000000000">
+<I>*ring<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>integers*</I></A>
+<LI><A NAME="tex2html523"
+ HREF="node5.html#SECTION00050030000000000000">
+<I>*field<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>rationals*</I></A>
+<LI><A NAME="tex2html524"
+ HREF="node5.html#SECTION00050040000000000000">
+<I>field<MATH CLASS="INLINE">
+-
+</MATH>modulo<MATH CLASS="INLINE">
+-
+</MATH>prime</I></A>
+<LI><A NAME="tex2html525"
+ HREF="node5.html#SECTION00050050000000000000">
+<I>*coefficient<MATH CLASS="INLINE">
+-
+</MATH>ring*</I></A>
+</UL>
+<LI><A NAME="tex2html526"
+ HREF="node6.html#SECTION00060000000000000000">
+The Division Package</A>
+<UL>
+<LI><A NAME="tex2html527"
+ HREF="node6.html#SECTION00060010000000000000">
+<I>divide</I></A>
+<LI><A NAME="tex2html528"
+ HREF="node6.html#SECTION00060020000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>exact<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+</UL>
+<LI><A NAME="tex2html529"
+ HREF="node7.html#SECTION00070000000000000000">
+The Dynamical Systems package</A>
+<UL>
+<LI><A NAME="tex2html530"
+ HREF="node7.html#SECTION00070010000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>composition</I></A>
+<LI><A NAME="tex2html531"
+ HREF="node7.html#SECTION00070020000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>composition</I></A>
+<LI><A NAME="tex2html532"
+ HREF="node7.html#SECTION00070030000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>dynamic<MATH CLASS="INLINE">
+-
+</MATH>power</I></A>
+<LI><A NAME="tex2html533"
+ HREF="node7.html#SECTION00070040000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>evaluate</I></A>
+<LI><A NAME="tex2html534"
+ HREF="node7.html#SECTION00070050000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>evaluate</I></A>
+<LI><A NAME="tex2html535"
+ HREF="node7.html#SECTION00070060000000000000">
+<I>factorial</I></A>
+<LI><A NAME="tex2html536"
+ HREF="node7.html#SECTION00070070000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+<LI><A NAME="tex2html537"
+ HREF="node7.html#SECTION00070080000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+<LI><A NAME="tex2html538"
+ HREF="node7.html#SECTION00070090000000000000">
+<I>standard<MATH CLASS="INLINE">
+-
+</MATH>vector</I></A>
+<LI><A NAME="tex2html539"
+ HREF="node7.html#SECTION000700100000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>partial</I></A>
+<LI><A NAME="tex2html540"
+ HREF="node7.html#SECTION000700110000000000000">
+<I>partial</I></A>
+<LI><A NAME="tex2html541"
+ HREF="node7.html#SECTION000700120000000000000">
+<I>determinant</I></A>
+<LI><A NAME="tex2html542"
+ HREF="node7.html#SECTION000700130000000000000">
+<I>minor</I></A>
+<LI><A NAME="tex2html543"
+ HREF="node7.html#SECTION000700140000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>row</I></A>
+<LI><A NAME="tex2html544"
+ HREF="node7.html#SECTION000700150000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>column</I></A>
+<LI><A NAME="tex2html545"
+ HREF="node7.html#SECTION000700160000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>elt</I></A>
+<LI><A NAME="tex2html546"
+ HREF="node7.html#SECTION000700170000000000000">
+<I>matrix<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html547"
+ HREF="node7.html#SECTION000700180000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html548"
+ HREF="node7.html#SECTION000700190000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html549"
+ HREF="node7.html#SECTION000700200000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html550"
+ HREF="node7.html#SECTION000700210000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>list<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html551"
+ HREF="node7.html#SECTION000700220000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html552"
+ HREF="node7.html#SECTION000700230000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html553"
+ HREF="node7.html#SECTION000700240000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html554"
+ HREF="node7.html#SECTION000700250000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>combination</I></A>
+<LI><A NAME="tex2html555"
+ HREF="node7.html#SECTION000700260000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>combination<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html556"
+ HREF="node7.html#SECTION000700270000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html557"
+ HREF="node7.html#SECTION000700280000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>polynomial</I></A>
+<LI><A NAME="tex2html558"
+ HREF="node7.html#SECTION000700290000000000000">
+<I>identity<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html559"
+ HREF="node7.html#SECTION000700300000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html560"
+ HREF="node7.html#SECTION000700310000000000000">
+<I>jacobi<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html561"
+ HREF="node7.html#SECTION000700320000000000000">
+<I>jacobian</I></A>
+</UL>
+<LI><A NAME="tex2html562"
+ HREF="node8.html#SECTION00080000000000000000">
+The Geometric Theorem Prover package</A>
+<UL>
+<LI><A NAME="tex2html563"
+ HREF="node8.html#SECTION00080010000000000000">
+<I>*prover<MATH CLASS="INLINE">
+-
+</MATH>order*</I></A>
+<LI><A NAME="tex2html564"
+ HREF="node8.html#SECTION00080020000000000000">
+<I>csym</I></A>
+<LI><A NAME="tex2html565"
+ HREF="node8.html#SECTION00080030000000000000">
+<I>real<MATH CLASS="INLINE">
+-
+</MATH>identical<MATH CLASS="INLINE">
+-
+</MATH>points</I></A>
+<LI><A NAME="tex2html566"
+ HREF="node8.html#SECTION00080040000000000000">
+<I>identical<MATH CLASS="INLINE">
+-
+</MATH>points</I></A>
+<LI><A NAME="tex2html567"
+ HREF="node8.html#SECTION00080050000000000000">
+<I>perpendicular</I></A>
+<LI><A NAME="tex2html568"
+ HREF="node8.html#SECTION00080060000000000000">
+<I>parallel</I></A>
+<LI><A NAME="tex2html569"
+ HREF="node8.html#SECTION00080070000000000000">
+<I>collinear</I></A>
+<LI><A NAME="tex2html570"
+ HREF="node8.html#SECTION00080080000000000000">
+<I>equidistant</I></A>
+<LI><A NAME="tex2html571"
+ HREF="node8.html#SECTION00080090000000000000">
+<I>euclidean<MATH CLASS="INLINE">
+-
+</MATH>distance</I></A>
+<LI><A NAME="tex2html572"
+ HREF="node8.html#SECTION000800100000000000000">
+<I>midpoint</I></A>
+<LI><A NAME="tex2html573"
+ HREF="node8.html#SECTION000800110000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>statements</I></A>
+<LI><A NAME="tex2html574"
+ HREF="node8.html#SECTION000800120000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>assumptions</I></A>
+<LI><A NAME="tex2html575"
+ HREF="node8.html#SECTION000800130000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>conclusions</I></A>
+<LI><A NAME="tex2html576"
+ HREF="node8.html#SECTION000800140000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>theorem</I></A>
+<LI><A NAME="tex2html577"
+ HREF="node8.html#SECTION000800150000000000000">
+<I>prove<MATH CLASS="INLINE">
+-
+</MATH>theorem</I></A>
+</UL>
+<LI><A NAME="tex2html578"
+ HREF="node9.html#SECTION00090000000000000000">
+The Monomial Order Package</A>
+<UL>
+<LI><A NAME="tex2html579"
+ HREF="node9.html#SECTION00090010000000000000">
+<I>lex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html580"
+ HREF="node9.html#SECTION00090020000000000000">
+<I>total<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+<LI><A NAME="tex2html581"
+ HREF="node9.html#SECTION00090030000000000000">
+<I>grlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html582"
+ HREF="node9.html#SECTION00090040000000000000">
+<I>grevlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html583"
+ HREF="node9.html#SECTION00090050000000000000">
+<I>revlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html584"
+ HREF="node9.html#SECTION00090060000000000000">
+<I>invlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html585"
+ HREF="node9.html#SECTION00090070000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>order</I></A>
+<LI><A NAME="tex2html586"
+ HREF="node9.html#SECTION00090080000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>order<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</UL>
+<LI><A NAME="tex2html587"
+ HREF="node10.html#SECTION000100000000000000000">
+The Polynomial Package</A>
+<UL>
+<LI><A NAME="tex2html588"
+ HREF="node10.html#SECTION000100010000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html589"
+ HREF="node10.html#SECTION000100020000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html590"
+ HREF="node10.html#SECTION000100030000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html591"
+ HREF="node10.html#SECTION000100040000000000000">
+<I>minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html592"
+ HREF="node10.html#SECTION000100050000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html593"
+ HREF="node10.html#SECTION000100060000000000000">
+<I>poly+</I></A>
+<LI><A NAME="tex2html594"
+ HREF="node10.html#SECTION000100070000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html595"
+ HREF="node10.html#SECTION000100080000000000000">
+<I>poly*</I></A>
+<LI><A NAME="tex2html596"
+ HREF="node10.html#SECTION000100090000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+<LI><A NAME="tex2html597"
+ HREF="node10.html#SECTION0001000100000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+<LI><A NAME="tex2html598"
+ HREF="node10.html#SECTION0001000110000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>mexpt</I></A>
+<LI><A NAME="tex2html599"
+ HREF="node10.html#SECTION0001000120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>constant<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html600"
+ HREF="node10.html#SECTION0001000130000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>extend</I></A>
+<LI><A NAME="tex2html601"
+ HREF="node10.html#SECTION0001000140000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>extend<MATH CLASS="INLINE">
+-
+</MATH>end</I></A>
+<LI><A NAME="tex2html602"
+ HREF="node10.html#SECTION0001000150000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+<LI><A NAME="tex2html603"
+ HREF="node10.html#SECTION0001000160000000000000">
+<I>lt</I></A>
+<LI><A NAME="tex2html604"
+ HREF="node10.html#SECTION0001000170000000000000">
+<I>lm</I></A>
+<LI><A NAME="tex2html605"
+ HREF="node10.html#SECTION0001000180000000000000">
+<I>lc</I></A>
+</UL>
+<LI><A NAME="tex2html606"
+ HREF="node11.html#SECTION000110000000000000000">
+The Parser Package</A>
+<UL>
+<LI><A NAME="tex2html607"
+ HREF="node11.html#SECTION000110010000000000000">
+<I>parse</I></A>
+<LI><A NAME="tex2html608"
+ HREF="node11.html#SECTION000110020000000000000">
+<I>alist<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html609"
+ HREF="node11.html#SECTION000110030000000000000">
+<I>alist<MATH CLASS="INLINE">
+-
+</MATH>form<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html610"
+ HREF="node11.html#SECTION000110040000000000000">
+<I>powers</I></A>
+<LI><A NAME="tex2html611"
+ HREF="node11.html#SECTION000110050000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html612"
+ HREF="node11.html#SECTION000110060000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>string<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html613"
+ HREF="node11.html#SECTION000110070000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>sorted<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html614"
+ HREF="node11.html#SECTION000110080000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>string<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>sorted<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html615"
+ HREF="node11.html#SECTION000110090000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html616"
+ HREF="node11.html#SECTION0001100100000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html617"
+ HREF="node11.html#SECTION0001100110000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>eval<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html618"
+ HREF="node11.html#SECTION0001100120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>eval</I></A>
+<LI><A NAME="tex2html619"
+ HREF="node11.html#SECTION0001100130000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>basis</I></A>
+<LI><A NAME="tex2html620"
+ HREF="node11.html#SECTION0001100140000000000000">
+<I>convert<MATH CLASS="INLINE">
+-
+</MATH>number</I></A>
+<LI><A NAME="tex2html621"
+ HREF="node11.html#SECTION0001100150000000000000">
+<I>$poly+</I></A>
+<LI><A NAME="tex2html622"
+ HREF="node11.html#SECTION0001100160000000000000">
+<I>$poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html623"
+ HREF="node11.html#SECTION0001100170000000000000">
+<I>$minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html624"
+ HREF="node11.html#SECTION0001100180000000000000">
+<I>$poly*</I></A>
+<LI><A NAME="tex2html625"
+ HREF="node11.html#SECTION0001100190000000000000">
+<I>$poly/</I></A>
+<LI><A NAME="tex2html626"
+ HREF="node11.html#SECTION0001100200000000000000">
+<I>$poly<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+</UL>
+<LI><A NAME="tex2html627"
+ HREF="node12.html#SECTION000120000000000000000">
+Other packages</A>
+<UL>
+<LI><A NAME="tex2html628"
+ HREF="node12.html#SECTION000120010000000000000">
+<I>makelist<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html629"
+ HREF="node12.html#SECTION000120020000000000000">
+<I>makelist</I></A>
+<LI><A NAME="tex2html630"
+ HREF="node12.html#SECTION000120030000000000000">
+<I>sum</I></A>
+<LI><A NAME="tex2html631"
+ HREF="node12.html#SECTION000120040000000000000">
+<I>list<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+<LI><A NAME="tex2html632"
+ HREF="node12.html#SECTION000120050000000000000">
+<I>list<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html633"
+ HREF="node12.html#SECTION000120060000000000000">
+<I>union<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+<LI><A NAME="tex2html634"
+ HREF="node12.html#SECTION000120070000000000000">
+<I>union<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html635"
+ HREF="node12.html#SECTION000120080000000000000">
+<I>set<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+<LI><A NAME="tex2html636"
+ HREF="node12.html#SECTION000120090000000000000">
+<I>set<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html637"
+ HREF="node12.html#SECTION0001200100000000000000">
+<I>select</I></A>
+<LI><A NAME="tex2html638"
+ HREF="node12.html#SECTION0001200110000000000000">
+<I>monom/</I></A>
+<LI><A NAME="tex2html639"
+ HREF="node12.html#SECTION0001200120000000000000">
+<I>monom*</I></A>
+<LI><A NAME="tex2html640"
+ HREF="node12.html#SECTION0001200130000000000000">
+<I>nmonom*</I></A>
+<LI><A NAME="tex2html641"
+ HREF="node12.html#SECTION0001200140000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>divides<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html642"
+ HREF="node12.html#SECTION0001200150000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>divisible<MATH CLASS="INLINE">
+-
+</MATH>by<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html643"
+ HREF="node12.html#SECTION0001200160000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>rel<MATH CLASS="INLINE">
+-
+</MATH>prime</I></A>
+<LI><A NAME="tex2html644"
+ HREF="node12.html#SECTION0001200170000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+<LI><A NAME="tex2html645"
+ HREF="node12.html#SECTION0001200180000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html646"
+ HREF="node12.html#SECTION0001200190000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html647"
+ HREF="node12.html#SECTION0001200200000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html648"
+ HREF="node12.html#SECTION0001200210000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>pseudo<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+<LI><A NAME="tex2html649"
+ HREF="node12.html#SECTION0001200220000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>pseudo<MATH CLASS="INLINE">
+-
+</MATH>remainder</I></A>
+<LI><A NAME="tex2html650"
+ HREF="node12.html#SECTION0001200230000000000000">
+<I>mdeg</I></A>
+<LI><A NAME="tex2html651"
+ HREF="node12.html#SECTION0001200240000000000000">
+<I>lcoeff</I></A>
+<LI><A NAME="tex2html652"
+ HREF="node12.html#SECTION0001200250000000000000">
+<I>lrest</I></A>
+<LI><A NAME="tex2html653"
+ HREF="node12.html#SECTION0001200260000000000000">
+<I>lpart</I></A>
+<LI><A NAME="tex2html654"
+ HREF="node12.html#SECTION0001200270000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+<LI><A NAME="tex2html655"
+ HREF="node12.html#SECTION0001200280000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>content</I></A>
+<LI><A NAME="tex2html656"
+ HREF="node12.html#SECTION0001200290000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html657"
+ HREF="node12.html#SECTION0001200300000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html658"
+ HREF="node12.html#SECTION0001200310000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>tail</I></A>
+<LI><A NAME="tex2html659"
+ HREF="node12.html#SECTION0001200320000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>poly)</I></A>
+<LI><A NAME="tex2html660"
+ HREF="node12.html#SECTION0001200330000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sugar)</I></A>
+<LI><A NAME="tex2html661"
+ HREF="node12.html#SECTION0001200340000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>tail)</I></A>
+<LI><A NAME="tex2html662"
+ HREF="node12.html#SECTION0001200350000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html663"
+ HREF="node12.html#SECTION0001200360000000000000">
+<I>coefficient<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html664"
+ HREF="node12.html#SECTION0001200370000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html665"
+ HREF="node12.html#SECTION0001200380000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>add<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html666"
+ HREF="node12.html#SECTION0001200390000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html667"
+ HREF="node12.html#SECTION0001200400000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html668"
+ HREF="node12.html#SECTION0001200410000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html669"
+ HREF="node12.html#SECTION0001200420000000000000">
+<I>minus<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html670"
+ HREF="node12.html#SECTION0001200430000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar+</I></A>
+<LI><A NAME="tex2html671"
+ HREF="node12.html#SECTION0001200440000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html672"
+ HREF="node12.html#SECTION0001200450000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+<LI><A NAME="tex2html673"
+ HREF="node12.html#SECTION0001200460000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>nreverse</I></A>
+<LI><A NAME="tex2html674"
+ HREF="node12.html#SECTION0001200470000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>append</I></A>
+<LI><A NAME="tex2html675"
+ HREF="node12.html#SECTION0001200480000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+<LI><A NAME="tex2html676"
+ HREF="node12.html#SECTION0001200490000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lm</I></A>
+<LI><A NAME="tex2html677"
+ HREF="node12.html#SECTION0001200500000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lc</I></A>
+<LI><A NAME="tex2html678"
+ HREF="node12.html#SECTION0001200510000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lt</I></A>
+<LI><A NAME="tex2html679"
+ HREF="node12.html#SECTION0001200520000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html680"
+ HREF="node12.html#SECTION0001200530000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html681"
+ HREF="node12.html#SECTION0001200540000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html682"
+ HREF="node12.html#SECTION0001200550000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+<LI><A NAME="tex2html683"
+ HREF="node12.html#SECTION0001200560000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>monom</I></A>
+<LI><A NAME="tex2html684"
+ HREF="node12.html#SECTION0001200570000000000000">
+<I>num</I></A>
+<LI><A NAME="tex2html685"
+ HREF="node12.html#SECTION0001200580000000000000">
+<I>denom</I></A>
+<LI><A NAME="tex2html686"
+ HREF="node12.html#SECTION0001200590000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>simplify<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html687"
+ HREF="node12.html#SECTION0001200600000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>simplify</I></A>
+<LI><A NAME="tex2html688"
+ HREF="node12.html#SECTION0001200610000000000000">
+<I>rat+</I></A>
+<LI><A NAME="tex2html689"
+ HREF="node12.html#SECTION0001200620000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html690"
+ HREF="node12.html#SECTION0001200630000000000000">
+<I>rat*</I></A>
+<LI><A NAME="tex2html691"
+ HREF="node12.html#SECTION0001200640000000000000">
+<I>rat/</I></A>
+<LI><A NAME="tex2html692"
+ HREF="node12.html#SECTION0001200650000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>rat</I></A>
+<LI><A NAME="tex2html693"
+ HREF="node12.html#SECTION0001200660000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>div<MATH CLASS="INLINE">
+-
+</MATH>rat</I></A>
+<LI><A NAME="tex2html694"
+ HREF="node12.html#SECTION0001200670000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+<LI><A NAME="tex2html695"
+ HREF="node12.html#SECTION0001200680000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+<LI><A NAME="tex2html696"
+ HREF="node12.html#SECTION0001200690000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+<LI><A NAME="tex2html697"
+ HREF="node12.html#SECTION0001200700000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>constant</I></A>
+<LI><A NAME="tex2html698"
+ HREF="node12.html#SECTION0001200710000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html699"
+ HREF="node12.html#SECTION0001200720000000000000">
+<I>ratpoly+</I></A>
+<LI><A NAME="tex2html700"
+ HREF="node12.html#SECTION0001200730000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html701"
+ HREF="node12.html#SECTION0001200740000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+<LI><A NAME="tex2html702"
+ HREF="node12.html#SECTION0001200750000000000000">
+<I>ratpoly*</I></A>
+<LI><A NAME="tex2html703"
+ HREF="node12.html#SECTION0001200760000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html704"
+ HREF="node12.html#SECTION0001200770000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html705"
+ HREF="node12.html#SECTION0001200780000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+<LI><A NAME="tex2html706"
+ HREF="node12.html#SECTION0001200790000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>remainder</I></A>
+<LI><A NAME="tex2html707"
+ HREF="node12.html#SECTION0001200800000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html708"
+ HREF="node12.html#SECTION0001200810000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+<LI><A NAME="tex2html709"
+ HREF="node12.html#SECTION0001200820000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>square<MATH CLASS="INLINE">
+-
+</MATH>free</I></A>
+<LI><A NAME="tex2html710"
+ HREF="node12.html#SECTION0001200830000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>normalize</I></A>
+<LI><A NAME="tex2html711"
+ HREF="node12.html#SECTION0001200840000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>resultant</I></A>
+<LI><A NAME="tex2html712"
+ HREF="node12.html#SECTION0001200850000000000000">
+<I>deg</I></A>
+<LI><A NAME="tex2html713"
+ HREF="node12.html#SECTION0001200860000000000000">
+<I>lead</I></A>
+<LI><A NAME="tex2html714"
+ HREF="node12.html#SECTION0001200870000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>discriminant</I></A>
+<LI><A NAME="tex2html715"
+ HREF="node12.html#SECTION0001200880000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html716"
+ HREF="node12.html#SECTION0001200890000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html717"
+ HREF="node12.html#SECTION0001200900000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly1</I></A>
+<LI><A NAME="tex2html718"
+ HREF="node12.html#SECTION0001200910000000000000">
+<I>poly1<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html719"
+ HREF="node12.html#SECTION0001200920000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly1</I></A>
+<LI><A NAME="tex2html720"
+ HREF="node12.html#SECTION0001200930000000000000">
+<I>poly1<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html721"
+ HREF="node12.html#SECTION0001200940000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html722"
+ HREF="node12.html#SECTION0001200950000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>resultant</I></A>
+<LI><A NAME="tex2html723"
+ HREF="node12.html#SECTION0001200960000000000000">
+<I>term*</I></A>
+<LI><A NAME="tex2html724"
+ HREF="node12.html#SECTION0001200970000000000000">
+<I>term/</I></A>
+<LI><A NAME="tex2html725"
+ HREF="node12.html#SECTION0001200980000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+<LI><A NAME="tex2html726"
+ HREF="node12.html#SECTION0001200990000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>divides<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html727"
+ HREF="node12.html#SECTION00012001000000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>monom</I></A>
+<LI><A NAME="tex2html728"
+ HREF="node12.html#SECTION00012001010000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>coefficient</I></A>
+<LI><A NAME="tex2html729"
+ HREF="node12.html#SECTION00012001020000000000000">
+<I>(setf term<MATH CLASS="INLINE">
+-
+</MATH>monom)</I></A>
+<LI><A NAME="tex2html730"
+ HREF="node12.html#SECTION00012001030000000000000">
+<I>(setf term<MATH CLASS="INLINE">
+-
+</MATH>coefficient)</I></A>
+<LI><A NAME="tex2html731"
+ HREF="node12.html#SECTION00012001040000000000000">
+<I>xgcd</I></A>
+</UL>
+<LI><A NAME="tex2html732"
+ HREF="node13.html#SECTION000130000000000000000">
+All examples produced by the <TT>all-examples</TT> utility</A>
+</UL>
+<!--End of Table of Contents-->
+<BR><HR>
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node10.html
===================================================================
--- /trunk/latex-doc/manual/node10.html	(revision 8)
+++ /trunk/latex-doc/manual/node10.html	(revision 8)
@@ -0,0 +1,369 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>The Polynomial Package</TITLE>
+<META NAME="description" CONTENT="The Polynomial Package">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node11.html">
+<LINK REL="previous" HREF="node9.html">
+<LINK REL="up" HREF="manual.html">
+<LINK REL="next" HREF="node11.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html1034"
+ HREF="node11.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html1031"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html1025"
+ HREF="node9.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html1033"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html1035"
+ HREF="node11.html">The Parser Package</A>
+<B> Up:</B> <A NAME="tex2html1032"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html1026"
+ HREF="node9.html">The Monomial Order Package</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<!--Table of Child-Links-->
+<A NAME="CHILD_LINKS"><strong>Subsections</strong></A>
+<UL>
+<LI><A NAME="tex2html1036"
+ HREF="node10.html#SECTION000100010000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html1037"
+ HREF="node10.html#SECTION000100020000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html1038"
+ HREF="node10.html#SECTION000100030000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html1039"
+ HREF="node10.html#SECTION000100040000000000000">
+<I>minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html1040"
+ HREF="node10.html#SECTION000100050000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html1041"
+ HREF="node10.html#SECTION000100060000000000000">
+<I>poly+</I></A>
+<LI><A NAME="tex2html1042"
+ HREF="node10.html#SECTION000100070000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html1043"
+ HREF="node10.html#SECTION000100080000000000000">
+<I>poly*</I></A>
+<LI><A NAME="tex2html1044"
+ HREF="node10.html#SECTION000100090000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+<LI><A NAME="tex2html1045"
+ HREF="node10.html#SECTION0001000100000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+<LI><A NAME="tex2html1046"
+ HREF="node10.html#SECTION0001000110000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>mexpt</I></A>
+<LI><A NAME="tex2html1047"
+ HREF="node10.html#SECTION0001000120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>constant<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html1048"
+ HREF="node10.html#SECTION0001000130000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>extend</I></A>
+<LI><A NAME="tex2html1049"
+ HREF="node10.html#SECTION0001000140000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>extend<MATH CLASS="INLINE">
+-
+</MATH>end</I></A>
+<LI><A NAME="tex2html1050"
+ HREF="node10.html#SECTION0001000150000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+<LI><A NAME="tex2html1051"
+ HREF="node10.html#SECTION0001000160000000000000">
+<I>lt</I></A>
+<LI><A NAME="tex2html1052"
+ HREF="node10.html#SECTION0001000170000000000000">
+<I>lm</I></A>
+<LI><A NAME="tex2html1053"
+ HREF="node10.html#SECTION0001000180000000000000">
+<I>lc</I></A>
+</UL>
+<!--End of Table of Child-Links-->
+<HR>
+<H1><A NAME="SECTION000100000000000000000">
+The Polynomial Package</A>
+</H1>
+<H4><A NAME="SECTION000100010000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="481" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img153.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c p {\sf \&optional} (ring *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return product of a scalar C by a polynomial P with coefficient ring
+RING. </BLOCKQUOTE><H4><A NAME="SECTION000100020000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="488" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img154.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term f {\sf \&optional} (ring *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return product of a term TERM by a polynomial F with coefficient ring
+RING. </BLOCKQUOTE><H4><A NAME="SECTION000100030000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="453" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img129.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return product of a monomial M by a polynomial F with coefficient
+ring RING. </BLOCKQUOTE><H4><A NAME="SECTION000100040000000000000">
+<I>minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="529" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img155.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (ring *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Changes the sign of a polynomial F with coefficients in coefficient
+ring RING, and returns the result.</BLOCKQUOTE><H4><A NAME="SECTION000100050000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="544" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img156.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly {\sf \&optional} (pred
+ \char93 'lex$\gt$) (start
+ 0) (end
+ (unless
+ (null poly)
+ (length
+ (caar poly)))) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Destructively Sorts a polynomial POLY by predicate PRED; the
+predicate is assumed to take arguments START and END in addition to
+the pair of monomials, as the functions in the ORDER package do.</BLOCKQUOTE><H4><A NAME="SECTION000100060000000000000">
+<I>poly+</I></A>
+</H4>
+<P><IMG WIDTH="570" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img157.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q {\sf \&optional} (pred \char93 'lex$\gt$) (ring *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the sum of two polynomials P and Q with coefficients in
+ring RING, with terms ordered according to monomial order PRED.</BLOCKQUOTE><H4><A NAME="SECTION000100070000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="570" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img157.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q {\sf \&optional} (pred \char93 'lex$\gt$) (ring *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the difference of two polynomials P and Q with coefficients
+in ring RING, with terms ordered according to monomial order PRED.</BLOCKQUOTE><H4><A NAME="SECTION000100080000000000000">
+<I>poly*</I></A>
+</H4>
+<P><IMG WIDTH="570" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img157.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q {\sf \&optional} (pred \char93 'lex$\gt$) (ring *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the product of two polynomials P and Q with coefficients in
+ring RING, with terms ordered according to monomial order PRED.</BLOCKQUOTE><H4><A NAME="SECTION000100090000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+</H4>
+<P><IMG WIDTH="553" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img158.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f m g pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns F<MATH CLASS="INLINE">
+-
+</MATH>M*G, where F and G are polynomials with coefficients in
+ring RING, ordered according to monomial order PRED and M is a
+monomial.</BLOCKQUOTE><H4><A NAME="SECTION0001000100000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+</H4>
+<P><IMG WIDTH="540" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img159.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly n {\sf \&optional} (pred
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Exponentiate a polynomial POLY to power N. The terms of the
+polynomial are assumed to be ordered by monomial order PRED and with
+coefficients in ring RING.  Use the Chinese algorithm; assume N<MATH CLASS="INLINE">
+&gt;
+</MATH>=0
+and POLY is non<MATH CLASS="INLINE">
+-
+</MATH>zero (not NIL).</BLOCKQUOTE><H4><A NAME="SECTION0001000110000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>mexpt</I></A>
+</H4>
+<P><IMG WIDTH="527" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img160.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist monom {\sf \&optional} (pred
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Raise a polynomial vector represented ad a list of polynomials
+PLIST to power MULTIINDEX.  Every polynomial has its terms ordered by
+predicate PRED and coefficients in the ring RING.</BLOCKQUOTE><H4><A NAME="SECTION0001000120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>constant<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if P is a constant polynomial.</BLOCKQUOTE><H4><A NAME="SECTION0001000130000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>extend</I></A>
+</H4>
+<P><IMG WIDTH="524" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img161.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p {\sf \&optional} (m (list 0)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Given a polynomial P in k[x[r+1],...,xn], it returns the same
+polynomial as an element of k[x1,...,xn], optionally multiplying it
+by a monomial x1&#94;m1*x2&#94;m2*...*xr&#94;mr,
+where m=(m1,m2,...,mr) is a multiindex.</BLOCKQUOTE><H4><A NAME="SECTION0001000140000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>extend<MATH CLASS="INLINE">
+-
+</MATH>end</I></A>
+</H4>
+<P><IMG WIDTH="524" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img161.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p {\sf \&optional} (m (list 0)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Similar to POLY<MATH CLASS="INLINE">
+-
+</MATH>EXTEND, but it adds new variables at the end.</BLOCKQUOTE><H4><A NAME="SECTION0001000150000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if P is a zero polynomial.</BLOCKQUOTE><H4><A NAME="SECTION0001000160000000000000">
+<I>lt</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the leading term of a polynomial P.</BLOCKQUOTE><H4><A NAME="SECTION0001000170000000000000">
+<I>lm</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the leading monomial of a polynomial P.</BLOCKQUOTE><H4><A NAME="SECTION0001000180000000000000">
+<I>lc</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the leading coefficient of a polynomial P.</BLOCKQUOTE><HR>
+<!--Navigation Panel-->
+<A NAME="tex2html1034"
+ HREF="node11.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html1031"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html1025"
+ HREF="node9.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html1033"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html1035"
+ HREF="node11.html">The Parser Package</A>
+<B> Up:</B> <A NAME="tex2html1032"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html1026"
+ HREF="node9.html">The Monomial Order Package</A>
+<!--End of Navigation Panel-->
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node11.html
===================================================================
--- /trunk/latex-doc/manual/node11.html	(revision 8)
+++ /trunk/latex-doc/manual/node11.html	(revision 8)
@@ -0,0 +1,639 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>The Parser Package</TITLE>
+<META NAME="description" CONTENT="The Parser Package">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node12.html">
+<LINK REL="previous" HREF="node10.html">
+<LINK REL="up" HREF="manual.html">
+<LINK REL="next" HREF="node12.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html1063"
+ HREF="node12.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html1060"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html1054"
+ HREF="node10.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html1062"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html1064"
+ HREF="node12.html">Other packages</A>
+<B> Up:</B> <A NAME="tex2html1061"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html1055"
+ HREF="node10.html">The Polynomial Package</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<!--Table of Child-Links-->
+<A NAME="CHILD_LINKS"><strong>Subsections</strong></A>
+<UL>
+<LI><A NAME="tex2html1065"
+ HREF="node11.html#SECTION000110010000000000000">
+<I>parse</I></A>
+<LI><A NAME="tex2html1066"
+ HREF="node11.html#SECTION000110020000000000000">
+<I>alist<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html1067"
+ HREF="node11.html#SECTION000110030000000000000">
+<I>alist<MATH CLASS="INLINE">
+-
+</MATH>form<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html1068"
+ HREF="node11.html#SECTION000110040000000000000">
+<I>powers</I></A>
+<LI><A NAME="tex2html1069"
+ HREF="node11.html#SECTION000110050000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html1070"
+ HREF="node11.html#SECTION000110060000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>string<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html1071"
+ HREF="node11.html#SECTION000110070000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>sorted<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html1072"
+ HREF="node11.html#SECTION000110080000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>string<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>sorted<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+<LI><A NAME="tex2html1073"
+ HREF="node11.html#SECTION000110090000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html1074"
+ HREF="node11.html#SECTION0001100100000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html1075"
+ HREF="node11.html#SECTION0001100110000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>eval<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html1076"
+ HREF="node11.html#SECTION0001100120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>eval</I></A>
+<LI><A NAME="tex2html1077"
+ HREF="node11.html#SECTION0001100130000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>basis</I></A>
+<LI><A NAME="tex2html1078"
+ HREF="node11.html#SECTION0001100140000000000000">
+<I>convert<MATH CLASS="INLINE">
+-
+</MATH>number</I></A>
+<LI><A NAME="tex2html1079"
+ HREF="node11.html#SECTION0001100150000000000000">
+<I>$poly+</I></A>
+<LI><A NAME="tex2html1080"
+ HREF="node11.html#SECTION0001100160000000000000">
+<I>$poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html1081"
+ HREF="node11.html#SECTION0001100170000000000000">
+<I>$minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html1082"
+ HREF="node11.html#SECTION0001100180000000000000">
+<I>$poly*</I></A>
+<LI><A NAME="tex2html1083"
+ HREF="node11.html#SECTION0001100190000000000000">
+<I>$poly/</I></A>
+<LI><A NAME="tex2html1084"
+ HREF="node11.html#SECTION0001100200000000000000">
+<I>$poly<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+</UL>
+<!--End of Table of Child-Links-->
+<HR>
+<H1><A NAME="SECTION000110000000000000000">
+The Parser Package</A>
+</H1>
+<H4><A NAME="SECTION000110010000000000000">
+<I>parse</I></A>
+</H4>
+<P><IMG WIDTH="576" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img162.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em {\sf \&optional} stream \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Parser of infis expressions with integer/rational coefficients
+The parser will recognize two kinds of polynomial expressions:
+<MATH CLASS="INLINE">
+-
+</MATH> polynomials in fully expanded forms with coefficients
+ written in front of symbolic expressions; constants can be
+optionally enclosed in (); for example, the infix form
+X&#94;2<MATH CLASS="INLINE">
+-
+</MATH>Y&#94;2+(<MATH CLASS="INLINE">
+-
+</MATH>4/3)*U&#94;2*W&#94;3<MATH CLASS="INLINE">
+-
+</MATH>5 parses to
+	(+ (<MATH CLASS="INLINE">
+-
+</MATH> (EXPT X 2) (EXPT Y 2)) (* (<MATH CLASS="INLINE">
+-
+</MATH> (/ 4 3)) (EXPT U 2) (EXPT W
+3)) (<MATH CLASS="INLINE">
+-
+</MATH> 5)) 
+<MATH CLASS="INLINE">
+-
+</MATH> lists of polynomials; for example
+       [X<MATH CLASS="INLINE">
+-
+</MATH>Y, X&#94;2+3*Z]          
+ parses to
+	  (:[ (<MATH CLASS="INLINE">
+-
+</MATH> X Y) (+ (EXPT X 2) (* 3 Z)))
+ where the first symbol [ marks a list of polynomials.
+<MATH CLASS="INLINE">
+-
+</MATH>other infix expressions, for example
+       [(X<MATH CLASS="INLINE">
+-
+</MATH>Y)*(X+Y)/Z,(X+1)&#94;2]
+parses to:
+	(:[ (/ (* (<MATH CLASS="INLINE">
+-
+</MATH> X Y) (+ X Y)) Z) (EXPT (+ X 1) 2))
+Currently this function is implemented using M. Kantrowitz's INFIX
+package. </BLOCKQUOTE><H4><A NAME="SECTION000110020000000000000">
+<I>alist<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+</H4>
+<P><IMG WIDTH="539" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img163.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist vars \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Translates an expression PLIST, which should be a list of polynomials
+in variables VARS, to an alist representation of a polynomial.
+It returns the alist. See also PARSE<MATH CLASS="INLINE">
+-
+</MATH>TO<MATH CLASS="INLINE">
+-
+</MATH>ALIST.</BLOCKQUOTE><H4><A NAME="SECTION000110030000000000000">
+<I>alist<MATH CLASS="INLINE">
+-
+</MATH>form<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="517" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img164.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p vars {\sf \&aux} (ht
+ (make$-$hash$-$table
+ :test
+ \char93 'equal
+ :size
+ 16)) stack \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000110040000000000000">
+<I>powers</I></A>
+</H4>
+<P><IMG WIDTH="564" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img165.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em monom vars {\sf \&aux} (tab
+ (pairlis vars
+ (make$-$list (length vars)
+ :initial$-$element 0))) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000110050000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+</H4>
+<P><IMG WIDTH="508" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img166.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em vars {\sf \&optional} stream \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Parse an expression already in prefix form to an association list
+form according to the internal CGBlisp polynomial syntax: a
+polynomial is an alist of pairs (MONOM . COEFFICIENT). For example:
+ (WITH<MATH CLASS="INLINE">
+-
+</MATH>INPUT<MATH CLASS="INLINE">
+-
+</MATH>FROM<MATH CLASS="INLINE">
+-
+</MATH>STRING (S
+&quot;X&#94;2<MATH CLASS="INLINE">
+-
+</MATH>Y&#94;2+(<MATH CLASS="INLINE">
+-
+</MATH>4/3)*U&#94;2*W&#94;3<MATH CLASS="INLINE">
+-
+</MATH>5&quot;) (PARSE<MATH CLASS="INLINE">
+-
+</MATH>TO<MATH CLASS="INLINE">
+-
+</MATH>ALIST '(X Y U W) S))
+evaluates to
+(((0 0 2 3) . <MATH CLASS="INLINE">
+-
+</MATH>4/3) ((0 2 0 0) . <MATH CLASS="INLINE">
+-
+</MATH>1) ((2 0 0 0) . 1) ((0 0 0 0) .
+<MATH CLASS="INLINE">
+-
+</MATH>5)) </BLOCKQUOTE><H4><A NAME="SECTION000110060000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>string<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+</H4>
+<P><IMG WIDTH="456" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img167.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em str vars \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Parse string STR and return a polynomial as a sorted association
+list of pairs (MONOM . COEFFICIENT). For example:
+(parse<MATH CLASS="INLINE">
+-
+</MATH>string<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>alist
+&quot;[x&#94;2<MATH CLASS="INLINE">
+-
+</MATH>y&#94;2+(<MATH CLASS="INLINE">
+-
+</MATH>4/3)*u&#94;2*w&#94;3<MATH CLASS="INLINE">
+-
+</MATH>5,y]&quot; '(x y u w)) ([ (((0 0 2 3) . <MATH CLASS="INLINE">
+-
+</MATH>4/3) ((0 2 0 0) . <MATH CLASS="INLINE">
+-
+</MATH>1) ((2 0 0 0) . 1)
+    ((0 0 0 0) . <MATH CLASS="INLINE">
+-
+</MATH>5))
+   (((0 1 0 0) . 1)))
+The functions PARSE<MATH CLASS="INLINE">
+-
+</MATH>TO<MATH CLASS="INLINE">
+-
+</MATH>SORTED<MATH CLASS="INLINE">
+-
+</MATH>ALIST and
+PARSE<MATH CLASS="INLINE">
+-
+</MATH>STRING<MATH CLASS="INLINE">
+-
+</MATH>TO<MATH CLASS="INLINE">
+-
+</MATH>SORTED<MATH CLASS="INLINE">
+-
+</MATH>ALIST sort terms by the predicate
+defined in the ORDER package. </BLOCKQUOTE><H4><A NAME="SECTION000110070000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>sorted<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+</H4>
+<P><IMG WIDTH="453" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img168.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em vars {\sf \&optional} (order
+ \char93 'lex$\gt$) (stream t) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Parses streasm STREAM and returns a polynomial represented as 
+a sorted alist. For example:
+(WITH<MATH CLASS="INLINE">
+-
+</MATH>INPUT<MATH CLASS="INLINE">
+-
+</MATH>FROM<MATH CLASS="INLINE">
+-
+</MATH>STRING (S
+&quot;X&#94;2<MATH CLASS="INLINE">
+-
+</MATH>Y&#94;2+(<MATH CLASS="INLINE">
+-
+</MATH>4/3)*U&#94;2*W&#94;3<MATH CLASS="INLINE">
+-
+</MATH>5&quot;) (PARSE<MATH CLASS="INLINE">
+-
+</MATH>TO<MATH CLASS="INLINE">
+-
+</MATH>SORTED<MATH CLASS="INLINE">
+-
+</MATH>ALIST '(X Y U W) S))
+returns
+(((2 0 0 0) . 1) ((0 2 0 0) . <MATH CLASS="INLINE">
+-
+</MATH>1) ((0 0 2 3) . <MATH CLASS="INLINE">
+-
+</MATH>4/3) ((0 0 0 0) .
+<MATH CLASS="INLINE">
+-
+</MATH>5)) and
+(WITH<MATH CLASS="INLINE">
+-
+</MATH>INPUT<MATH CLASS="INLINE">
+-
+</MATH>FROM<MATH CLASS="INLINE">
+-
+</MATH>STRING (S
+&quot;X&#94;2<MATH CLASS="INLINE">
+-
+</MATH>Y&#94;2+(<MATH CLASS="INLINE">
+-
+</MATH>4/3)*U&#94;2*W&#94;3<MATH CLASS="INLINE">
+-
+</MATH>5&quot;) (PARSE<MATH CLASS="INLINE">
+-
+</MATH>TO<MATH CLASS="INLINE">
+-
+</MATH>SORTED<MATH CLASS="INLINE">
+-
+</MATH>ALIST '(X Y U W) T #'GRLEX<MATH CLASS="INLINE">
+&gt;
+</MATH>) S)
+returns
+(((0 0 2 3) . <MATH CLASS="INLINE">
+-
+</MATH>4/3) ((2 0 0 0) . 1) ((0 2 0 0) . <MATH CLASS="INLINE">
+-
+</MATH>1) ((0 0 0 0) .
+<MATH CLASS="INLINE">
+-
+</MATH>5)) </BLOCKQUOTE><H4><A NAME="SECTION000110080000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>string<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>sorted<MATH CLASS="INLINE">
+-
+</MATH>alist</I></A>
+</H4>
+<P><IMG WIDTH="401" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img169.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em str vars {\sf \&optional} (order
+ \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Parse a string to a sorted alist form, the internal representation
+of polynomials used by our system.</BLOCKQUOTE><H4><A NAME="SECTION000110090000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="523" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img170.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p order \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Sort the terms of a single polynomial P using an admissible monomial
+order ORDER. Returns the sorted polynomial. Destructively modifies P.</BLOCKQUOTE><H4><A NAME="SECTION0001100100000000000000">
+<I>sort<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="544" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img171.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly$-$or$-$poly$-$list {\sf \&optional} (order \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Sort POLY<MATH CLASS="INLINE">
+-
+</MATH>OR<MATH CLASS="INLINE">
+-
+</MATH>POLY<MATH CLASS="INLINE">
+-
+</MATH>LIST, which could be either a single
+polynomial or a list of polynomials in internal alist representation,
+using admissible monomial order ORDER. Each polynomial is sorted
+using SORT<MATH CLASS="INLINE">
+-
+</MATH>POLY<MATH CLASS="INLINE">
+-
+</MATH>1.</BLOCKQUOTE><H4><A NAME="SECTION0001100110000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>eval<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="521" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img172.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr vars order ring {\sf \&aux} (n (length vars)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Evaluate an expression EXPR as polynomial
+by substituting operators + <MATH CLASS="INLINE">
+-
+</MATH> * expt with
+corresponding polynomial operators
+and variables VARS with monomials (1 0 ... 0), (0 1 ... 0) etc.
+We use special versions of binary
+operators $poly+, $poly<MATH CLASS="INLINE">
+-
+</MATH>, $minus<MATH CLASS="INLINE">
+-
+</MATH>poly, $poly* and
+$poly<MATH CLASS="INLINE">
+-
+</MATH>expt which work like the corresponding functions in the
+POLY package, but accept scalars as arguments as well.</BLOCKQUOTE><H4><A NAME="SECTION0001100120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>eval</I></A>
+</H4>
+<P><IMG WIDTH="543" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img173.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr vars {\sf \&optional} (order
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Evaluate an expression EXPR, which should be a polynomial
+expression or a list of polynomial expressions (a list of expressions
+marked by prepending keyword :[ to it) given in lisp prefix notation,
+in variables VARS, which should be a list of symbols. The result of
+the evaluation is a polynomial or a list of polynomials (marked by
+prepending symbol '[) in the internal alist form. This evaluator is
+used by the PARSE package to convert input from strings directly to
+internal form.</BLOCKQUOTE><H4><A NAME="SECTION0001100130000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>basis</I></A>
+</H4>
+<P><IMG WIDTH="514" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img174.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em n {\sf \&aux} (basis
+ (copy$-$tree
+ (make$-...
+ ...
+ (list 'quote
+ (list
+ (cons
+ (make$-$list n :initial$-$element 0)
+ 1)))))) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Generate a list of monomials ((1 0 ... 0) (0 1 0 ... 0) ... (0 0 ...
+1) which correspond to linear monomials X1, X2, ... XN.</BLOCKQUOTE><H4><A NAME="SECTION0001100140000000000000">
+<I>convert<MATH CLASS="INLINE">
+-
+</MATH>number</I></A>
+</H4>
+<P><IMG WIDTH="495" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img175.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em number$-$or$-$poly n \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns NUMBER<MATH CLASS="INLINE">
+-
+</MATH>OR<MATH CLASS="INLINE">
+-
+</MATH>POLY, if it is a polynomial. If it is a number,
+it converts it to the constant monomial in N variables. If the result
+is a number then convert it to a polynomial in N variables.</BLOCKQUOTE><H4><A NAME="SECTION0001100150000000000000">
+<I>$poly+</I></A>
+</H4>
+<P><IMG WIDTH="561" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img176.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q n order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Add two polynomials P and Q, where each polynomial is either a
+numeric constant or a polynomial in internal representation. If the
+result is a number then convert it to a polynomial in N variables.</BLOCKQUOTE><H4><A NAME="SECTION0001100160000000000000">
+<I>$poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="561" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img176.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q n order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Subtract two polynomials P and Q, where each polynomial is either a
+numeric constant or a polynomial in internal representation. If the
+result is a number then convert it to a polynomial in N variables.</BLOCKQUOTE><H4><A NAME="SECTION0001100170000000000000">
+<I>$minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="521" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img177.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p n ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Negation of P is a polynomial is either a numeric constant or a
+polynomial in internal representation. If the result is a number then
+convert it to a polynomial in N variables.</BLOCKQUOTE><H4><A NAME="SECTION0001100180000000000000">
+<I>$poly*</I></A>
+</H4>
+<P><IMG WIDTH="561" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img176.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q n order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Multiply two polynomials P and Q, where each polynomial is either a
+numeric constant or a polynomial in internal representation. If the
+result is a number then convert it to a polynomial in N variables.</BLOCKQUOTE><H4><A NAME="SECTION0001100190000000000000">
+<I>$poly/</I></A>
+</H4>
+<P><IMG WIDTH="566" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img178.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Divide a polynomials P which is either a numeric constant or a
+polynomial in internal representation, by a number Q.</BLOCKQUOTE><H4><A NAME="SECTION0001100200000000000000">
+<I>$poly<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+</H4>
+<P><IMG WIDTH="532" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img179.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p l n order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Raise polynomial P, which is a polynomial in internal
+representation or a numeric constant, to power L. If P is a number,
+convert the result to a polynomial in N variables.</BLOCKQUOTE><HR>
+<!--Navigation Panel-->
+<A NAME="tex2html1063"
+ HREF="node12.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html1060"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html1054"
+ HREF="node10.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html1062"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html1064"
+ HREF="node12.html">Other packages</A>
+<B> Up:</B> <A NAME="tex2html1061"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html1055"
+ HREF="node10.html">The Polynomial Package</A>
+<!--End of Navigation Panel-->
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node12.html
===================================================================
--- /trunk/latex-doc/manual/node12.html	(revision 8)
+++ /trunk/latex-doc/manual/node12.html	(revision 8)
@@ -0,0 +1,1765 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>Other packages</TITLE>
+<META NAME="description" CONTENT="Other packages">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node13.html">
+<LINK REL="previous" HREF="node11.html">
+<LINK REL="up" HREF="manual.html">
+<LINK REL="next" HREF="node13.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html1094"
+ HREF="node13.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html1091"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html1085"
+ HREF="node11.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html1093"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html1095"
+ HREF="node13.html">All examples produced by</A>
+<B> Up:</B> <A NAME="tex2html1092"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html1086"
+ HREF="node11.html">The Parser Package</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<!--Table of Child-Links-->
+<A NAME="CHILD_LINKS"><strong>Subsections</strong></A>
+<UL>
+<LI><A NAME="tex2html1096"
+ HREF="node12.html#SECTION000120010000000000000">
+<I>makelist<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html1097"
+ HREF="node12.html#SECTION000120020000000000000">
+<I>makelist</I></A>
+<LI><A NAME="tex2html1098"
+ HREF="node12.html#SECTION000120030000000000000">
+<I>sum</I></A>
+<LI><A NAME="tex2html1099"
+ HREF="node12.html#SECTION000120040000000000000">
+<I>list<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+<LI><A NAME="tex2html1100"
+ HREF="node12.html#SECTION000120050000000000000">
+<I>list<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html1101"
+ HREF="node12.html#SECTION000120060000000000000">
+<I>union<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+<LI><A NAME="tex2html1102"
+ HREF="node12.html#SECTION000120070000000000000">
+<I>union<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html1103"
+ HREF="node12.html#SECTION000120080000000000000">
+<I>set<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+<LI><A NAME="tex2html1104"
+ HREF="node12.html#SECTION000120090000000000000">
+<I>set<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html1105"
+ HREF="node12.html#SECTION0001200100000000000000">
+<I>select</I></A>
+<LI><A NAME="tex2html1106"
+ HREF="node12.html#SECTION0001200110000000000000">
+<I>monom/</I></A>
+<LI><A NAME="tex2html1107"
+ HREF="node12.html#SECTION0001200120000000000000">
+<I>monom*</I></A>
+<LI><A NAME="tex2html1108"
+ HREF="node12.html#SECTION0001200130000000000000">
+<I>nmonom*</I></A>
+<LI><A NAME="tex2html1109"
+ HREF="node12.html#SECTION0001200140000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>divides<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html1110"
+ HREF="node12.html#SECTION0001200150000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>divisible<MATH CLASS="INLINE">
+-
+</MATH>by<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html1111"
+ HREF="node12.html#SECTION0001200160000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>rel<MATH CLASS="INLINE">
+-
+</MATH>prime</I></A>
+<LI><A NAME="tex2html1112"
+ HREF="node12.html#SECTION0001200170000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+<LI><A NAME="tex2html1113"
+ HREF="node12.html#SECTION0001200180000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html1114"
+ HREF="node12.html#SECTION0001200190000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html1115"
+ HREF="node12.html#SECTION0001200200000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html1116"
+ HREF="node12.html#SECTION0001200210000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>pseudo<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+<LI><A NAME="tex2html1117"
+ HREF="node12.html#SECTION0001200220000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>pseudo<MATH CLASS="INLINE">
+-
+</MATH>remainder</I></A>
+<LI><A NAME="tex2html1118"
+ HREF="node12.html#SECTION0001200230000000000000">
+<I>mdeg</I></A>
+<LI><A NAME="tex2html1119"
+ HREF="node12.html#SECTION0001200240000000000000">
+<I>lcoeff</I></A>
+<LI><A NAME="tex2html1120"
+ HREF="node12.html#SECTION0001200250000000000000">
+<I>lrest</I></A>
+<LI><A NAME="tex2html1121"
+ HREF="node12.html#SECTION0001200260000000000000">
+<I>lpart</I></A>
+<LI><A NAME="tex2html1122"
+ HREF="node12.html#SECTION0001200270000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+<LI><A NAME="tex2html1123"
+ HREF="node12.html#SECTION0001200280000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>content</I></A>
+<LI><A NAME="tex2html1124"
+ HREF="node12.html#SECTION0001200290000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html1125"
+ HREF="node12.html#SECTION0001200300000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html1126"
+ HREF="node12.html#SECTION0001200310000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>tail</I></A>
+<LI><A NAME="tex2html1127"
+ HREF="node12.html#SECTION0001200320000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>poly)</I></A>
+<LI><A NAME="tex2html1128"
+ HREF="node12.html#SECTION0001200330000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sugar)</I></A>
+<LI><A NAME="tex2html1129"
+ HREF="node12.html#SECTION0001200340000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>tail)</I></A>
+<LI><A NAME="tex2html1130"
+ HREF="node12.html#SECTION0001200350000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html1131"
+ HREF="node12.html#SECTION0001200360000000000000">
+<I>coefficient<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html1132"
+ HREF="node12.html#SECTION0001200370000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html1133"
+ HREF="node12.html#SECTION0001200380000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>add<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html1134"
+ HREF="node12.html#SECTION0001200390000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html1135"
+ HREF="node12.html#SECTION0001200400000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html1136"
+ HREF="node12.html#SECTION0001200410000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html1137"
+ HREF="node12.html#SECTION0001200420000000000000">
+<I>minus<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html1138"
+ HREF="node12.html#SECTION0001200430000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar+</I></A>
+<LI><A NAME="tex2html1139"
+ HREF="node12.html#SECTION0001200440000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html1140"
+ HREF="node12.html#SECTION0001200450000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+<LI><A NAME="tex2html1141"
+ HREF="node12.html#SECTION0001200460000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>nreverse</I></A>
+<LI><A NAME="tex2html1142"
+ HREF="node12.html#SECTION0001200470000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>append</I></A>
+<LI><A NAME="tex2html1143"
+ HREF="node12.html#SECTION0001200480000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+<LI><A NAME="tex2html1144"
+ HREF="node12.html#SECTION0001200490000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lm</I></A>
+<LI><A NAME="tex2html1145"
+ HREF="node12.html#SECTION0001200500000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lc</I></A>
+<LI><A NAME="tex2html1146"
+ HREF="node12.html#SECTION0001200510000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lt</I></A>
+<LI><A NAME="tex2html1147"
+ HREF="node12.html#SECTION0001200520000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html1148"
+ HREF="node12.html#SECTION0001200530000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html1149"
+ HREF="node12.html#SECTION0001200540000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html1150"
+ HREF="node12.html#SECTION0001200550000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+<LI><A NAME="tex2html1151"
+ HREF="node12.html#SECTION0001200560000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>monom</I></A>
+<LI><A NAME="tex2html1152"
+ HREF="node12.html#SECTION0001200570000000000000">
+<I>num</I></A>
+<LI><A NAME="tex2html1153"
+ HREF="node12.html#SECTION0001200580000000000000">
+<I>denom</I></A>
+<LI><A NAME="tex2html1154"
+ HREF="node12.html#SECTION0001200590000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>simplify<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html1155"
+ HREF="node12.html#SECTION0001200600000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>simplify</I></A>
+<LI><A NAME="tex2html1156"
+ HREF="node12.html#SECTION0001200610000000000000">
+<I>rat+</I></A>
+<LI><A NAME="tex2html1157"
+ HREF="node12.html#SECTION0001200620000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html1158"
+ HREF="node12.html#SECTION0001200630000000000000">
+<I>rat*</I></A>
+<LI><A NAME="tex2html1159"
+ HREF="node12.html#SECTION0001200640000000000000">
+<I>rat/</I></A>
+<LI><A NAME="tex2html1160"
+ HREF="node12.html#SECTION0001200650000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>rat</I></A>
+<LI><A NAME="tex2html1161"
+ HREF="node12.html#SECTION0001200660000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>div<MATH CLASS="INLINE">
+-
+</MATH>rat</I></A>
+<LI><A NAME="tex2html1162"
+ HREF="node12.html#SECTION0001200670000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+<LI><A NAME="tex2html1163"
+ HREF="node12.html#SECTION0001200680000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+<LI><A NAME="tex2html1164"
+ HREF="node12.html#SECTION0001200690000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+<LI><A NAME="tex2html1165"
+ HREF="node12.html#SECTION0001200700000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>constant</I></A>
+<LI><A NAME="tex2html1166"
+ HREF="node12.html#SECTION0001200710000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html1167"
+ HREF="node12.html#SECTION0001200720000000000000">
+<I>ratpoly+</I></A>
+<LI><A NAME="tex2html1168"
+ HREF="node12.html#SECTION0001200730000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html1169"
+ HREF="node12.html#SECTION0001200740000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+<LI><A NAME="tex2html1170"
+ HREF="node12.html#SECTION0001200750000000000000">
+<I>ratpoly*</I></A>
+<LI><A NAME="tex2html1171"
+ HREF="node12.html#SECTION0001200760000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html1172"
+ HREF="node12.html#SECTION0001200770000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html1173"
+ HREF="node12.html#SECTION0001200780000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+<LI><A NAME="tex2html1174"
+ HREF="node12.html#SECTION0001200790000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>remainder</I></A>
+<LI><A NAME="tex2html1175"
+ HREF="node12.html#SECTION0001200800000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html1176"
+ HREF="node12.html#SECTION0001200810000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+<LI><A NAME="tex2html1177"
+ HREF="node12.html#SECTION0001200820000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>square<MATH CLASS="INLINE">
+-
+</MATH>free</I></A>
+<LI><A NAME="tex2html1178"
+ HREF="node12.html#SECTION0001200830000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>normalize</I></A>
+<LI><A NAME="tex2html1179"
+ HREF="node12.html#SECTION0001200840000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>resultant</I></A>
+<LI><A NAME="tex2html1180"
+ HREF="node12.html#SECTION0001200850000000000000">
+<I>deg</I></A>
+<LI><A NAME="tex2html1181"
+ HREF="node12.html#SECTION0001200860000000000000">
+<I>lead</I></A>
+<LI><A NAME="tex2html1182"
+ HREF="node12.html#SECTION0001200870000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>discriminant</I></A>
+<LI><A NAME="tex2html1183"
+ HREF="node12.html#SECTION0001200880000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html1184"
+ HREF="node12.html#SECTION0001200890000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html1185"
+ HREF="node12.html#SECTION0001200900000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly1</I></A>
+<LI><A NAME="tex2html1186"
+ HREF="node12.html#SECTION0001200910000000000000">
+<I>poly1<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+<LI><A NAME="tex2html1187"
+ HREF="node12.html#SECTION0001200920000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly1</I></A>
+<LI><A NAME="tex2html1188"
+ HREF="node12.html#SECTION0001200930000000000000">
+<I>poly1<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html1189"
+ HREF="node12.html#SECTION0001200940000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html1190"
+ HREF="node12.html#SECTION0001200950000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>resultant</I></A>
+<LI><A NAME="tex2html1191"
+ HREF="node12.html#SECTION0001200960000000000000">
+<I>term*</I></A>
+<LI><A NAME="tex2html1192"
+ HREF="node12.html#SECTION0001200970000000000000">
+<I>term/</I></A>
+<LI><A NAME="tex2html1193"
+ HREF="node12.html#SECTION0001200980000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+<LI><A NAME="tex2html1194"
+ HREF="node12.html#SECTION0001200990000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>divides<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html1195"
+ HREF="node12.html#SECTION00012001000000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>monom</I></A>
+<LI><A NAME="tex2html1196"
+ HREF="node12.html#SECTION00012001010000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>coefficient</I></A>
+<LI><A NAME="tex2html1197"
+ HREF="node12.html#SECTION00012001020000000000000">
+<I>(setf term<MATH CLASS="INLINE">
+-
+</MATH>monom)</I></A>
+<LI><A NAME="tex2html1198"
+ HREF="node12.html#SECTION00012001030000000000000">
+<I>(setf term<MATH CLASS="INLINE">
+-
+</MATH>coefficient)</I></A>
+<LI><A NAME="tex2html1199"
+ HREF="node12.html#SECTION00012001040000000000000">
+<I>xgcd</I></A>
+</UL>
+<!--End of Table of Child-Links-->
+<HR>
+<H1><A NAME="SECTION000120000000000000000">
+Other packages</A>
+</H1>
+<H4><A NAME="SECTION000120010000000000000">
+<I>makelist<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="577" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img180.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr var lo hi {\sf \&optional} (step 1) \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000120020000000000000">
+<I>makelist</I></A>
+</H4>
+<P><IMG WIDTH="598" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img181.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr (var lo hi {\sf \&optional} (step 1)) {\sf \&rest} more \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000120030000000000000">
+<I>sum</I></A>
+</H4>
+<P><IMG WIDTH="627" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img182.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em {\sf \&body} body \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000120040000000000000">
+<I>list<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+</H4>
+<P><IMG WIDTH="608" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img183.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr (var lst) {\sf \&rest} more \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000120050000000000000">
+<I>list<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="587" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img184.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr var lst \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000120060000000000000">
+<I>union<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+</H4>
+<P><IMG WIDTH="608" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img183.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr (var lst) {\sf \&rest} more \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000120070000000000000">
+<I>union<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="587" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img184.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr var lst \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000120080000000000000">
+<I>set<MATH CLASS="INLINE">
+-
+</MATH>of</I></A>
+</H4>
+<P><IMG WIDTH="608" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img183.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr (var lst) {\sf \&rest} more \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000120090000000000000">
+<I>set<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="587" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img184.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em expr var lst \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200100000000000000">
+<I>select</I></A>
+</H4>
+<P><IMG WIDTH="573" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img185.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em ind lst \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200110000000000000">
+<I>monom/</I></A>
+</H4>
+<P><IMG WIDTH="552" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img186.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m1 m2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Divide monomial M1 by monomial M2.</BLOCKQUOTE><H4><A NAME="SECTION0001200120000000000000">
+<I>monom*</I></A>
+</H4>
+<P><IMG WIDTH="552" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img186.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m1 m2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Multiply monomial M1 by monomial M2.</BLOCKQUOTE><H4><A NAME="SECTION0001200130000000000000">
+<I>nmonom*</I></A>
+</H4>
+<P><IMG WIDTH="552" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img186.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m1 m2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Multiply monomials M1 and M2 <MATH CLASS="INLINE">
+-
+</MATH> destructive version.
+ M1 is destructively modified, M2 is not modified.</BLOCKQUOTE><H4><A NAME="SECTION0001200140000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>divides<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+</H4>
+<P><IMG WIDTH="552" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img186.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m1 m2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if monomial M1 divides monomial M2, NIL otherwise.</BLOCKQUOTE><H4><A NAME="SECTION0001200150000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>divisible<MATH CLASS="INLINE">
+-
+</MATH>by<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+</H4>
+<P><IMG WIDTH="552" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img186.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m1 m2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if monomial M1 is divisible by monomial M2, NIL otherwise.</BLOCKQUOTE><H4><A NAME="SECTION0001200160000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>rel<MATH CLASS="INLINE">
+-
+</MATH>prime</I></A>
+</H4>
+<P><IMG WIDTH="552" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img186.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m1 m2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if two monomials M1 and M2 are relatively prime (disjoint).</BLOCKQUOTE><H4><A NAME="SECTION0001200170000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+</H4>
+<P><IMG WIDTH="552" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img186.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m1 m2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if two monomials M1 and M2 are equal.</BLOCKQUOTE><H4><A NAME="SECTION0001200180000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+</H4>
+<P><IMG WIDTH="552" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img186.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m1 m2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns least common multiple of monomials M1 and M2.</BLOCKQUOTE><H4><A NAME="SECTION0001200190000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+</H4>
+<P><IMG WIDTH="552" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img186.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m1 m2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns greatest common divisor of monomials M1 and M2.</BLOCKQUOTE><H4><A NAME="SECTION0001200200000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+</H4>
+<P><IMG WIDTH="504" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img140.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200210000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>pseudo<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+</H4>
+<P><IMG WIDTH="469" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img187.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200220000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>pseudo<MATH CLASS="INLINE">
+-
+</MATH>remainder</I></A>
+</H4>
+<P><IMG WIDTH="469" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img187.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200230000000000000">
+<I>mdeg</I></A>
+</H4>
+<P><IMG WIDTH="574" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img188.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200240000000000000">
+<I>lcoeff</I></A>
+</H4>
+<P><IMG WIDTH="574" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img188.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200250000000000000">
+<I>lrest</I></A>
+</H4>
+<P><IMG WIDTH="574" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img188.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200260000000000000">
+<I>lpart</I></A>
+</H4>
+<P><IMG WIDTH="574" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img188.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200270000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+</H4>
+<P><IMG WIDTH="549" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img88.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200280000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>content</I></A>
+</H4>
+<P><IMG WIDTH="549" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img88.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200290000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200300000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200310000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>tail</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200320000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>poly)</I></A>
+</H4>
+<P><IMG WIDTH="348" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img189.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly \/}$"> [<EM>SETF MAPPING</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200330000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sugar)</I></A>
+</H4>
+<P><IMG WIDTH="340" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img190.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em sugar \/}$"> [<EM>SETF MAPPING</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200340000000000000">
+<I>(setf poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>tail)</I></A>
+</H4>
+<P><IMG WIDTH="355" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img191.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em tail \/}$"> [<EM>SETF MAPPING</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200350000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="511" HEIGHT="14" ALIGN="BOTTOM" BORDER="0"
+ SRC="img192.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200360000000000000">
+<I>coefficient<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="492" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img193.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200370000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="455" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img94.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200380000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>add<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="495" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img194.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200390000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="389" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img195.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c p ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200400000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="396" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img196.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term f ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200410000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="453" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img129.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200420000000000000">
+<I>minus<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="437" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img197.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200430000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar+</I></A>
+</H4>
+<P><IMG WIDTH="478" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img198.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200440000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="478" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img198.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200450000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+</H4>
+<P><IMG WIDTH="461" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img199.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f term g pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200460000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>nreverse</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200470000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>append</I></A>
+</H4>
+<P><IMG WIDTH="427" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img200.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200480000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200490000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lm</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200500000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lc</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200510000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>lt</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200520000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+</H4>
+<P><IMG WIDTH="537" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img201.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist vars {\sf \&optional} (stream t) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Prints a polynomial or  a list of polynomials PLIST using infix
+syntax compatible with most software systems. The following data
+representations are assumed: 1) Polynomial list is ([ poly1 poly2
+...) 2) Polynomial is a list (term1 term2 ...)
+3) Term is (monom . number)
+4) Monom is (number1 number2 ...) and is a list of powers at
+corresponding variables
+Variable names must be provided to the printer explicitly.</BLOCKQUOTE><H4><A NAME="SECTION0001200530000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="516" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img202.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p vars {\sf \&optional} (stream t) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+An auxillary function of POLY<MATH CLASS="INLINE">
+-
+</MATH>PRINT. It prints a single polynomial
+P. </BLOCKQUOTE><H4><A NAME="SECTION0001200540000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+</H4>
+<P><IMG WIDTH="516" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img203.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist vars stream {\sf \&optional} (beg t) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+An auxillary function of POLY<MATH CLASS="INLINE">
+-
+</MATH>PRINT. It prints a comma<MATH CLASS="INLINE">
+-
+</MATH>separated
+list of polynomials PLIST. </BLOCKQUOTE><H4><A NAME="SECTION0001200550000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+</H4>
+<P><IMG WIDTH="534" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img204.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em l vars {\sf \&optional} (stream t) beg \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+An auxillary function of POLY<MATH CLASS="INLINE">
+-
+</MATH>PRINT. It prints a single term L.</BLOCKQUOTE><H4><A NAME="SECTION0001200560000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>monom</I></A>
+</H4>
+<P><IMG WIDTH="534" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img204.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em l vars {\sf \&optional} (stream t) beg \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+An auxillary function of POLY<MATH CLASS="INLINE">
+-
+</MATH>PRINT. It prints a single monomial L.</BLOCKQUOTE><H4><A NAME="SECTION0001200570000000000000">
+<I>num</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200580000000000000">
+<I>denom</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200590000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>simplify<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+</H4>
+<P><IMG WIDTH="505" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img205.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em num denom \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200600000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>simplify</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200610000000000000">
+<I>rat+</I></A>
+</H4>
+<P><IMG WIDTH="427" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img200.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200620000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="427" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img200.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200630000000000000">
+<I>rat*</I></A>
+</H4>
+<P><IMG WIDTH="427" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img200.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200640000000000000">
+<I>rat/</I></A>
+</H4>
+<P><IMG WIDTH="427" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img200.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200650000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>rat</I></A>
+</H4>
+<P><IMG WIDTH="490" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img206.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em scalar p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200660000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>div<MATH CLASS="INLINE">
+-
+</MATH>rat</I></A>
+</H4>
+<P><IMG WIDTH="490" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img206.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em scalar p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200670000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>zerop</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200680000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200690000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>expt</I></A>
+</H4>
+<P><IMG WIDTH="549" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img207.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p n \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200700000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>constant</I></A>
+</H4>
+<P><IMG WIDTH="520" HEIGHT="14" ALIGN="BOTTOM" BORDER="0"
+ SRC="img208.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c n \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Make a constant rational function equal to c with n variables</BLOCKQUOTE><H4><A NAME="SECTION0001200710000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Attempt to convert a rational function to a polynomial by
+dividing numerator by denominator. Error if not divisible</BLOCKQUOTE><H4><A NAME="SECTION0001200720000000000000">
+<I>ratpoly+</I></A>
+</H4>
+<P><IMG WIDTH="427" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img200.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Add polynomials P and Q.</BLOCKQUOTE><H4><A NAME="SECTION0001200730000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="427" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img200.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200740000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200750000000000000">
+<I>ratpoly*</I></A>
+</H4>
+<P><IMG WIDTH="427" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img200.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Multiply polynomials P and Q.</BLOCKQUOTE><H4><A NAME="SECTION0001200760000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+</H4>
+<P><IMG WIDTH="490" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img206.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em scalar p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Multiply scalar SCALAR by a polynomial P.</BLOCKQUOTE><H4><A NAME="SECTION0001200770000000000000">
+<I>rat<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+</H4>
+<P><IMG WIDTH="490" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img206.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em scalar p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Multiply rational function SCALAR by a polynomial P.</BLOCKQUOTE><H4><A NAME="SECTION0001200780000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+</H4>
+<P><IMG WIDTH="469" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img187.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Divide polynomial F by G. Return quotient and remainder as multiple
+values. </BLOCKQUOTE><H4><A NAME="SECTION0001200790000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>remainder</I></A>
+</H4>
+<P><IMG WIDTH="469" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img187.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+The remainder of the division of a polynomial F by G.</BLOCKQUOTE><H4><A NAME="SECTION0001200800000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+</H4>
+<P><IMG WIDTH="469" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img187.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return GCD of polynomials F and G.</BLOCKQUOTE><H4><A NAME="SECTION0001200810000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+</H4>
+<P><IMG WIDTH="549" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img88.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Differentiate a polynomial.</BLOCKQUOTE><H4><A NAME="SECTION0001200820000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>square<MATH CLASS="INLINE">
+-
+</MATH>free</I></A>
+</H4>
+<P><IMG WIDTH="549" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img88.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return the square<MATH CLASS="INLINE">
+-
+</MATH>free part of a polynomial F.</BLOCKQUOTE><H4><A NAME="SECTION0001200830000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>normalize</I></A>
+</H4>
+<P><IMG WIDTH="549" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img88.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Divide a non<MATH CLASS="INLINE">
+-
+</MATH>zero polynomial by the coefficient at the highest
+power. </BLOCKQUOTE><H4><A NAME="SECTION0001200840000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>resultant</I></A>
+</H4>
+<P><IMG WIDTH="469" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img187.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return the resultant of polynomials F and G.</BLOCKQUOTE><H4><A NAME="SECTION0001200850000000000000">
+<I>deg</I></A>
+</H4>
+<P><IMG WIDTH="587" HEIGHT="14" ALIGN="BOTTOM" BORDER="0"
+ SRC="img209.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em s \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200860000000000000">
+<I>lead</I></A>
+</H4>
+<P><IMG WIDTH="587" HEIGHT="14" ALIGN="BOTTOM" BORDER="0"
+ SRC="img209.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em s \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200870000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>discriminant</I></A>
+</H4>
+<P><IMG WIDTH="466" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img210.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p {\sf \&aux} (l (deg p)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+The discriminant of a polynomial P.</BLOCKQUOTE><H4><A NAME="SECTION0001200880000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+</H4>
+<P><IMG WIDTH="518" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img211.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p vars {\sf \&optional} (stream t) (beg t) (p$-$orig p) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200890000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200900000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly1</I></A>
+</H4>
+<P><IMG WIDTH="505" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img212.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p {\sf \&aux} (htab (make$-$hash$-$table)) q \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200910000000000000">
+<I>poly1<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>ratpoly</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200920000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly1</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Convert every coefficient of ratpoly to polynomial if possible</BLOCKQUOTE><H4><A NAME="SECTION0001200930000000000000">
+<I>poly1<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Convert a ratpoly, whose coeffs have been converted to poly,
+into a poly structure, i.e. tack in powers of first variable.</BLOCKQUOTE><H4><A NAME="SECTION0001200940000000000000">
+<I>ratpoly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200950000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>resultant</I></A>
+</H4>
+<P><IMG WIDTH="469" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img187.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Calculate resultant of F and G given in poly i.e. alist
+representation. </BLOCKQUOTE><H4><A NAME="SECTION0001200960000000000000">
+<I>term*</I></A>
+</H4>
+<P><IMG WIDTH="571" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img213.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term1 term2 {\sf \&optional} (ring *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200970000000000000">
+<I>term/</I></A>
+</H4>
+<P><IMG WIDTH="571" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img213.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term1 term2 {\sf \&optional} (ring *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200980000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+</H4>
+<P><IMG WIDTH="465" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img214.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m term \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION0001200990000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>divides<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+</H4>
+<P><IMG WIDTH="498" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img215.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term1 term2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00012001000000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>monom</I></A>
+</H4>
+<P><IMG WIDTH="558" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img216.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00012001010000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>coefficient</I></A>
+</H4>
+<P><IMG WIDTH="558" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img216.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00012001020000000000000">
+<I>(setf term<MATH CLASS="INLINE">
+-
+</MATH>monom)</I></A>
+</H4>
+<P><IMG WIDTH="414" HEIGHT="14" ALIGN="BOTTOM" BORDER="0"
+ SRC="img217.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em monom \/}$"> [<EM>SETF MAPPING</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00012001030000000000000">
+<I>(setf term<MATH CLASS="INLINE">
+-
+</MATH>coefficient)</I></A>
+</H4>
+<P><IMG WIDTH="395" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img218.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em coefficient \/}$"> [<EM>SETF MAPPING</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00012001040000000000000">
+<I>xgcd</I></A>
+</H4>
+<P><IMG WIDTH="580" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img219.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em x y \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Extended gcd; the call
+     (xgcd X Y)
+returns a multiple value list:
+<MATH CLASS="INLINE">
+-
+</MATH> GCD
+<MATH CLASS="INLINE">
+-
+</MATH> U,V  such that they solve the equation
+    GCD=U*X+V*Y
+<MATH CLASS="INLINE">
+-
+</MATH> U1,V1 such that
+    LCM=U1*X=V1*Y (up to the sign).</BLOCKQUOTE>
+<P><HR>
+<!--Navigation Panel-->
+<A NAME="tex2html1094"
+ HREF="node13.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html1091"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html1085"
+ HREF="node11.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html1093"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html1095"
+ HREF="node13.html">All examples produced by</A>
+<B> Up:</B> <A NAME="tex2html1092"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html1086"
+ HREF="node11.html">The Parser Package</A>
+<!--End of Navigation Panel-->
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node13.html
===================================================================
--- /trunk/latex-doc/manual/node13.html	(revision 8)
+++ /trunk/latex-doc/manual/node13.html	(revision 8)
@@ -0,0 +1,234 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>All examples produced by the all-examples utility</TITLE>
+<META NAME="description" CONTENT="All examples produced by the all-examples utility">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node14.html">
+<LINK REL="previous" HREF="node12.html">
+<LINK REL="up" HREF="manual.html">
+<LINK REL="next" HREF="node14.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html1209"
+ HREF="node14.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html1206"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html1200"
+ HREF="node12.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html1208"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html1210"
+ HREF="node14.html">About this document ...</A>
+<B> Up:</B> <A NAME="tex2html1207"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html1201"
+ HREF="node12.html">Other packages</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<H1><A NAME="SECTION000130000000000000000">
+All examples produced by the <TT>all-examples</TT> utility</A>
+</H1>
+<SMALL>
+<PRE>
+;;----------------------------------------------------------------
+;;
+;; (STRING-GROBNER &quot;[x^2+y,x-y]&quot; '(X Y))
+;;
+;;----------------------------------------------------------------
+Args:[ X^2 + Y, X - Y ]
+[ X - Y, Y^2 + Y ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-GROBNER &quot;[y-x^2,z-x^3]&quot; '(X Y Z) :ORDER #'GREVLEX&gt;)
+;;
+;;----------------------------------------------------------------
+Args:[  - X^2 + Y,  - X^3 + Z ]
+[ X^2 - Y, X * Y - Z, Y^2 - X * Z ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-GROBNER-SYSTEM &quot;[u*x+y,x+y]&quot; '(X Y) '(U))
+;;
+;;----------------------------------------------------------------
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [ U ]
+  Red list: [  ]
+ Basis: [ (1) * Y, (1) * X ]
+------------------- CASE 2 -------------------
+Condition:
+  Green list: [  ]
+  Red list: [ U, U - 1 ]
+ Basis: [ (U - 1) * X, ( - U + 1) * Y ]
+------------------- CASE 3 -------------------
+Condition:
+  Green list: [ U - 1 ]
+  Red list: [ U ]
+ Basis: [ (1) * X + (1) * Y ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-GROBNER-SYSTEM &quot;[u*x+y,x+y]&quot; '(X Y) '(U) :COVER '((&quot;[u-1]&quot; &quot;[]&quot;)))
+;;
+;;----------------------------------------------------------------
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [ U - 1 ]
+  Red list: [ U ]
+ Basis: [ (1) * X + (1) * Y ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-READ-POLY &quot;[x^3+3*x^2+3*x+1]&quot; '(X))
+;;
+;;----------------------------------------------------------------
+Args:[ X^3 + 3 * X^2 + 3 * X + 1 ]
+[ RETURN VALUE 1]--&gt;&gt; ([ (((3) . 1) ((2) . 3) ((1) . 3) ((0) . 1)))
+
+;;----------------------------------------------------------------
+;;
+;; (STRING-ELIMINATION-IDEAL &quot;[x^2+y^2-2,x*y-1]&quot; '(X Y) 1)
+;;
+;;----------------------------------------------------------------
+Args:[ X^2 + Y^2 - 2, X * Y - 1 ]
+[ Y^4 - 2 * Y^2 + 1 ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-IDEAL-SATURATION-1 &quot;[x^2*y,y^3]&quot; &quot;x&quot; '(X Y))
+;;
+;;----------------------------------------------------------------
+[ Y ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-IDEAL-POLYSATURATION-1 &quot;[x^2*y,y^3]&quot; &quot;[x,y]&quot; '(X Y))
+;;
+;;----------------------------------------------------------------
+Args1:[ X^2 * Y, Y^3 ]
+Args2:[ X, Y ]
+[ 1 ]
+;;----------------------------------------------------------------
+;;
+;; (STRING-COND '(&quot;[u^2-v]&quot; &quot;[v-1]&quot;) '(U V) #'GREVLEX&gt;)
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]--&gt;&gt; (((((2 0) . 1) ((0 1) . -1))) ((((0 1) . 1) ((0 0) . -1))))
+
+;;----------------------------------------------------------------
+;;
+;; (STRING-COVER '((&quot;[u^2-v]&quot; &quot;[u]&quot;) (&quot;[u+v]&quot; &quot;[]&quot;)) '(U V) #'GREVLEX&gt;)
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]--&gt;&gt; ((((((2 0) . 1) ((0 1) . -1))) ((((1 0) . 1)))) (((((1 0) . 1) ((0 1) . 1))) NIL))
+
+;;----------------------------------------------------------------
+;;
+;; (STRING-DETERMINE &quot;[u*x+y,v*x^2+y^2]&quot; '(X Y) '(U V) :COND '(&quot;[u,v]&quot; &quot;[v-1]&quot;) :MAIN-ORDER #'LEX&gt;)
+;;
+;;----------------------------------------------------------------
+------------------- CASE 1 -------------------
+Condition:
+  Green list: [ U, V ]
+  Red list: [ V - 1, 1 ]
+ Basis: [ (1) * Y, (1) * Y^2 ]
+;;----------------------------------------------------------------
+;;
+;; (PARSE-STRING-TO-SORTED-ALIST &quot;x^2+y^3&quot; '(X Y) #'GREVLEX&gt;)
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]--&gt;&gt; (((0 3) . 1) ((2 0) . 1))
+
+;;----------------------------------------------------------------
+;;
+;; (PARSE-STRING-TO-SORTED-ALIST &quot;[x^2+y^3,x-y]&quot; '(X Y) #'GREVLEX&gt;)
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]--&gt;&gt; ([ (((0 3) . 1) ((2 0) . 1)) (((1 0) . 1) ((0 1) . -1)))
+
+;;----------------------------------------------------------------
+;;
+;; (TRANSLATE-STATEMENTS (COLLINEAR A B C) (PERPENDICULAR A B A C))
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]--&gt;&gt; ((((+ (- (* B1 C2) (* B2 C1)) (- (* A2 C1) (* A1 C2)) (- (* A1 B2) (* A2 B1))))
+                        ((+ (* (- A1 B1) (- A1 C1)) (* (- A2 B2) (- A2 C2)))))
+                       (B1 B2 A1 A2 C1 C2))
+
+;;----------------------------------------------------------------
+;;
+;; (TRANSLATE-THEOREM ((PERPENDICULAR A B C D) (PERPENDICULAR C D E F))
+                      ((PARALLEL A B E F) (IDENTICAL-POINTS C D)))
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]--&gt;&gt; (((+ (* (- A1 B1) (- C1 D1)) (* (- A2 B2) (- C2 D2)))
+                        (+ (* (- C1 D1) (- E1 F1)) (* (- C2 D2) (- E2 F2))))
+                       (A1 A2 B1 B2 C1 C2 D1 D2 E1 E2 F1 F2))
+[ RETURN VALUE 2]--&gt;&gt; ((((- (* (- A1 B1) (- E2 F2)) (* (- A2 B2) (- E1 F1)))) ((- C1 D1) (- C2 D2)))
+                       (A1 A2 B1 B2 E1 E2 F1 F2 C1 C2 D1 D2))
+
+;;----------------------------------------------------------------
+;;
+;; (TRANSLATE-THEOREM ((PERPENDICULAR A B A C) (MIDPOINT B C M) (MIDPOINT A M O) (COLLINEAR B H C)
+                       (PERPENDICULAR A H B C))
+                      ((EQUIDISTANT M O H O) (IDENTICAL-POINTS B C)))
+;;
+;;----------------------------------------------------------------
+[ RETURN VALUE 1]--&gt;&gt; (((+ (* (- A1 B1) (- A1 C1)) (* (- A2 B2) (- A2 C2))) (- (* 2 M1) B1 C1)
+                        (- (* 2 M2) B2 C2) (- (* 2 O1) A1 M1) (- (* 2 O2) A2 M2)
+                        (+ (- (* H1 C2) (* H2 C1)) (- (* B2 C1) (* B1 C2)) (- (* B1 H2) (* B2 H1)))
+                        (+ (* (- A1 H1) (- B1 C1)) (* (- A2 H2) (- B2 C2))))
+                       (M1 M2 O1 O2 A1 A2 H1 H2 B1 B2 C1 C2))
+[ RETURN VALUE 2]--&gt;&gt; ((((- (+ (EXPT (- M1 O1) 2) (EXPT (- M2 O2) 2))
+                            (+ (EXPT (- H1 O1) 2) (EXPT (- H2 O2) 2))))
+                        ((- B1 C1) (- B2 C2)))
+                       (M1 M2 H1 H2 O1 O2 B1 B2 C1 C2))
+
+;;----------------------------------------------------------------
+;;
+;; (PROVE-THEOREM ((PERPENDICULAR A B C D) (PERPENDICULAR C D E F)) ((PARALLEL A B E F) (IDENTICAL-POINTS C D)))
+;;
+;;----------------------------------------------------------------
+[ 1 ]
+;;----------------------------------------------------------------
+;;
+;; (PROVE-THEOREM ((PERPENDICULAR A B A C) (MIDPOINT B C M) (MIDPOINT A M O) (COLLINEAR B H C)
+                   (PERPENDICULAR A H B C))
+                  ((EQUIDISTANT M O H O) (IDENTICAL-POINTS B C)))
+;;
+;;----------------------------------------------------------------
+[ 1 ]
+;;----------------------------------------------------------------
+;;
+;; (PROVE-THEOREM ((PERPENDICULAR A B A C) (IDENTICAL-POINTS B C))
+                  ((IDENTICAL-POINTS A B) (IDENTICAL-POINTS A C)))
+;;
+;;----------------------------------------------------------------
+[ B1 - C1, B2 - C2, A1^2 + A2^2 - 2 * A1 * C1 + C1^2 - 2 * A2 * C2 + C2^2 ]
+;;----------------------------------------------------------------
+;;
+;; (PROVE-THEOREM ((PERPENDICULAR A B A C) (IDENTICAL-POINTS B C))
+                  ((IDENTICAL-POINTS A B) (REAL-IDENTICAL-POINTS A C)))
+;;
+;;----------------------------------------------------------------
+[ 1 ]
+</PRE>
+</SMALL>
+<BR><HR>
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node14.html
===================================================================
--- /trunk/latex-doc/manual/node14.html	(revision 8)
+++ /trunk/latex-doc/manual/node14.html	(revision 8)
@@ -0,0 +1,59 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>About this document ... </TITLE>
+<META NAME="description" CONTENT="About this document ... ">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="previous" HREF="node13.html">
+<LINK REL="up" HREF="manual.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif_gr.gif"> 
+<A NAME="tex2html1215"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html1211"
+ HREF="node13.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html1217"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Up:</B> <A NAME="tex2html1216"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html1212"
+ HREF="node13.html">All examples produced by</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<H1><A NAME="SECTION000140000000000000000">
+About this document ... </A>
+</H1> 
+ <STRONG>CGBLisp User Guide and Manual</STRONG><P>
+This document was generated using the
+<A HREF="http://www-dsed.llnl.gov/files/programs/unix/latex2html/manual/"><STRONG>LaTeX</STRONG>2<tt>HTML</tt></A> translator Version 97.1 (release) (July 13th, 1997)
+<P>
+Copyright &#169; 1993, 1994, 1995, 1996, 1997,
+<A HREF="http://cbl.leeds.ac.uk/nikos/personal.html">Nikos Drakos</A>, 
+Computer Based Learning Unit, University of Leeds.
+<P>
+The command line arguments were: <BR>
+ <STRONG>latex2html</STRONG> <tt>-local_icons -split +1 -html_version 3.2,math manual</tt>.
+<P>
+The translation was initiated by Marek Rychlik on 3/21/1998
+<BR><HR>
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node2.html
===================================================================
--- /trunk/latex-doc/manual/node2.html	(revision 8)
+++ /trunk/latex-doc/manual/node2.html	(revision 8)
@@ -0,0 +1,2002 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>The Gr&#246;bner Basis package</TITLE>
+<META NAME="description" CONTENT="The Gr&#246;bner Basis package">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node3.html">
+<LINK REL="previous" HREF="node1.html">
+<LINK REL="up" HREF="manual.html">
+<LINK REL="next" HREF="node3.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html742"
+ HREF="node3.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html739"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html733"
+ HREF="node1.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html741"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html743"
+ HREF="node3.html">The String Interface to</A>
+<B> Up:</B> <A NAME="tex2html740"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html734"
+ HREF="node1.html">Contents</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<!--Table of Child-Links-->
+<A NAME="CHILD_LINKS"><strong>Subsections</strong></A>
+<UL>
+<LI><A NAME="tex2html744"
+ HREF="node2.html#SECTION00020010000000000000">
+<I>*grobner<MATH CLASS="INLINE">
+-
+</MATH>debug*</I></A>
+<LI><A NAME="tex2html745"
+ HREF="node2.html#SECTION00020020000000000000">
+<I>*buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs*</I></A>
+<LI><A NAME="tex2html746"
+ HREF="node2.html#SECTION00020030000000000000">
+<I>*gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs*</I></A>
+<LI><A NAME="tex2html747"
+ HREF="node2.html#SECTION00020040000000000000">
+<I>*grobner<MATH CLASS="INLINE">
+-
+</MATH>function*</I></A>
+<LI><A NAME="tex2html748"
+ HREF="node2.html#SECTION00020050000000000000">
+<I>select<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>algorithm</I></A>
+<LI><A NAME="tex2html749"
+ HREF="node2.html#SECTION00020060000000000000">
+<I>grobner</I></A>
+<LI><A NAME="tex2html750"
+ HREF="node2.html#SECTION00020070000000000000">
+<I>debug<MATH CLASS="INLINE">
+-
+</MATH>cgb</I></A>
+<LI><A NAME="tex2html751"
+ HREF="node2.html#SECTION00020080000000000000">
+<I>spoly</I></A>
+<LI><A NAME="tex2html752"
+ HREF="node2.html#SECTION00020090000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+<LI><A NAME="tex2html753"
+ HREF="node2.html#SECTION000200100000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>content</I></A>
+<LI><A NAME="tex2html754"
+ HREF="node2.html#SECTION000200110000000000000">
+<I>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html755"
+ HREF="node2.html#SECTION000200120000000000000">
+<I>buchberger</I></A>
+<LI><A NAME="tex2html756"
+ HREF="node2.html#SECTION000200130000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+<LI><A NAME="tex2html757"
+ HREF="node2.html#SECTION000200140000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>sort<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html758"
+ HREF="node2.html#SECTION000200150000000000000">
+<I>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html759"
+ HREF="node2.html#SECTION000200160000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html760"
+ HREF="node2.html#SECTION000200170000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html761"
+ HREF="node2.html#SECTION000200180000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+<LI><A NAME="tex2html762"
+ HREF="node2.html#SECTION000200190000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html763"
+ HREF="node2.html#SECTION000200200000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>coefficient<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html764"
+ HREF="node2.html#SECTION000200210000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>set<MATH CLASS="INLINE">
+-
+</MATH>pair<MATH CLASS="INLINE">
+-
+</MATH>heuristic</I></A>
+<LI><A NAME="tex2html765"
+ HREF="node2.html#SECTION000200220000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html766"
+ HREF="node2.html#SECTION000200230000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html767"
+ HREF="node2.html#SECTION000200240000000000000">
+<I>normalize<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html768"
+ HREF="node2.html#SECTION000200250000000000000">
+<I>normalize<MATH CLASS="INLINE">
+-
+</MATH>basis</I></A>
+<LI><A NAME="tex2html769"
+ HREF="node2.html#SECTION000200260000000000000">
+<I>reduction</I></A>
+<LI><A NAME="tex2html770"
+ HREF="node2.html#SECTION000200270000000000000">
+<I>reduced<MATH CLASS="INLINE">
+-
+</MATH>grobner</I></A>
+<LI><A NAME="tex2html771"
+ HREF="node2.html#SECTION000200280000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html772"
+ HREF="node2.html#SECTION000200290000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html773"
+ HREF="node2.html#SECTION000200300000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+<LI><A NAME="tex2html774"
+ HREF="node2.html#SECTION000200310000000000000">
+<I>ring<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+<LI><A NAME="tex2html775"
+ HREF="node2.html#SECTION000200320000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html776"
+ HREF="node2.html#SECTION000200330000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+<LI><A NAME="tex2html777"
+ HREF="node2.html#SECTION000200340000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>contract</I></A>
+<LI><A NAME="tex2html778"
+ HREF="node2.html#SECTION000200350000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html779"
+ HREF="node2.html#SECTION000200360000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+<LI><A NAME="tex2html780"
+ HREF="node2.html#SECTION000200370000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+<LI><A NAME="tex2html781"
+ HREF="node2.html#SECTION000200380000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>subsetp</I></A>
+<LI><A NAME="tex2html782"
+ HREF="node2.html#SECTION000200390000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>member</I></A>
+<LI><A NAME="tex2html783"
+ HREF="node2.html#SECTION000200400000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+<LI><A NAME="tex2html784"
+ HREF="node2.html#SECTION000200410000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>subsetp</I></A>
+<LI><A NAME="tex2html785"
+ HREF="node2.html#SECTION000200420000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>member</I></A>
+<LI><A NAME="tex2html786"
+ HREF="node2.html#SECTION000200430000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html787"
+ HREF="node2.html#SECTION000200440000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>variables</I></A>
+<LI><A NAME="tex2html788"
+ HREF="node2.html#SECTION000200450000000000000">
+<I>extend<MATH CLASS="INLINE">
+-
+</MATH>polynomials</I></A>
+<LI><A NAME="tex2html789"
+ HREF="node2.html#SECTION000200460000000000000">
+<I>saturation<MATH CLASS="INLINE">
+-
+</MATH>extension</I></A>
+<LI><A NAME="tex2html790"
+ HREF="node2.html#SECTION000200470000000000000">
+<I>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>extension</I></A>
+<LI><A NAME="tex2html791"
+ HREF="node2.html#SECTION000200480000000000000">
+<I>saturation<MATH CLASS="INLINE">
+-
+</MATH>extension<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html792"
+ HREF="node2.html#SECTION000200490000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html793"
+ HREF="node2.html#SECTION000200500000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation</I></A>
+<LI><A NAME="tex2html794"
+ HREF="node2.html#SECTION000200510000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation</I></A>
+<LI><A NAME="tex2html795"
+ HREF="node2.html#SECTION000200520000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>criterion</I></A>
+<LI><A NAME="tex2html796"
+ HREF="node2.html#SECTION000200530000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>test</I></A>
+<LI><A NAME="tex2html797"
+ HREF="node2.html#SECTION000200540000000000000">
+<I>minimization</I></A>
+<LI><A NAME="tex2html798"
+ HREF="node2.html#SECTION000200550000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>minimized</I></A>
+<LI><A NAME="tex2html799"
+ HREF="node2.html#SECTION000200560000000000000">
+<I>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html800"
+ HREF="node2.html#SECTION000200570000000000000">
+<I>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html801"
+ HREF="node2.html#SECTION000200580000000000000">
+<I>pseudo<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+<LI><A NAME="tex2html802"
+ HREF="node2.html#SECTION000200590000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller</I></A>
+<LI><A NAME="tex2html803"
+ HREF="node2.html#SECTION000200600000000000000">
+<I>update</I></A>
+<LI><A NAME="tex2html804"
+ HREF="node2.html#SECTION000200610000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html805"
+ HREF="node2.html#SECTION000200620000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html806"
+ HREF="node2.html#SECTION000200630000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+<LI><A NAME="tex2html807"
+ HREF="node2.html#SECTION000200640000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html808"
+ HREF="node2.html#SECTION000200650000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>coefficient<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+<LI><A NAME="tex2html809"
+ HREF="node2.html#SECTION000200660000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>set<MATH CLASS="INLINE">
+-
+</MATH>pair<MATH CLASS="INLINE">
+-
+</MATH>heuristic</I></A>
+<LI><A NAME="tex2html810"
+ HREF="node2.html#SECTION000200670000000000000">
+<I>spoly<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html811"
+ HREF="node2.html#SECTION000200680000000000000">
+<I>spoly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html812"
+ HREF="node2.html#SECTION000200690000000000000">
+<I>normal<MATH CLASS="INLINE">
+-
+</MATH>form<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html813"
+ HREF="node2.html#SECTION000200700000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html814"
+ HREF="node2.html#SECTION000200710000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html815"
+ HREF="node2.html#SECTION000200720000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sort<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html816"
+ HREF="node2.html#SECTION000200730000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>1<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html817"
+ HREF="node2.html#SECTION000200740000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>2<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html818"
+ HREF="node2.html#SECTION000200750000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html819"
+ HREF="node2.html#SECTION000200760000000000000">
+<I>update<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+<LI><A NAME="tex2html820"
+ HREF="node2.html#SECTION000200770000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html821"
+ HREF="node2.html#SECTION000200780000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</UL>
+<!--End of Table of Child-Links-->
+<HR>
+<H1><A NAME="SECTION00020000000000000000">
+The Gr&#246;bner Basis package</A>
+</H1>
+<H4><A NAME="SECTION00020010000000000000">
+<I>*grobner<MATH CLASS="INLINE">
+-
+</MATH>debug*</I></A>
+</H4>
+<P><IMG WIDTH="495" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img1.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em nil \/}$"> [<EM>VARIABLE</EM>]
+<BLOCKQUOTE>
+If T, produce debugging and tracing output.</BLOCKQUOTE><H4><A NAME="SECTION00020020000000000000">
+<I>*buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs*</I></A>
+</H4>
+<P><IMG WIDTH="425" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img2.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em 'buchberger$-$merge$-$pairs$-$smallest$-$lcm \/}$"> [<EM>VARIABLE</EM>]
+<BLOCKQUOTE>
+A variable holding the predicate used to sort critical pairs
+in the order of decreasing priority for the Buchberger algorithm.</BLOCKQUOTE><H4><A NAME="SECTION00020030000000000000">
+<I>*gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs*</I></A>
+</H4>
+<P><IMG WIDTH="384" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img3.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em 'gebauer$-$moeller$-$merge$-$pairs$-$use$-$mock$-$spoly \/}$"> [<EM>VARIABLE</EM>]
+<BLOCKQUOTE>
+A variable holding the predicate used to sort critical pairs
+in the order of decreasing priority for the Gebauer<MATH CLASS="INLINE">
+-
+</MATH>Moeller
+algorithm </BLOCKQUOTE><H4><A NAME="SECTION00020040000000000000">
+<I>*grobner<MATH CLASS="INLINE">
+-
+</MATH>function*</I></A>
+</H4>
+<P><IMG WIDTH="480" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img4.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em 'buchberger \/}$"> [<EM>VARIABLE</EM>]
+<BLOCKQUOTE>
+The name of the function used to calculate Grobner basis</BLOCKQUOTE><H4><A NAME="SECTION00020050000000000000">
+<I>select<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>algorithm</I></A>
+</H4>
+<P><IMG WIDTH="429" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img5.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em algorithm \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Select one of the several implementations of the Grobner basis
+algorithm.</BLOCKQUOTE><H4><A NAME="SECTION00020060000000000000">
+<I>grobner</I></A>
+</H4>
+<P><IMG WIDTH="559" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img6.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (pred \char93 'lex$\gt$) (start
+ 0) (top$-$reduction$-$only
+ nil) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return Grobner basis of an ideal generated by polynomial list F.
+Assume that the monomials of each polynomial are ordered according to
+the admissible monomial order PRED. The result will be a list of
+polynomials ordered as well according to PRED. The polynomials from 0
+to START<MATH CLASS="INLINE">
+-
+</MATH>1 in the list F are assumed to be a Grobner basis, and
+thus certain critical pairs do not have to be calculated. If
+TOP<MATH CLASS="INLINE">
+-
+</MATH>REDUCTION<MATH CLASS="INLINE">
+-
+</MATH>ONLY is not NIL then only top reductions will be
+performed, instead of full division, and thus the returned Grobner
+basis will have its polynomials only top<MATH CLASS="INLINE">
+-
+</MATH>reduced with respect to
+the preceding polynomials. RING should be set to the RING structure
+(see COEFFICIENT<MATH CLASS="INLINE">
+-
+</MATH>RING package) corresponding to the coefficients of
+the polynomials in the list F. This function is currently just an
+interface to several algorithms which fine Grobner bases. Use
+SELECT<MATH CLASS="INLINE">
+-
+</MATH>GROBNER<MATH CLASS="INLINE">
+-
+</MATH>ALGORITHM in order to change the algorithm.</BLOCKQUOTE><H4><A NAME="SECTION00020070000000000000">
+<I>debug<MATH CLASS="INLINE">
+-
+</MATH>cgb</I></A>
+</H4>
+<P><IMG WIDTH="576" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img7.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em {\sf \&rest} args \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+This macro is used in printing debugging and tracing messages
+and its arguments are analogous to the FORMAT function, except
+that the stream argument is omitted. By default, the output is
+sent to *trace<MATH CLASS="INLINE">
+-
+</MATH>output*, which can be set to produce output 
+in a file.</BLOCKQUOTE><H4><A NAME="SECTION00020080000000000000">
+<I>spoly</I></A>
+</H4>
+<P><IMG WIDTH="576" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img8.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return the S<MATH CLASS="INLINE">
+-
+</MATH>polynomial of F and G, which should
+be two polynomials with terms ordered by PRED and
+coefficients in a ring whose operations are the slots
+of the RING structure.</BLOCKQUOTE><H4><A NAME="SECTION00020090000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+</H4>
+<P><IMG WIDTH="446" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img9.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Divide polynomial P with integer coefficients by gcd of its
+coefficients and return the result. Use the RING structure from the
+COEFFICIENT<MATH CLASS="INLINE">
+-
+</MATH>RING package to perform the operations on the
+coefficients.</BLOCKQUOTE><H4><A NAME="SECTION000200100000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>content</I></A>
+</H4>
+<P><IMG WIDTH="446" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img9.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Greatest common divisor of the coefficients of the polynomial P. Use
+the RING structure to compute the greatest common divisor.</BLOCKQUOTE><H4><A NAME="SECTION000200110000000000000">
+<I>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+</H4>
+<P><IMG WIDTH="520" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img10.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f fl pred top$-$reduction$-$only ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Calculate the normal form of the polynomial F with respect to
+the polynomial list FL. Destructive to F; thus, copy<MATH CLASS="INLINE">
+-
+</MATH>tree should be
+used where F needs to be preserved. It returns multiple values.
+The first value is the polynomial R which is reduced (or
+top<MATH CLASS="INLINE">
+-
+</MATH>reduced if TOP<MATH CLASS="INLINE">
+-
+</MATH>REDUCTION<MATH CLASS="INLINE">
+-
+</MATH>ONLY is not NIL). The second value
+is an integer which is the number of reductions actually performed.
+The third value is the coefficient by which F needs to be multiplied
+in order to be able to perform the division without actually having
+to divide in the coefficient ring (a form of pseudo<MATH CLASS="INLINE">
+-
+</MATH>division is
+used). All operations on the coefficients are performed using the
+RING structure from the COEFFICIENT<MATH CLASS="INLINE">
+-
+</MATH>RING package.</BLOCKQUOTE><H4><A NAME="SECTION000200120000000000000">
+<I>buchberger</I></A>
+</H4>
+<P><IMG WIDTH="535" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img11.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f pred start top$-$reduction$-$only ring {\sf \&aux} (s (1$-$\space (length f))) b m \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+An implementation of the Buchberger algorithm. Return Grobner
+basis of the ideal generated by the polynomial list F.
+The terms of each polynomial are ordered by the admissible
+monomial order PRED. Polynomials 0 to START<MATH CLASS="INLINE">
+-
+</MATH>1 are assumed to
+be a Grobner basis already, so that certain critical pairs
+will not be examined. If TOP<MATH CLASS="INLINE">
+-
+</MATH>REDUCTION<MATH CLASS="INLINE">
+-
+</MATH>ONLY set, top reduction
+will be preformed. The RING structure is used to perform operations
+on coefficents (see COEFFICIENT<MATH CLASS="INLINE">
+-
+</MATH>RING package).</BLOCKQUOTE><H4><A NAME="SECTION000200130000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>op</I></A>
+</H4>
+<P><IMG WIDTH="529" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img12.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c1 c2 m a b pred ring {\sf \&aux} n a1 a2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Perform a calculation equivalent to
+(POLY<MATH CLASS="INLINE">
+-
+</MATH> (SCALAR<MATH CLASS="INLINE">
+-
+</MATH>TIMES<MATH CLASS="INLINE">
+-
+</MATH>POLY C2 A)
+	 (SCALAR<MATH CLASS="INLINE">
+-
+</MATH>TIMES<MATH CLASS="INLINE">
+-
+</MATH>POLY C1 (MONOM<MATH CLASS="INLINE">
+-
+</MATH>TIMES<MATH CLASS="INLINE">
+-
+</MATH>POLY M B))
+	 PRED)
+but more efficiently; it destructively modifies A and stores the 
+result in it; A is returned.</BLOCKQUOTE><H4><A NAME="SECTION000200140000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>sort<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+</H4>
+<P><IMG WIDTH="451" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img13.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b g pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Sort critical pairs B by the function which is
+the value of the vairable *buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs*.
+G is the list of polynomials which the elemnts
+of B point into. PRED is the admissible monomial order.
+The RING structure holds operations on the coefficients
+as described in the COEFFICIENT<MATH CLASS="INLINE">
+-
+</MATH>RING package.</BLOCKQUOTE><H4><A NAME="SECTION000200150000000000000">
+<I>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+</H4>
+<P><IMG WIDTH="526" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img14.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g pred \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns an upper<MATH CLASS="INLINE">
+-
+</MATH>bound on the leading
+monomial of the S<MATH CLASS="INLINE">
+-
+</MATH>polynomial of F and G, which are two polynomials
+sorted by the admissible monomial order PRED.</BLOCKQUOTE><H4><A NAME="SECTION000200160000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+</H4>
+<P><IMG WIDTH="301" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img15.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c g pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Merges lists of critical pairs B and C into one list. 
+The pairs are assumed to be ordered according to the
+increasing value of MOCK<MATH CLASS="INLINE">
+-
+</MATH>SPOLY, as determined by the admissible
+monomial order PRED. G is the list of polynomials which the pairs
+of integers in B and C point into, and RING is the ring structure
+defined in the COEFFICIENT<MATH CLASS="INLINE">
+-
+</MATH>RING package.</BLOCKQUOTE><H4><A NAME="SECTION000200170000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+</H4>
+<P><IMG WIDTH="301" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img15.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c g pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Merges lists of critical pairs B and C into a single ordered
+list. Implements a strategy of ordering pairs according to the
+smallest lcm of the leading monomials of the two polynomials <MATH CLASS="INLINE">
+-
+</MATH> so
+called normal strategy.</BLOCKQUOTE><H4><A NAME="SECTION000200180000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+</H4>
+<P><IMG WIDTH="301" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img15.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c g pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Mergest lists B and C of critical pairs. This strategy is based on
+ordering the pairs according to the smallest degree of the lcm of
+the leading monomials of the two polynomials.</BLOCKQUOTE><H4><A NAME="SECTION000200190000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+</H4>
+<P><IMG WIDTH="301" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img15.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c g pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Mergest lists B and C of critical pairs. This strategy is based on
+ordering the pairs according to the smallest total length of the 
+two polynomials, where length is the number of terms.</BLOCKQUOTE><H4><A NAME="SECTION000200200000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>coefficient<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+</H4>
+<P><IMG WIDTH="301" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img15.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c g pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Mergest lists B and C of critical pairs. This strategy is based on
+ordering the pairs according to the smallest combined length of the 
+coefficients of the two polynomials.</BLOCKQUOTE><H4><A NAME="SECTION000200210000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>set<MATH CLASS="INLINE">
+-
+</MATH>pair<MATH CLASS="INLINE">
+-
+</MATH>heuristic</I></A>
+</H4>
+<P><IMG WIDTH="551" HEIGHT="173" ALIGN="MIDDLE" BORDER="0"
+ SRC="img16.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em method {\sf \&aux} (strategy$-$fn
+ (ecase
+ ...
+ ...ar93 'buchberger$-$merge$-$pairs$-$use$-$smallest$-$coefficient$-$length))) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Simply sets the variable *buchberger<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs* to the
+heuristic function STRATEGY<MATH CLASS="INLINE">
+-
+</MATH>FN implementing one of several
+strategies introduces before of selecting the most promising. METHOD
+should be one of the listed keywords.</BLOCKQUOTE><H4><A NAME="SECTION000200220000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="533" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img17.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em pair g {\sf \&aux} (i (first pair)) (j (second pair)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if the leading monomials of the two polynomials
+in G pointed to by the integers in PAIR have disjoint (relatively
+prime) monomials. This test is known as the first Buchberger
+criterion. </BLOCKQUOTE><H4><A NAME="SECTION000200230000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+</H4>
+<P><IMG WIDTH="533" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img18.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em pair g m {\sf \&aux} (i (first pair)) (j (second pair)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if the leading monomial of some element P of G divides
+the LCM of the leading monomials of the two polynomials in the
+polynomial list G, pointed to by the two integers in PAIR, and P
+paired with each of the polynomials pointed to by the the PAIR has
+already been treated, as indicated by the hash table M, which stores
+value T for every treated pair so far.</BLOCKQUOTE><H4><A NAME="SECTION000200240000000000000">
+<I>normalize<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="446" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img9.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Divide a polynomial by its leading coefficient. It assumes
+that the division is possible, which may not always be the
+case in rings which are not fields. The exact division operator
+is assumed to be provided by the RING structure of the
+COEFFICIENT<MATH CLASS="INLINE">
+-
+</MATH>RING package.</BLOCKQUOTE><H4><A NAME="SECTION000200250000000000000">
+<I>normalize<MATH CLASS="INLINE">
+-
+</MATH>basis</I></A>
+</H4>
+<P><IMG WIDTH="500" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img19.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Divide every polynomial in a list PLIST by its leading coefficient.
+Use RING structure to perform the division of the coefficients.</BLOCKQUOTE><H4><A NAME="SECTION000200260000000000000">
+<I>reduction</I></A>
+</H4>
+<P><IMG WIDTH="547" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img20.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Reduce a list of polynomials P, so that non of the terms in any of
+the polynomials is divisible by a leading monomial of another
+polynomial. Return the reduced list.</BLOCKQUOTE><H4><A NAME="SECTION000200270000000000000">
+<I>reduced<MATH CLASS="INLINE">
+-
+</MATH>grobner</I></A>
+</H4>
+<P><IMG WIDTH="559" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img6.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (pred \char93 'lex$\gt$) (start
+ 0) (top$-$reduction$-$only
+ nil) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return the reduced Grobner basis of the ideal generated by a
+polynomial list F. This combines calls to two functions: GROBNER and
+REDUCTION. The parameters have the same meaning as in GROBNER or
+BUCHBERGER. </BLOCKQUOTE><H4><A NAME="SECTION000200280000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+</H4>
+<P><IMG WIDTH="470" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img21.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m k \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return T if the monomial M depends on variable number K.</BLOCKQUOTE><H4><A NAME="SECTION000200290000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+</H4>
+<P><IMG WIDTH="489" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img22.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term k \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return T if the term TERM depends on variable number K.</BLOCKQUOTE><H4><A NAME="SECTION000200300000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>depends<MATH CLASS="INLINE">
+-
+</MATH>p</I></A>
+</H4>
+<P><IMG WIDTH="492" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img23.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p k \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return T if the term polynomial P depends on variable number K.</BLOCKQUOTE><H4><A NAME="SECTION000200310000000000000">
+<I>ring<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+</H4>
+<P><IMG WIDTH="493" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img24.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist k {\sf \&key} (key \char93 'identity) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+This function assumes that polynomial list PLIST is a Grobner basis
+and it calculates the intersection with the ring R[x[k+1],...,x[n]],
+i.e. it discards polynomials which depend on variables x[0], x[1],
+..., x[k]. </BLOCKQUOTE><H4><A NAME="SECTION000200320000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+</H4>
+<P><IMG WIDTH="491" HEIGHT="90" ALIGN="MIDDLE" BORDER="0"
+ SRC="img25.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em flist k {\sf \&key} (primary$-$order
+ \char...
+ ...ondary$-$order)) (top$-$reduction$-$only
+ nil) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the K<MATH CLASS="INLINE">
+-
+</MATH>th elimination ideal of the ideal generated by
+polynomial list FLIST. Thus, a Grobner basis of the ideal generated
+by FLIST is calculated and polynomials depending on variables 0<MATH CLASS="INLINE">
+-
+</MATH>K
+are discarded. The monomial order in the calculation is an
+elimination order formed by combining two orders: PRIMARY<MATH CLASS="INLINE">
+-
+</MATH>ORDER
+used on variables 0<MATH CLASS="INLINE">
+-
+</MATH>K and SECONDARY<MATH CLASS="INLINE">
+-
+</MATH>ORDER used on variables
+starting from variable K+1. Thus, if both orders are set to the
+lexicographic order #'LEX<MATH CLASS="INLINE">
+&gt;
+</MATH> then the resulting order is simply
+equivalent to #'LEX<MATH CLASS="INLINE">
+&gt;
+</MATH>. But one could use arbitrary two orders in
+this function, for instance, two copies of #'GREVLEX<MATH CLASS="INLINE">
+&gt;
+</MATH> (see ORDER
+package). When doing so, the caller must ensure that the same order
+has been used to sort the terms of the polynomials FLIST. </BLOCKQUOTE><H4><A NAME="SECTION000200330000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+</H4>
+<P><IMG WIDTH="487" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img26.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g pred top$-$reduction$-$only ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return the Grobner basis of the intersection of the ideals
+generated by the polynomial lists F and G. PRED is an admissible
+monomial order with respect to which the terms of F and G have been
+sorted. This order is going to be used in the Grobner basis
+calculation. If TOP<MATH CLASS="INLINE">
+-
+</MATH>REDUCTION<MATH CLASS="INLINE">
+-
+</MATH>ONLY is not NIL, internally the
+Grobner basis algorithm will perform top reduction only.  The RING
+parameter, as usual, should be set to a structure defined in the
+package COEFFICIENT<MATH CLASS="INLINE">
+-
+</MATH>RING, and it will be used to perform all
+operations on coefficients.</BLOCKQUOTE><H4><A NAME="SECTION000200340000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>contract</I></A>
+</H4>
+<P><IMG WIDTH="512" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img27.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (k 1) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return a polynomial obtained from polynomial F by dropping the
+first K variables, if F does not depend on them.  Note that this
+operation makes the polynomial incompatible for certain arithmetical
+operations with the original polynomial F. Calling this function on a
+polynomial F which does depend on variables 0<MATH CLASS="INLINE">
+-
+</MATH>K will result in
+error. </BLOCKQUOTE><H4><A NAME="SECTION000200350000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+</H4>
+<P><IMG WIDTH="545" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img28.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g {\sf \&optional} (pred \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return LCM (least common multiple) of two polynomials F and G.
+The polynomials must be ordered according to monomial order PRED
+and their coefficients must be compatible with the RING structure
+defined in the COEFFICIENT<MATH CLASS="INLINE">
+-
+</MATH>RING package.</BLOCKQUOTE><H4><A NAME="SECTION000200360000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>gcd</I></A>
+</H4>
+<P><IMG WIDTH="545" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img28.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g {\sf \&optional} (pred \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return GCD (greatest common divisor) of two polynomials F and G.
+The polynomials must be ordered according to monomial order PRED
+and their coefficients must be compatible with the RING structure
+defined in the COEFFICIENT<MATH CLASS="INLINE">
+-
+</MATH>RING package.</BLOCKQUOTE><H4><A NAME="SECTION000200370000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+</H4>
+<P><IMG WIDTH="510" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img29.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em g1 g2 {\sf \&optional} (pred
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if two lists of polynomials G1 and G2, assumed to be
+Grobner bases, generate  the same ideal, and NIL otherwise.</BLOCKQUOTE><H4><A NAME="SECTION000200380000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>subsetp</I></A>
+</H4>
+<P><IMG WIDTH="510" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img29.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em g1 g2 {\sf \&optional} (pred
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if a list of polynomials G1 generates
+an ideal contained in the ideal generated by a polynomial list G2,
+both G1 and G2 assumed to be Grobner bases. Returns NIL otherwise.</BLOCKQUOTE><H4><A NAME="SECTION000200390000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>member</I></A>
+</H4>
+<P><IMG WIDTH="490" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img30.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p g {\sf \&optional} (pred
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if a polynomial P belongs to the ideal generated by the
+polynomial list G, which is assumed to be a Grobner basis. Returns
+NIL otherwise. </BLOCKQUOTE><H4><A NAME="SECTION000200400000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>equal</I></A>
+</H4>
+<P><IMG WIDTH="530" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img31.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f1 f2 pred top$-$reduction$-$only ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if two ideals generated by polynomial lists F1 and F2 are
+identical. Returns NIL otherwise.</BLOCKQUOTE><H4><A NAME="SECTION000200410000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>subsetp</I></A>
+</H4>
+<P><IMG WIDTH="515" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img32.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f1 f2 {\sf \&optional} (pred
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if the ideal spanned by the polynomial list F1 is contained
+in the ideal spanned by the polynomial list F2. Returns NIL
+otherwise. </BLOCKQUOTE><H4><A NAME="SECTION000200420000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>member</I></A>
+</H4>
+<P><IMG WIDTH="511" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img33.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p plist pred top$-$reduction$-$only ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if the polynomial P belongs to the ideal spanned by the
+polynomial list PLIST, and NIL otherwise.</BLOCKQUOTE><H4><A NAME="SECTION000200430000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="476" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img34.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f p pred start top$-$reduction$-$only ring {\sf \&aux} (pred
+ (elimination$-$order$-$1
+ pred)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the reduced Grobner basis of the saturation of the ideal
+generated by a polynomial list F in the ideal generated by a single
+polynomial P. The saturation ideal is defined as the set of
+polynomials H such for some natural number n (* (EXPT P N) H) is in
+the ideal F. Geometrically, over an algebraically closed field, this
+is the set of polynomials in the ideal generated by F which do not
+identically vanish on the variety of P.</BLOCKQUOTE><H4><A NAME="SECTION000200440000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>variables</I></A>
+</H4>
+<P><IMG WIDTH="514" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img35.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist n \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Add N new variables, adn the first N variables, to every polynomial
+in polynomial list PLIST. The resulting polynomial will not depend on
+these N variables. </BLOCKQUOTE><H4><A NAME="SECTION000200450000000000000">
+<I>extend<MATH CLASS="INLINE">
+-
+</MATH>polynomials</I></A>
+</H4>
+<P><IMG WIDTH="472" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img36.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist {\sf \&aux} (k (length plist)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns polynomial list {U1*P1', U2*P2', ... , UK*PK'}
+where Ui are new variables and PLIST={P1, P2, ... , PK} is a
+polynomial list. PI' is obtained from PI by adding new variables U1,
+U2, ..., UN UK as the first K variables. Thus, the resulting list is
+consists of polynomials whose terms are ordered by the lexicographic
+order on variables UI, with ties resolved by the monomial order which
+was used to order the terms of the polynomials in PLIST. We note that
+the monomial order does not explicitly participate in this
+calculation, and neither do the variable names.</BLOCKQUOTE><H4><A NAME="SECTION000200460000000000000">
+<I>saturation<MATH CLASS="INLINE">
+-
+</MATH>extension</I></A>
+</H4>
+<P><IMG WIDTH="465" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img37.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f plist ring {\sf \&aux} (k
+ (length plist)) (d
+ (+
+ k
+ (length
+ (caaar
+ plist)))) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns F' union {U1*P1<MATH CLASS="INLINE">
+-
+</MATH>1,U2*P2<MATH CLASS="INLINE">
+-
+</MATH>1,...,UK*PK<MATH CLASS="INLINE">
+-
+</MATH>1} where Ui are
+new variables and F' is a polynomial list  obtained from F by adding
+variables U1, U2, ..., Uk as the first K variables to each polynomial
+in F. Thus, the resulting list is consists of polynomials whose terms
+are ordered by the lexicographic order on variables Ui, with ties
+resolved by the monomial order which was used to order the terms of
+the polynomials in F. We note that the monomial order does not
+explicitly participate in this calculation, and neither do the
+variable names. </BLOCKQUOTE><H4><A NAME="SECTION000200470000000000000">
+<I>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>extension</I></A>
+</H4>
+<P><IMG WIDTH="465" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img37.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f plist ring {\sf \&aux} (k
+ (length plist)) (d
+ (+
+ k
+ (length
+ (caaar
+ plist)))) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns F' union {U1*P1+U2*P2+UK*PK<MATH CLASS="INLINE">
+-
+</MATH>1} where Ui are new variables
+and F' is a polynomial list  obtained from F by adding variables U1,
+U2, ..., Uk as the first K variables to each polynomial in F. Thus,
+the resulting list is consists of polynomials whose terms are ordered
+by the lexicographic order on variables Ui, with ties resolved by the
+monomial order which was used to order the terms of the polynomials
+in F. We note that the monomial order does not explicitly participate
+in this calculation, and neither do the variable names. </BLOCKQUOTE><H4><A NAME="SECTION000200480000000000000">
+<I>saturation<MATH CLASS="INLINE">
+-
+</MATH>extension<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="444" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img38.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f p ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return the list F' union {U*P<MATH CLASS="INLINE">
+-
+</MATH>1} where U is a new variable,
+where F' is obtained from the polynomial list F by adding U as the
+first variable. The variable U will be added as the first variable,
+so that it can be easily eliminated.</BLOCKQUOTE><H4><A NAME="SECTION000200490000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="447" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img39.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f plist pred start top$-$reduction$-$only ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the reduced Grobner basis of the ideal obtained by a
+sequence of successive saturations in the polynomials
+of the polynomial list PLIST of the ideal generated by the
+polynomial list F.</BLOCKQUOTE><H4><A NAME="SECTION000200500000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation</I></A>
+</H4>
+<P><IMG WIDTH="497" HEIGHT="70" ALIGN="MIDDLE" BORDER="0"
+ SRC="img40.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g pred start top$-$reduction$-$only ring ...
+ ...$order k :primary$-$order \char93 'lex$\gt$\space :secondary$-$order pred)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the reduced Grobner basis of the saturation of the ideal
+generated by a polynomial list F in the ideal generated a polynomial
+list G The saturation ideal is defined as the set of polynomials H
+such for some natural number n and some P in the ideal generated by G
+the polynomial P**N * H is in the ideal spanned by F.  Geometrically,
+over an algebraically closed field, this is the set of polynomials in
+the ideal generated by F which do not identically vanish on the
+variety of G.</BLOCKQUOTE><H4><A NAME="SECTION000200510000000000000">
+<I>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation</I></A>
+</H4>
+<P><IMG WIDTH="468" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img41.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f ideal$-$list pred start top$-$reduction$-$only ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the reduced Grobner basis of the ideal obtained by a
+successive applications of IDEAL<MATH CLASS="INLINE">
+-
+</MATH>SATURATIONS to F and
+lists of polynomials in the list IDEAL<MATH CLASS="INLINE">
+-
+</MATH>LIST.</BLOCKQUOTE><H4><A NAME="SECTION000200520000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>criterion</I></A>
+</H4>
+<P><IMG WIDTH="465" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img42.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em g pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns T if G is a Grobner basis, by using the Buchberger
+criterion: for every two polynomials h1 and h2 in G the
+S<MATH CLASS="INLINE">
+-
+</MATH>polynomial S(h1,h2) reduces to 0 modulo G.</BLOCKQUOTE><H4><A NAME="SECTION000200530000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>test</I></A>
+</H4>
+<P><IMG WIDTH="520" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img43.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em g f pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Test whether G is a Grobner basis and F is contained in G. Return T
+upon success and NIL otherwise.</BLOCKQUOTE><H4><A NAME="SECTION000200540000000000000">
+<I>minimization</I></A>
+</H4>
+<P><IMG WIDTH="523" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img44.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p pred \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns a sublist of the polynomial list P spanning the same
+monomial ideal as P but minimal, i.e. no leading monomial
+of a polynomial in the sublist divides the leading monomial
+of another polynomial.</BLOCKQUOTE><H4><A NAME="SECTION000200550000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>minimized</I></A>
+</H4>
+<P><IMG WIDTH="503" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img45.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f gred pred \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Adds a polynomial f to GRED, reduced Grobner basis, preserving the
+property described in the documentation for MINIMIZATION.</BLOCKQUOTE><H4><A NAME="SECTION000200560000000000000">
+<I>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+</H4>
+<P><IMG WIDTH="487" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img26.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g pred top$-$reduction$-$only ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the reduced Grobner basis of the colon ideal Id(F):Id(G),
+where F and G are two lists of polynomials. The colon ideal I:J is
+defined as the set of polynomials H such that there is a polynomial W
+in J for which W*H belongs to I.</BLOCKQUOTE><H4><A NAME="SECTION000200570000000000000">
+<I>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="487" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img26.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g pred top$-$reduction$-$only ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the reduced Grobner basis of the colon ideal Id(F):Id({G}),
+where F is a list of polynomials and G is a polynomial.</BLOCKQUOTE><H4><A NAME="SECTION000200580000000000000">
+<I>pseudo<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+</H4>
+<P><IMG WIDTH="511" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img46.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f fl pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Pseudo<MATH CLASS="INLINE">
+-
+</MATH>divide a polynomial F by the list of polynomials FL. Return
+multiple values. The first value is a list of quotients A.
+The second value is the remainder R. The third value is an integer
+count of the number of reductions performed. Finally, the fourth
+argument is a scalar coefficient C, such that C*F can be divided by
+FL within the ring of coefficients, which is not necessarily a field.
+The resulting objects satisfy the equation:
+ C*F= sum A[i]*FL[i] + R</BLOCKQUOTE><H4><A NAME="SECTION000200590000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller</I></A>
+</H4>
+<P><IMG WIDTH="494" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img47.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f pred start top$-$reduction$-$only ring {\sf \&aux} b g f1 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Compute Grobner basis by using the algorithm of Gebauer and Moeller.
+This algorithm is described as BUCHBERGERNEW2 in the book by
+Becker<MATH CLASS="INLINE">
+-
+</MATH>Weispfenning entitled ``Grobner Bases''</BLOCKQUOTE><H4><A NAME="SECTION000200600000000000000">
+<I>update</I></A>
+</H4>
+<P><IMG WIDTH="564" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img48.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em g b h pred ring {\sf \&aux} c d e b$-$new g$-$new pair \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+An implementation of the auxillary UPDATE algorithm used by the
+Gebauer<MATH CLASS="INLINE">
+-
+</MATH>Moeller algorithm. G is a list of polynomials, B is a list
+of critical pairs and H is a new polynomial which possibly will be
+added to G. The naming conventions used are very close to the one
+used in the book of Becker<MATH CLASS="INLINE">
+-
+</MATH>Weispfenning.</BLOCKQUOTE><H4><A NAME="SECTION000200610000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>mock<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+</H4>
+<P><IMG WIDTH="261" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img49.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+The merging strategy used by the Gebauer<MATH CLASS="INLINE">
+-
+</MATH>Moeller algorithm, based
+on MOCK<MATH CLASS="INLINE">
+-
+</MATH>SPOLY; see the documentation of
+BUCHBERGER<MATH CLASS="INLINE">
+-
+</MATH>MERGE<MATH CLASS="INLINE">
+-
+</MATH>PAIRS<MATH CLASS="INLINE">
+-
+</MATH>USE<MATH CLASS="INLINE">
+-
+</MATH>MOCK<MATH CLASS="INLINE">
+-
+</MATH>SPOLY.</BLOCKQUOTE><H4><A NAME="SECTION000200620000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+</H4>
+<P><IMG WIDTH="261" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img49.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+The merging strategy based on the smallest<MATH CLASS="INLINE">
+-
+</MATH>lcm (normal strategy);
+see the documentation of BUCHBERGER<MATH CLASS="INLINE">
+-
+</MATH>MERGE<MATH CLASS="INLINE">
+-
+</MATH>PAIRS<MATH CLASS="INLINE">
+-
+</MATH>SMALLEST<MATH CLASS="INLINE">
+-
+</MATH>LCM.</BLOCKQUOTE><H4><A NAME="SECTION000200630000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+</H4>
+<P><IMG WIDTH="261" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img49.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+The merging strategy based on the smallest<MATH CLASS="INLINE">
+-
+</MATH>lcm (normal strategy);
+see the documentation of
+BUCHBERGER<MATH CLASS="INLINE">
+-
+</MATH>MERGE<MATH CLASS="INLINE">
+-
+</MATH>PAIRS<MATH CLASS="INLINE">
+-
+</MATH>USE<MATH CLASS="INLINE">
+-
+</MATH>SMALLEST<MATH CLASS="INLINE">
+-
+</MATH>DEGREE. </BLOCKQUOTE><H4><A NAME="SECTION000200640000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+</H4>
+<P><IMG WIDTH="261" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img49.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000200650000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs<MATH CLASS="INLINE">
+-
+</MATH>use<MATH CLASS="INLINE">
+-
+</MATH>smallest<MATH CLASS="INLINE">
+-
+</MATH>coefficient<MATH CLASS="INLINE">
+-
+</MATH>length</I></A>
+</H4>
+<P><IMG WIDTH="261" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img49.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+The merging strategy based on the smallest<MATH CLASS="INLINE">
+-
+</MATH>lcm (normal strategy);
+see the documentation of
+BUCHBERGER<MATH CLASS="INLINE">
+-
+</MATH>MERGE<MATH CLASS="INLINE">
+-
+</MATH>PAIRS<MATH CLASS="INLINE">
+-
+</MATH>USE<MATH CLASS="INLINE">
+-
+</MATH>SMALLEST<MATH CLASS="INLINE">
+-
+</MATH>COEFFICIENT<MATH CLASS="INLINE">
+-
+</MATH>LENGTH. </BLOCKQUOTE><H4><A NAME="SECTION000200660000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>set<MATH CLASS="INLINE">
+-
+</MATH>pair<MATH CLASS="INLINE">
+-
+</MATH>heuristic</I></A>
+</H4>
+<P><IMG WIDTH="551" HEIGHT="173" ALIGN="MIDDLE" BORDER="0"
+ SRC="img16.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em method {\sf \&aux} (strategy$-$fn
+ (ecase
+ ...
+ ...ar93 'buchberger$-$merge$-$pairs$-$use$-$smallest$-$coefficient$-$length))) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000200670000000000000">
+<I>spoly<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="527" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img50.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f$-$with$-$sugar g$-$with$-$sugar ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Calculate the ``sugar'' of the S<MATH CLASS="INLINE">
+-
+</MATH>polynomial of two polynomials with
+sugar. A polynomial with sugar is simply a pair (P . SUGAR) where
+SUGAR is an integer constant defined according to the following
+algorighm: the sugar of sum or difference of two polynomials with
+sugar is the MAX of the sugars of those two polynomials. The sugar of
+a product of a term and a polynomial is the sum of the degree of the
+term and the sugar of the polynomial.  The idea is to accumulate
+sugar as we perform the arithmetic operations, and that polynomials
+with small (little) sugar should be given priority in the
+calculations. Thus, the ``sugar strategy'' of the critical pair
+selection is to select a pair with the smallest value of sugar of the
+resulting S<MATH CLASS="INLINE">
+-
+</MATH>polynomial.</BLOCKQUOTE><H4><A NAME="SECTION000200680000000000000">
+<I>spoly<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="484" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img51.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f$-$with$-$sugar g$-$with$-$sugar pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+The S<MATH CLASS="INLINE">
+-
+</MATH>polynomials of two polynomials with SUGAR strategy.</BLOCKQUOTE><H4><A NAME="SECTION000200690000000000000">
+<I>normal<MATH CLASS="INLINE">
+-
+</MATH>form<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="520" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img10.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f fl pred top$-$reduction$-$only ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Normal form of the polynomial with sugar F with respect to
+a list of polynomials with sugar FL. Assumes that FL is not empty.
+Parameters PRED, TOP<MATH CLASS="INLINE">
+-
+</MATH>REDUCTION<MATH CLASS="INLINE">
+-
+</MATH>ONLY and RING have the same
+meaning as in NORMAL<MATH CLASS="INLINE">
+-
+</MATH>FORM. The parameter SUGAR<MATH CLASS="INLINE">
+-
+</MATH>LIMIT should be
+set to a positive integer. If the sugar limit of the partial
+remainder exceeds SUGAR<MATH CLASS="INLINE">
+-
+</MATH>LIMIT then the calculation is stopped and
+the partial remainder is returned, although it is not fully reduced
+with respect to FL. </BLOCKQUOTE><H4><A NAME="SECTION000200700000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="443" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img52.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f$-$no$-$sugar pred start top$-$reduction$-$only ring {\sf \&aux} (s (1$-$\space (length f$-$no$-$sugar))) b m f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns a Grobner basis of an ideal generated by a list of ordinary
+polynomials F<MATH CLASS="INLINE">
+-
+</MATH>NO<MATH CLASS="INLINE">
+-
+</MATH>SUGAR. Adds initial sugar to the polynomials and
+performs the Buchberger algorithm with ``sugar strategy''. It returns
+an ordinary list of polynomials with no sugar. One of the most
+effective algorithms for Grobner basis calculation.</BLOCKQUOTE><H4><A NAME="SECTION000200710000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+</H4>
+<P><IMG WIDTH="343" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img53.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c g m pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Merges lists of critical pairs. It orders pairs according to
+increasing sugar, with ties broken by smaller MOCK<MATH CLASS="INLINE">
+-
+</MATH>SPOLY value of
+the two polynomials. In this function B must already be sorted.</BLOCKQUOTE><H4><A NAME="SECTION000200720000000000000">
+<I>buchberger<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>sort<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+</H4>
+<P><IMG WIDTH="359" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img54.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c g m pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Sorts critical pairs C according to sugar strategy.</BLOCKQUOTE><H4><A NAME="SECTION000200730000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>1<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="533" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img17.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em pair g {\sf \&aux} (i (first pair)) (j (second pair)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+An implementation of Buchberger's first criterion for polynomials 
+with sugar. See the documentation of BUCHBERGER<MATH CLASS="INLINE">
+-
+</MATH>CRITERION<MATH CLASS="INLINE">
+-
+</MATH>1.</BLOCKQUOTE><H4><A NAME="SECTION000200740000000000000">
+<I>criterion<MATH CLASS="INLINE">
+-
+</MATH>2<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="533" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img18.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em pair g m {\sf \&aux} (i (first pair)) (j (second pair)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+An implementation of Buchberger's first criterion for polynomials 
+with sugar. See the documentation of BUCHBERGER<MATH CLASS="INLINE">
+-
+</MATH>CRITERION<MATH CLASS="INLINE">
+-
+</MATH>2.</BLOCKQUOTE><H4><A NAME="SECTION000200750000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="494" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img47.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f pred start top$-$reduction$-$only ring {\sf \&aux} b g f1 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Compute Grobner basis by using the algorithm of Gebauer and Moeller.
+This algorithm is described as BUCHBERGERNEW2 in the book by
+Becker<MATH CLASS="INLINE">
+-
+</MATH>Weispfenning entitled ``Grobner Bases''</BLOCKQUOTE><H4><A NAME="SECTION000200760000000000000">
+<I>update<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="564" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img48.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em g b h pred ring {\sf \&aux} c d e b$-$new g$-$new pair \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+An implementation of the auxillary UPDATE algorithm used by the
+Gebauer<MATH CLASS="INLINE">
+-
+</MATH>Moeller algorithm. G is a list of polynomials, B is a list
+of critical pairs and H is a new polynomial which possibly will be
+added to G. The naming conventions used are very close to the one
+used in the book of Becker<MATH CLASS="INLINE">
+-
+</MATH>Weispfenning. Operates on polynomials
+with sugar. </BLOCKQUOTE><H4><A NAME="SECTION000200770000000000000">
+<I>gebauer<MATH CLASS="INLINE">
+-
+</MATH>moeller<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar<MATH CLASS="INLINE">
+-
+</MATH>merge<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+</H4>
+<P><IMG WIDTH="261" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img49.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b c pred ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Merges lists of critical pairs. It orders pairs according to
+increasing sugar, with ties broken by smaller lcm of head monomials
+In this function B must already be sorted. Operates on polynomials
+with sugar. </BLOCKQUOTE><H4><A NAME="SECTION000200780000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>primitive<MATH CLASS="INLINE">
+-
+</MATH>part<MATH CLASS="INLINE">
+-
+</MATH>with<MATH CLASS="INLINE">
+-
+</MATH>sugar</I></A>
+</H4>
+<P><IMG WIDTH="354" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img55.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em h ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><HR>
+<!--Navigation Panel-->
+<A NAME="tex2html742"
+ HREF="node3.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html739"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html733"
+ HREF="node1.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html741"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html743"
+ HREF="node3.html">The String Interface to</A>
+<B> Up:</B> <A NAME="tex2html740"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html734"
+ HREF="node1.html">Contents</A>
+<!--End of Navigation Panel-->
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node3.html
===================================================================
--- /trunk/latex-doc/manual/node3.html	(revision 8)
+++ /trunk/latex-doc/manual/node3.html	(revision 8)
@@ -0,0 +1,396 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>The String Interface to the Gr&#246;bner Basis package</TITLE>
+<META NAME="description" CONTENT="The String Interface to the Gr&#246;bner Basis package">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node4.html">
+<LINK REL="previous" HREF="node2.html">
+<LINK REL="up" HREF="manual.html">
+<LINK REL="next" HREF="node4.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html831"
+ HREF="node4.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html828"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html822"
+ HREF="node2.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html830"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html832"
+ HREF="node4.html">The Comprehensive Gr&#246;bner basis</A>
+<B> Up:</B> <A NAME="tex2html829"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html823"
+ HREF="node2.html">The Gr&#246;bner Basis package</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<!--Table of Child-Links-->
+<A NAME="CHILD_LINKS"><strong>Subsections</strong></A>
+<UL>
+<LI><A NAME="tex2html833"
+ HREF="node3.html#SECTION00030010000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html834"
+ HREF="node3.html#SECTION00030020000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>grobner</I></A>
+<LI><A NAME="tex2html835"
+ HREF="node3.html#SECTION00030030000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>elimination<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html836"
+ HREF="node3.html#SECTION00030040000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+<LI><A NAME="tex2html837"
+ HREF="node3.html#SECTION00030050000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+<LI><A NAME="tex2html838"
+ HREF="node3.html#SECTION00030060000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html839"
+ HREF="node3.html#SECTION00030070000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html840"
+ HREF="node3.html#SECTION00030080000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation</I></A>
+<LI><A NAME="tex2html841"
+ HREF="node3.html#SECTION00030090000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation</I></A>
+<LI><A NAME="tex2html842"
+ HREF="node3.html#SECTION000300100000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+<LI><A NAME="tex2html843"
+ HREF="node3.html#SECTION000300110000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>read<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html844"
+ HREF="node3.html#SECTION000300120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>rational<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>integer</I></A>
+<LI><A NAME="tex2html845"
+ HREF="node3.html#SECTION000300130000000000000">
+<I>read<MATH CLASS="INLINE">
+-
+</MATH>vars</I></A>
+</UL>
+<!--End of Table of Child-Links-->
+<HR>
+<H1><A NAME="SECTION00030000000000000000">
+The String Interface to the Gr&#246;bner Basis package</A>
+</H1>
+<H4><A NAME="SECTION00030010000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+</H4>
+<P><IMG WIDTH="468" HEIGHT="70" ALIGN="MIDDLE" BORDER="0"
+ SRC="img56.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f fl vars {\sf \&key} (stream
+ t) (print
+ t...
+ ...ient$-$ring*) (suppress$-$value
+ t) {\sf \&aux} (vars
+ (read$-$vars
+ vars)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00030020000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>grobner</I></A>
+</H4>
+<P><IMG WIDTH="507" HEIGHT="70" ALIGN="MIDDLE" BORDER="0"
+ SRC="img57.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist vars {\sf \&key} (order
+ \char93 'lex...
+ ...g
+ *coefficient$-$ring*) (print
+ t) {\sf \&aux} (vars
+ (read$-$vars
+ vars)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00030030000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>elimination<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+</H4>
+<P><IMG WIDTH="439" HEIGHT="110" ALIGN="MIDDLE" BORDER="0"
+ SRC="img58.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em flist vars k {\sf \&key} (stream
+ t) (key
+ ...
+ ...ondary$-$order
+ secondary$-$order)) {\sf \&aux} (vars
+ (read$-$vars
+ vars)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00030040000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>intersection</I></A>
+</H4>
+<P><IMG WIDTH="435" HEIGHT="90" ALIGN="MIDDLE" BORDER="0"
+ SRC="img59.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g vars {\sf \&key} (order
+ \char93 'lex$\...
+ ...
+ vars
+ order)) (g
+ (parse$-$string$-$to$-$sorted$-$alist
+ g
+ vars
+ order)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00030050000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>lcm</I></A>
+</H4>
+<P><IMG WIDTH="435" HEIGHT="90" ALIGN="MIDDLE" BORDER="0"
+ SRC="img59.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g vars {\sf \&key} (order
+ \char93 'lex$\...
+ ...
+ vars
+ order)) (g
+ (parse$-$string$-$to$-$sorted$-$alist
+ g
+ vars
+ order)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00030060000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="424" HEIGHT="110" ALIGN="MIDDLE" BORDER="0"
+ SRC="img60.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f p vars {\sf \&key} (order
+ \char93 'lex$\...
+ ...
+ vars
+ order)) (p
+ (parse$-$string$-$to$-$sorted$-$alist
+ p
+ vars
+ order)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00030070000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="395" HEIGHT="110" ALIGN="MIDDLE" BORDER="0"
+ SRC="img61.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f plist vars {\sf \&key} (order
+ \char93 'l...
+ ...order)) (plist
+ (parse$-$string$-$to$-$sorted$-$alist
+ plist
+ vars
+ order)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00030080000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>saturation</I></A>
+</H4>
+<P><IMG WIDTH="435" HEIGHT="90" ALIGN="MIDDLE" BORDER="0"
+ SRC="img59.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g vars {\sf \&key} (order
+ \char93 'lex$\...
+ ...
+ vars
+ order)) (g
+ (parse$-$string$-$to$-$sorted$-$alist
+ g
+ vars
+ order)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00030090000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>ideal<MATH CLASS="INLINE">
+-
+</MATH>polysaturation</I></A>
+</H4>
+<P><IMG WIDTH="417" HEIGHT="130" ALIGN="MIDDLE" BORDER="0"
+ SRC="img62.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f ideal$-$list vars {\sf \&key} (order
+ \ch...
+ ...da (g) (parse$-$string$-$to$-$sorted$-$alist g vars order))
+ ideal$-$list)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000300100000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>colon<MATH CLASS="INLINE">
+-
+</MATH>ideal</I></A>
+</H4>
+<P><IMG WIDTH="478" HEIGHT="90" ALIGN="MIDDLE" BORDER="0"
+ SRC="img63.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g vars {\sf \&key} (top$-$reduction$-$onl...
+ ...
+ vars
+ order)) (g
+ (parse$-$string$-$to$-$sorted$-$alist
+ g
+ vars
+ order)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000300110000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>read<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="488" HEIGHT="70" ALIGN="MIDDLE" BORDER="0"
+ SRC="img64.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f vars {\sf \&key} (order
+ \char93 'lex$\gt...
+ ...$-$vars
+ vars)) (f
+ (parse$-$string$-$to$-$sorted$-$alist
+ f
+ vars
+ order)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000300120000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>rational<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>integer</I></A>
+</H4>
+<P><IMG WIDTH="430" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img65.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p {\sf \&optional} (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000300130000000000000">
+<I>read<MATH CLASS="INLINE">
+-
+</MATH>vars</I></A>
+</H4>
+<P><IMG WIDTH="542" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img66.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em string$-$or$-$list \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Read a list of variables, specified either as a list of symbols or a
+string listing variables in the form of a comma<MATH CLASS="INLINE">
+-
+</MATH>separated list,
+delimited by [,] </BLOCKQUOTE><HR>
+<!--Navigation Panel-->
+<A NAME="tex2html831"
+ HREF="node4.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html828"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html822"
+ HREF="node2.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html830"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html832"
+ HREF="node4.html">The Comprehensive Gr&#246;bner basis</A>
+<B> Up:</B> <A NAME="tex2html829"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html823"
+ HREF="node2.html">The Gr&#246;bner Basis package</A>
+<!--End of Navigation Panel-->
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node4.html
===================================================================
--- /trunk/latex-doc/manual/node4.html	(revision 8)
+++ /trunk/latex-doc/manual/node4.html	(revision 8)
@@ -0,0 +1,1238 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>The Comprehensive Gr&#246;bner basis package</TITLE>
+<META NAME="description" CONTENT="The Comprehensive Gr&#246;bner basis package">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node5.html">
+<LINK REL="previous" HREF="node3.html">
+<LINK REL="up" HREF="manual.html">
+<LINK REL="next" HREF="node5.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html855"
+ HREF="node5.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html852"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html846"
+ HREF="node3.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html854"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html856"
+ HREF="node5.html">The Coefficient Ring package</A>
+<B> Up:</B> <A NAME="tex2html853"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html847"
+ HREF="node3.html">The String Interface to</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<!--Table of Child-Links-->
+<A NAME="CHILD_LINKS"><strong>Subsections</strong></A>
+<UL>
+<LI><A NAME="tex2html857"
+ HREF="node4.html#SECTION00040010000000000000">
+<I>*colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>debug*</I></A>
+<LI><A NAME="tex2html858"
+ HREF="node4.html#SECTION00040020000000000000">
+<I>debug<MATH CLASS="INLINE">
+-
+</MATH>cgb</I></A>
+<LI><A NAME="tex2html859"
+ HREF="node4.html#SECTION00040030000000000000">
+<I>make<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html860"
+ HREF="node4.html#SECTION00040040000000000000">
+<I>make<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html861"
+ HREF="node4.html#SECTION00040050000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html862"
+ HREF="node4.html#SECTION00040060000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html863"
+ HREF="node4.html#SECTION00040070000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html864"
+ HREF="node4.html#SECTION00040080000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html865"
+ HREF="node4.html#SECTION00040090000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html866"
+ HREF="node4.html#SECTION000400100000000000000">
+<I>determine</I></A>
+<LI><A NAME="tex2html867"
+ HREF="node4.html#SECTION000400110000000000000">
+<I>determine<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html868"
+ HREF="node4.html#SECTION000400120000000000000">
+<I>determine<MATH CLASS="INLINE">
+-
+</MATH>white<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+<LI><A NAME="tex2html869"
+ HREF="node4.html#SECTION000400130000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>system<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html870"
+ HREF="node4.html#SECTION000400140000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+<LI><A NAME="tex2html871"
+ HREF="node4.html#SECTION000400150000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html872"
+ HREF="node4.html#SECTION000400160000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+<LI><A NAME="tex2html873"
+ HREF="node4.html#SECTION000400170000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>hm</I></A>
+<LI><A NAME="tex2html874"
+ HREF="node4.html#SECTION000400180000000000000">
+<I>delete<MATH CLASS="INLINE">
+-
+</MATH>green<MATH CLASS="INLINE">
+-
+</MATH>polys</I></A>
+<LI><A NAME="tex2html875"
+ HREF="node4.html#SECTION000400190000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+<LI><A NAME="tex2html876"
+ HREF="node4.html#SECTION000400200000000000000">
+<I>reorder<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+<LI><A NAME="tex2html877"
+ HREF="node4.html#SECTION000400210000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>criterion<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+<LI><A NAME="tex2html878"
+ HREF="node4.html#SECTION000400220000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>criterion<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+<LI><A NAME="tex2html879"
+ HREF="node4.html#SECTION000400230000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+<LI><A NAME="tex2html880"
+ HREF="node4.html#SECTION000400240000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+<LI><A NAME="tex2html881"
+ HREF="node4.html#SECTION000400250000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>lm</I></A>
+<LI><A NAME="tex2html882"
+ HREF="node4.html#SECTION000400260000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>lc</I></A>
+<LI><A NAME="tex2html883"
+ HREF="node4.html#SECTION000400270000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html884"
+ HREF="node4.html#SECTION000400280000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html885"
+ HREF="node4.html#SECTION000400290000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term*</I></A>
+<LI><A NAME="tex2html886"
+ HREF="node4.html#SECTION000400300000000000000">
+<I>color*</I></A>
+<LI><A NAME="tex2html887"
+ HREF="node4.html#SECTION000400310000000000000">
+<I>color+</I></A>
+<LI><A NAME="tex2html888"
+ HREF="node4.html#SECTION000400320000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html889"
+ HREF="node4.html#SECTION000400330000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly+</I></A>
+<LI><A NAME="tex2html890"
+ HREF="node4.html#SECTION000400340000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html891"
+ HREF="node4.html#SECTION000400350000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+<LI><A NAME="tex2html892"
+ HREF="node4.html#SECTION000400360000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html893"
+ HREF="node4.html#SECTION000400370000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+<LI><A NAME="tex2html894"
+ HREF="node4.html#SECTION000400380000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+<LI><A NAME="tex2html895"
+ HREF="node4.html#SECTION000400390000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>cover</I></A>
+<LI><A NAME="tex2html896"
+ HREF="node4.html#SECTION000400400000000000000">
+<I>saturate<MATH CLASS="INLINE">
+-
+</MATH>cover</I></A>
+<LI><A NAME="tex2html897"
+ HREF="node4.html#SECTION000400410000000000000">
+<I>saturate<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+<LI><A NAME="tex2html898"
+ HREF="node4.html#SECTION000400420000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>determine</I></A>
+<LI><A NAME="tex2html899"
+ HREF="node4.html#SECTION000400430000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+<LI><A NAME="tex2html900"
+ HREF="node4.html#SECTION000400440000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>pair</I></A>
+<LI><A NAME="tex2html901"
+ HREF="node4.html#SECTION000400450000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+<LI><A NAME="tex2html902"
+ HREF="node4.html#SECTION000400460000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>reduction</I></A>
+<LI><A NAME="tex2html903"
+ HREF="node4.html#SECTION000400470000000000000">
+<I>green<MATH CLASS="INLINE">
+-
+</MATH>reduce<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+<LI><A NAME="tex2html904"
+ HREF="node4.html#SECTION000400480000000000000">
+<I>green<MATH CLASS="INLINE">
+-
+</MATH>reduce<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html905"
+ HREF="node4.html#SECTION000400490000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>system<MATH CLASS="INLINE">
+-
+</MATH>green<MATH CLASS="INLINE">
+-
+</MATH>reduce</I></A>
+<LI><A NAME="tex2html906"
+ HREF="node4.html#SECTION000400500000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html907"
+ HREF="node4.html#SECTION000400510000000000000">
+<I>red<MATH CLASS="INLINE">
+-
+</MATH>reduction</I></A>
+</UL>
+<!--End of Table of Child-Links-->
+<HR>
+<H1><A NAME="SECTION00040000000000000000">
+The Comprehensive Gr&#246;bner basis package</A>
+</H1>
+<H4><A NAME="SECTION00040010000000000000">
+<I>*colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>debug*</I></A>
+</H4>
+<P><IMG WIDTH="495" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img1.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em nil \/}$"> [<EM>VARIABLE</EM>]
+<BLOCKQUOTE>
+If true debugging output is on.</BLOCKQUOTE><H4><A NAME="SECTION00040020000000000000">
+<I>debug<MATH CLASS="INLINE">
+-
+</MATH>cgb</I></A>
+</H4>
+<P><IMG WIDTH="576" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img7.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em {\sf \&rest} args \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION00040030000000000000">
+<I>make<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="471" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img67.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly k {\sf \&key} (key
+ \char93 'identity)...
+ ...er
+ \char93 'lex$\gt$) (parameter$-$order
+ \char93 'lex$\gt$) {\sf \&aux} l \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Colored poly is represented as a list
+	(TERM1 TERM2 ... TERMS)
+where each term is a triple
+	(MONOM . (POLY . COLOR))
+where monoms and polys have common number of variables while color is
+one of the three: :RED, :GREEN or :WHITE.  This function translates
+an ordinary polynomial into a colored one by dividing variables into
+K and N<MATH CLASS="INLINE">
+-
+</MATH>K, where N is the total number of variables in the
+polynomial poly; the function KEY can be called to select variables
+in arbitrary order.</BLOCKQUOTE><H4><A NAME="SECTION00040040000000000000">
+<I>make<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+</H4>
+<P><IMG WIDTH="438" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img68.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em plist {\sf \&rest} rest \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Translate a list of polynomials PLIST into a list of colored
+polynomials by calling MAKE<MATH CLASS="INLINE">
+-
+</MATH>COLORED<MATH CLASS="INLINE">
+-
+</MATH>POLY. Returns the resulting
+list. </BLOCKQUOTE><H4><A NAME="SECTION00040050000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+</H4>
+<P><IMG WIDTH="503" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img69.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em flist {\sf \&optional} (cond (list nil nil)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Add colors to an ordinary list of polynomials FLIST, according to a
+condition COND. A condition is a pair of polynomial lists.  Each
+polynomial in COND is a polynomial in parameters only.  The list
+(FIRST COND) is called the ``green list'' and it consists of
+polynomials which vanish for the parameters associated with the
+condition. The list (SECOND COND) is called the ``red list</BLOCKQUOTE><H4><A NAME="SECTION00040060000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="536" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img70.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (cond (list nil nil)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Add color to a single polynomial F, according to condition COND.
+See the documentation of COLOR<MATH CLASS="INLINE">
+-
+</MATH>POLY<MATH CLASS="INLINE">
+-
+</MATH>LIST.</BLOCKQUOTE><H4><A NAME="SECTION00040070000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="451" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img71.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cpoly \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+For a given colored polynomial CPOLY, removes the colors and
+it returns the polynomial as an ordinary polynomial with
+coefficients which are polynomials in parameters.</BLOCKQUOTE><H4><A NAME="SECTION00040080000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+</H4>
+<P><IMG WIDTH="475" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img72.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly vars {\sf \&key} (stream
+ t) (beg
+ t) (print$-$green$-$part
+ nil) (mark$-$coefficients
+ nil) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Print a colored polynomial POLY. Use variables VARS to represent
+the variables. Some of the variables are going to be used as
+parameters, according to the length of the monomials in the main
+monomial and coefficient part of each term in POLY. The key variable
+STREAM may be used to redirect the output. If parameter
+PRINT<MATH CLASS="INLINE">
+-
+</MATH>GREEN<MATH CLASS="INLINE">
+-
+</MATH>PART is set then the coefficients which have color
+:GREEN will be printed, otherwise they are discarded silently. If
+MARK<MATH CLASS="INLINE">
+-
+</MATH>COEFFICIENTS is not NIL then every coefficient will be marked
+according to its color, for instance G(U<MATH CLASS="INLINE">
+-
+</MATH>1) would mean that U<MATH CLASS="INLINE">
+-
+</MATH>1
+is in the green list. Returns P.</BLOCKQUOTE><H4><A NAME="SECTION00040090000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>print<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+</H4>
+<P><IMG WIDTH="442" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img73.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em poly$-$list vars {\sf \&key} (stream
+ t) (beg
+ t) (print$-$green$-$part
+ nil) (mark$-$coefficients
+ nil) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Pring a list of colored polynomials via a call to
+COLORED<MATH CLASS="INLINE">
+-
+</MATH>POLY<MATH CLASS="INLINE">
+-
+</MATH>PRINT.</BLOCKQUOTE><H4><A NAME="SECTION000400100000000000000">
+<I>determine</I></A>
+</H4>
+<P><IMG WIDTH="543" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img74.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (cond (list nil nil)) (order
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+This function takes a list of colored polynomials F and a condition
+COND, and it returns a list of pairs (COND' F') such that COND' cover
+COND and F' is a ``determined'' version of the colored polynomial
+list F, i.e. every polynomial has its leading coefficient determined.
+This means that some of the initial coefficients in each polynomial
+in F' are in the green list of COND, and the first non<MATH CLASS="INLINE">
+-
+</MATH>green
+coefficient is in the red list of COND. We note that F' differs from
+F only by different colors: some of the terms marked :WHITE are now
+marked either :GREEN or :RED. Coloring is done either by explicitly
+checking membership in red or green list of COND, or implicitly by
+performing Grobner basis calculations in the polynomial ring over the
+parameters. The admissible monomial order ORDER is used only in the
+parameter space. Also, the ring structure RING is used only for
+calculations on polynomials of the parameters only.</BLOCKQUOTE><H4><A NAME="SECTION000400110000000000000">
+<I>determine<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="522" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img75.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond p end gp order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Determine a single colored polynomial  P according to condition COND.
+Prepend green part GP to P. Cons the result with END, which should be
+a list of colored polynomials, and return the resulting list of
+polynomials. This is an auxillary function of DETERMINE.</BLOCKQUOTE><H4><A NAME="SECTION000400120000000000000">
+<I>determine<MATH CLASS="INLINE">
+-
+</MATH>white<MATH CLASS="INLINE">
+-
+</MATH>term</I></A>
+</H4>
+<P><IMG WIDTH="448" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img76.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond term restp end gp order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+This is an auxillary function of DETERMINE.  In this function the
+parameter COND is a condition.  The parameters TERM, RESTP and GP are
+three parts of a polynomial being processed, where TERM is colored
+:WHITE. We test the membership in the red and green list of COND we
+try to determine whether the term is :RED or :GREEN. This is done by
+performing ideal membership tests in the polynomial ring. Let C be
+the coefficient of TERM.  Thus, C is a polynomial in parameters. We
+find whether C is in the green list by performing a plain ideal
+membership test. However, to test properly whether C is in the red
+list, one needs a different strategy.  In fact, we test whether
+adding C to the red list would produce a non<MATH CLASS="INLINE">
+-
+</MATH>empty set of
+parameters in some algebraic extension. The test is whether 1 belongs
+to the saturation ideal of (FIRST COND) in (CONS C (SECOND COND)).
+Thus, we use POLY<MATH CLASS="INLINE">
+-
+</MATH>SATURATION. If we are successful in determining
+the color of TERM, we simply change the color of the term and return
+the list ((COND P)) where P is obtained by appending GP, (LIST TERM)
+and RESTP. If we cannot determine whether TERM is :RED or :GREEN, we
+return the list ((COND' P') (COND'' P</BLOCKQUOTE><H4><A NAME="SECTION000400130000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>system<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+</H4>
+<P><IMG WIDTH="474" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img77.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em system vars params {\sf \&key} (suppress$-$...
+ ...rint$-$green$-$part
+ nil) (mark$-$coefficients
+ nil) {\sf \&aux} (label
+ 0) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+A conditional system SYSTEM is a list of pairs (COND PLIST), where
+COND is a condition (a pair (GREEN<MATH CLASS="INLINE">
+-
+</MATH>LIST RED<MATH CLASS="INLINE">
+-
+</MATH>LIST)) and PLIST is a
+list of colored polynomials. This function pretty<MATH CLASS="INLINE">
+-
+</MATH>prints this list
+of pairs. A conditional system is the data structure returned by
+GROBNER<MATH CLASS="INLINE">
+-
+</MATH>SYSTEM. This function returns SYSTEM, if SUPPRESS<MATH CLASS="INLINE">
+-
+</MATH>VALUE
+is non<MATH CLASS="INLINE">
+-
+</MATH>NIL and no value otherwise. If MARK<MATH CLASS="INLINE">
+-
+</MATH>COEFFICIENTS is
+non<MATH CLASS="INLINE">
+-
+</MATH>NIL coefficients will be marked as in G(u<MATH CLASS="INLINE">
+-
+</MATH>1)*x+R(2)*y, which
+means that u<MATH CLASS="INLINE">
+-
+</MATH>1 is :GREEN and 2 is :RED. </BLOCKQUOTE><H4><A NAME="SECTION000400140000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>print</I></A>
+</H4>
+<P><IMG WIDTH="533" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img78.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond params \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Pretty<MATH CLASS="INLINE">
+-
+</MATH>print a condition COND, using symbol list PARAMS as
+parameter names. </BLOCKQUOTE><H4><A NAME="SECTION000400150000000000000">
+<I>add<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+</H4>
+<P><IMG WIDTH="541" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img79.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em gs pred \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+The parameter GS shoud be a Grobner system, i.e. a set of pairs
+(CONDITION POLY<MATH CLASS="INLINE">
+-
+</MATH>LIST) This functions adds the third component: the
+list of initial critical pairs (I J), as in the ordinary Grobner
+basis algorithm. In addition, it adds the length of of the
+POLY<MATH CLASS="INLINE">
+-
+</MATH>LIST, less 1, as the fourth component. The resulting list of
+quadruples is returned.</BLOCKQUOTE><H4><A NAME="SECTION000400160000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>part</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Find the part of a colored polynomial P starting with the first
+ non<MATH CLASS="INLINE">
+-
+</MATH>green term.</BLOCKQUOTE><H4><A NAME="SECTION000400170000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>hm</I></A>
+</H4>
+<P><IMG WIDTH="538" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img80.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return the conditional head monomial of a colored polynomial P.</BLOCKQUOTE><H4><A NAME="SECTION000400180000000000000">
+<I>delete<MATH CLASS="INLINE">
+-
+</MATH>green<MATH CLASS="INLINE">
+-
+</MATH>polys</I></A>
+</H4>
+<P><IMG WIDTH="472" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img81.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em gamma \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Delete totally green polynomials from in a grobner system GAMMA.</BLOCKQUOTE><H4><A NAME="SECTION000400190000000000000">
+<I>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+</H4>
+<P><IMG WIDTH="499" HEIGHT="130" ALIGN="MIDDLE" BORDER="0"
+ SRC="img82.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&key} (cover (list '(nil nil))) (ma...
+ ...char93 '(lambda (cond) (determine f cond parameter$-$order ring))
+ cover))) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+This function returns a grobner system, given a list of colored
+polynomials F, Other parameters are:
+A cover COVER, i.e. a list of conditions, i.e. pairs of the form
+(GREEN<MATH CLASS="INLINE">
+-
+</MATH>LIST RED<MATH CLASS="INLINE">
+-
+</MATH>LIST), where GREEN<MATH CLASS="INLINE">
+-
+</MATH>LIST and RED<MATH CLASS="INLINE">
+-
+</MATH>LIST are to
+lists of ordinary polynomials in parameters. A monomial order
+MAIN<MATH CLASS="INLINE">
+-
+</MATH>ORDER used on main variables (not parameters). A monomial
+order PARAMETER<MATH CLASS="INLINE">
+-
+</MATH>ORDER used in calculations with parameters only.
+REDUCE, a flag deciding whether COLORED<MATH CLASS="INLINE">
+-
+</MATH>REDUCTION will be performed
+on the resulting grobner system. GREEN<MATH CLASS="INLINE">
+-
+</MATH>REDUCE, a flag deciding
+whether the green list of each condition will be reduced in a form of
+a reduced Grobner basis. TOP<MATH CLASS="INLINE">
+-
+</MATH>REDUCTION<MATH CLASS="INLINE">
+-
+</MATH>ONLY, a flag deciding
+whether in the internal calculations in the space of parameters top
+reduction only will be used. RING, a structure as in the package
+COEFFICIENT<MATH CLASS="INLINE">
+-
+</MATH>RING, used in operations on the coefficients of the
+polynomials in parameters. </BLOCKQUOTE><H4><A NAME="SECTION000400200000000000000">
+<I>reorder<MATH CLASS="INLINE">
+-
+</MATH>pairs</I></A>
+</H4>
+<P><IMG WIDTH="518" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img83.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em b bnew g pred {\sf \&optional} (sort$-$first nil) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Reorder pairs according to some heuristic. The heuristic at this time
+is ad hoc, in the future it should be replaced with sugar strategy
+and a mechanism for implementing new heuristic strategies, as in the
+GROBNER package. </BLOCKQUOTE><H4><A NAME="SECTION000400210000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>criterion<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="471" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img84.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em i j f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Buchberger criterion 1 for colored polynomials.</BLOCKQUOTE><H4><A NAME="SECTION000400220000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>criterion<MATH CLASS="INLINE">
+-
+</MATH>2</I></A>
+</H4>
+<P><IMG WIDTH="471" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img85.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em i j f b s \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Buchberger criterion 2 for colored polynomials.</BLOCKQUOTE><H4><A NAME="SECTION000400230000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>normal<MATH CLASS="INLINE">
+-
+</MATH>form</I></A>
+</H4>
+<P><IMG WIDTH="474" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img86.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f fl main$-$order parameter$-$order top$-$reduction$-$only ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the conditional normal form of a colored polynomial F with
+respect to the list of colored polynomials FL. The list FL is assumed
+to consist of determined polynomials, i.e. such that the first term
+which is not marked :GREEN is :RED.</BLOCKQUOTE><H4><A NAME="SECTION000400240000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>spoly</I></A>
+</H4>
+<P><IMG WIDTH="530" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img87.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g main$-$order parameter$-$order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the conditional S<MATH CLASS="INLINE">
+-
+</MATH>polynomial of two colored polynomials F
+and G. Both polynomials are assumed to be determined.</BLOCKQUOTE><H4><A NAME="SECTION000400250000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>lm</I></A>
+</H4>
+<P><IMG WIDTH="549" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img88.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the conditional leading monomial of a colored polynomial F,
+which is assumed to be determined.</BLOCKQUOTE><H4><A NAME="SECTION000400260000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>lc</I></A>
+</H4>
+<P><IMG WIDTH="549" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img88.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the conditional leading coefficient of a colored polynomial
+F, which is assumed to be determined.</BLOCKQUOTE><H4><A NAME="SECTION000400270000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="426" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img89.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term f order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the product of a colored term TERM and a colored polynomial
+F. </BLOCKQUOTE><H4><A NAME="SECTION000400280000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="419" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img90.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c f ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the product of an element of the coefficient ring C a colored
+polynomial F. </BLOCKQUOTE><H4><A NAME="SECTION000400290000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term*</I></A>
+</H4>
+<P><IMG WIDTH="509" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img91.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term1 term2 order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the product of two colored terms TERM1 and TERM2.</BLOCKQUOTE><H4><A NAME="SECTION000400300000000000000">
+<I>color*</I></A>
+</H4>
+<P><IMG WIDTH="570" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img92.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c1 c2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns a product of two colores. Rules:
+:red * :red yields :red
+any * :green yields :green
+otherwise the result is :white.</BLOCKQUOTE><H4><A NAME="SECTION000400310000000000000">
+<I>color+</I></A>
+</H4>
+<P><IMG WIDTH="570" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img92.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c1 c2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns a sum of colors. Rules:
+:green + :green yields :green,
+:red + :green yields :red
+any other result is :white.</BLOCKQUOTE><H4><A NAME="SECTION000400320000000000000">
+<I>color<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="570" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img92.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em c1 c2 \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Identical to COLOR+.</BLOCKQUOTE><H4><A NAME="SECTION000400330000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly+</I></A>
+</H4>
+<P><IMG WIDTH="508" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img93.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q main$-$order parameter$-$order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the sum of colored polynomials P and Q.</BLOCKQUOTE><H4><A NAME="SECTION000400340000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="508" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img93.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q main$-$order parameter$-$order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the difference of colored polynomials P and Q.</BLOCKQUOTE><H4><A NAME="SECTION000400350000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>term<MATH CLASS="INLINE">
+-
+</MATH>uminus</I></A>
+</H4>
+<P><IMG WIDTH="455" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img94.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the negation of a colored term TERM.</BLOCKQUOTE><H4><A NAME="SECTION000400360000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>minus<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="446" HEIGHT="28" ALIGN="MIDDLE" BORDER="0"
+ SRC="img9.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the negation of a colored polynomial P.</BLOCKQUOTE><H4><A NAME="SECTION000400370000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+</H4>
+<P><IMG WIDTH="447" HEIGHT="150" ALIGN="MIDDLE" BORDER="0"
+ SRC="img95.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f vars params {\sf \&key} (cover
+ (list
+ (l...
+ ...meter$-$order)) (cover
+ (string$-$cover
+ cover
+ params
+ parameter$-$order)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+An interface to GROBNER<MATH CLASS="INLINE">
+-
+</MATH>SYSTEM in which polynomials can be
+specified in infix notations as strings. Lists of polynomials are
+comma<MATH CLASS="INLINE">
+-
+</MATH>separated list marked by a matchfix operators [] </BLOCKQUOTE><H4><A NAME="SECTION000400380000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+</H4>
+<P><IMG WIDTH="527" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img96.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond params {\sf \&optional} (order \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return the internal representation of a condition COND, specified
+as pairs of strings (GREEN<MATH CLASS="INLINE">
+-
+</MATH>LIST RED<MATH CLASS="INLINE">
+-
+</MATH>LIST). GREEN<MATH CLASS="INLINE">
+-
+</MATH>LIST and
+RED<MATH CLASS="INLINE">
+-
+</MATH>LIST in the input are assumed to be strings which parse to two
+lists of polynomials with respect to variables whose names are in the
+list of symbols PARAMS. ORDER is the predicate used to sort the terms
+of the polynomials.</BLOCKQUOTE><H4><A NAME="SECTION000400390000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>cover</I></A>
+</H4>
+<P><IMG WIDTH="523" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img97.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cover params {\sf \&optional} (order \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the internal representation of COVER, given in the form of
+a list of conditions. See STRING<MATH CLASS="INLINE">
+-
+</MATH>COND for description of a
+condition. </BLOCKQUOTE><H4><A NAME="SECTION000400400000000000000">
+<I>saturate<MATH CLASS="INLINE">
+-
+</MATH>cover</I></A>
+</H4>
+<P><IMG WIDTH="506" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img98.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cover order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Brings every condition of a list of conditions COVER to the form (G
+R) where G is saturated with respect to R and G is a Grobner basis
+We could reduce R so that the elements of R are relatively prime,
+but this is not currently done.</BLOCKQUOTE><H4><A NAME="SECTION000400410000000000000">
+<I>saturate<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+</H4>
+<P><IMG WIDTH="510" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img99.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Saturate a single condition COND. An auxillary function of
+SATURATE<MATH CLASS="INLINE">
+-
+</MATH>COVER. </BLOCKQUOTE><H4><A NAME="SECTION000400420000000000000">
+<I>string<MATH CLASS="INLINE">
+-
+</MATH>determine</I></A>
+</H4>
+<P><IMG WIDTH="492" HEIGHT="130" ALIGN="MIDDLE" BORDER="0"
+ SRC="img100.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f vars params {\sf \&key} (cond
+ '([] [])) ...
+ ...arameter$-$order)) (cond
+ (string$-$cond
+ cond
+ params
+ parameter$-$order)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+A string interface to DETERMINE. See the documentation of
+STRING<MATH CLASS="INLINE">
+-
+</MATH>GROBNER<MATH CLASS="INLINE">
+-
+</MATH>SYSTEM. </BLOCKQUOTE><H4><A NAME="SECTION000400430000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>grobner<MATH CLASS="INLINE">
+-
+</MATH>system</I></A>
+</H4>
+<P><IMG WIDTH="460" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img101.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em gs main$-$order parameter$-$order reduce green$-$reduce ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Apply TIDY<MATH CLASS="INLINE">
+-
+</MATH>PAIR to every pair of a Grobner system.</BLOCKQUOTE><H4><A NAME="SECTION000400440000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>pair</I></A>
+</H4>
+<P><IMG WIDTH="546" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img102.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em pair main$-$order parameter$-$order reduce green$-$reduce ring {\sf \&aux} gs \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Make the output of Grobner system more readable by performing
+certain simplifications on an element of a Grobner system.
+If REDUCE is non<MATH CLASS="INLINE">
+-
+</MATH>NIL then COLORED<MATH CLASS="INLINE">
+-
+</MATH>reduction will be performed.
+In addition TIDY<MATH CLASS="INLINE">
+-
+</MATH>COND is called on the condition part of the pair
+PAIR. </BLOCKQUOTE><H4><A NAME="SECTION000400450000000000000">
+<I>tidy<MATH CLASS="INLINE">
+-
+</MATH>cond</I></A>
+</H4>
+<P><IMG WIDTH="510" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img99.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Currently saturates condition COND and does RED<MATH CLASS="INLINE">
+-
+</MATH>REDUCTION on the
+red list. </BLOCKQUOTE><H4><A NAME="SECTION000400460000000000000">
+<I>colored<MATH CLASS="INLINE">
+-
+</MATH>reduction</I></A>
+</H4>
+<P><IMG WIDTH="485" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img103.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond p main$-$order parameter$-$order ring {\sf \&aux} (open
+ (list
+ (list
+ cond
+ nil
+ p))) closed \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Reduce a list of colored polynomials P.  The difficulty as compared
+to the usual Buchberger algorithm is that the polys may have the same
+leading monomial which may result in cancellations and polynomials
+which may not be determined. Thus, when we find those, we will have
+to split the condition by calling determine. Returns a list of pairs
+(COND' P') where P' is a reduced grobner basis with respect to any
+parameter choice compatible with condition COND'. Moreover, COND'
+form a cover of COND.</BLOCKQUOTE><H4><A NAME="SECTION000400470000000000000">
+<I>green<MATH CLASS="INLINE">
+-
+</MATH>reduce<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly</I></A>
+</H4>
+<P><IMG WIDTH="413" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img104.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond f parameter$-$order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+It takes a colored polynomial F and it returns a modified
+polynomial obtained by reducing coefficient of F modulo green list of
+the condition COND.</BLOCKQUOTE><H4><A NAME="SECTION000400480000000000000">
+<I>green<MATH CLASS="INLINE">
+-
+</MATH>reduce<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+</H4>
+<P><IMG WIDTH="421" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img105.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em cond fl parameter$-$order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Apply GREEN<MATH CLASS="INLINE">
+-
+</MATH>REDUCE<MATH CLASS="INLINE">
+-
+</MATH>COLORED<MATH CLASS="INLINE">
+-
+</MATH>POLY to a list of polynomials FL.</BLOCKQUOTE><H4><A NAME="SECTION000400490000000000000">
+<I>cond<MATH CLASS="INLINE">
+-
+</MATH>system<MATH CLASS="INLINE">
+-
+</MATH>green<MATH CLASS="INLINE">
+-
+</MATH>reduce</I></A>
+</H4>
+<P><IMG WIDTH="411" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img106.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em gs parameter$-$order ring \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Apply GREEN<MATH CLASS="INLINE">
+-
+</MATH>REDUCE<MATH CLASS="INLINE">
+-
+</MATH>COLORED<MATH CLASS="INLINE">
+-
+</MATH>LIST to every pair of
+a grobner system GS.</BLOCKQUOTE><H4><A NAME="SECTION000400500000000000000">
+<I>parse<MATH CLASS="INLINE">
+-
+</MATH>to<MATH CLASS="INLINE">
+-
+</MATH>colored<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+</H4>
+<P><IMG WIDTH="412" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img107.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f vars params main$-$order parameter$-$order {\sf \&aux} (k
+ (length
+ vars)) (vars$-$params
+ (append
+ vars
+ params)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Parse a list of polynomials F, given as a string, with respect to
+a list of variables VARS, given as a list of symbols, to the internal
+representation of a colored polynomial. The polynomials will be
+properly sorted by MAIN<MATH CLASS="INLINE">
+-
+</MATH>ORDER, with the coefficients, which are
+polynomials in parameters, sorted by PARAMETER<MATH CLASS="INLINE">
+-
+</MATH>ORDER. Both orders
+must be admissible monomial orders. This form is suitable for parsing
+polynomials with integer coefficients.</BLOCKQUOTE><H4><A NAME="SECTION000400510000000000000">
+<I>red<MATH CLASS="INLINE">
+-
+</MATH>reduction</I></A>
+</H4>
+<P><IMG WIDTH="513" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img108.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p pred ring {\sf \&aux} (p
+ (remove$-$if
+ \char93 'poly$-$constant$-$p
+ p)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Takes a family of polynomials and produce a list whose prime factors 
+are the same but they are relatively prime
+Repetitively used the following procedure: it finds two elements f, g
+of P which are not relatively prime; it replaces f and g with
+f/GCD(f,g), g/ GCD(f,f) and GCD(f,g).</BLOCKQUOTE><HR>
+<!--Navigation Panel-->
+<A NAME="tex2html855"
+ HREF="node5.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html852"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html846"
+ HREF="node3.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html854"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html856"
+ HREF="node5.html">The Coefficient Ring package</A>
+<B> Up:</B> <A NAME="tex2html853"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html847"
+ HREF="node3.html">The String Interface to</A>
+<!--End of Navigation Panel-->
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node5.html
===================================================================
--- /trunk/latex-doc/manual/node5.html	(revision 8)
+++ /trunk/latex-doc/manual/node5.html	(revision 8)
@@ -0,0 +1,201 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>The Coefficient Ring package</TITLE>
+<META NAME="description" CONTENT="The Coefficient Ring package">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node6.html">
+<LINK REL="previous" HREF="node4.html">
+<LINK REL="up" HREF="manual.html">
+<LINK REL="next" HREF="node6.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html917"
+ HREF="node6.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html914"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html908"
+ HREF="node4.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html916"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html918"
+ HREF="node6.html">The Division Package</A>
+<B> Up:</B> <A NAME="tex2html915"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html909"
+ HREF="node4.html">The Comprehensive Gr&#246;bner basis</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<!--Table of Child-Links-->
+<A NAME="CHILD_LINKS"><strong>Subsections</strong></A>
+<UL>
+<LI><A NAME="tex2html919"
+ HREF="node5.html#SECTION00050010000000000000">
+<I>ring</I></A>
+<LI><A NAME="tex2html920"
+ HREF="node5.html#SECTION00050020000000000000">
+<I>*ring<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>integers*</I></A>
+<LI><A NAME="tex2html921"
+ HREF="node5.html#SECTION00050030000000000000">
+<I>*field<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>rationals*</I></A>
+<LI><A NAME="tex2html922"
+ HREF="node5.html#SECTION00050040000000000000">
+<I>field<MATH CLASS="INLINE">
+-
+</MATH>modulo<MATH CLASS="INLINE">
+-
+</MATH>prime</I></A>
+<LI><A NAME="tex2html923"
+ HREF="node5.html#SECTION00050050000000000000">
+<I>*coefficient<MATH CLASS="INLINE">
+-
+</MATH>ring*</I></A>
+</UL>
+<!--End of Table of Child-Links-->
+<HR>
+<H1><A NAME="SECTION00050000000000000000">
+The Coefficient Ring package</A>
+</H1>
+<H4><A NAME="SECTION00050010000000000000">
+<I>ring</I></A>
+</H4>
+<P><IMG WIDTH="565" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img109.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em + $-$\space * / gcd lcm zerop unit length signum numerator denominator \/}$"> [<EM>STRUCTURE</EM>]
+<BLOCKQUOTE>
+The structure whose slots are bound to functions
+performing usual ring operations. In addition to usual arithmetical
+operations, bindings for other common operations
+which increase efficiency of Grobner basis calculations are also
+included. They are as follows:
+	GCD	<MATH CLASS="INLINE">
+-
+</MATH> greatest common divisor;
+	LCM	<MATH CLASS="INLINE">
+-
+</MATH> least common multiple;
+	ZEROP	<MATH CLASS="INLINE">
+-
+</MATH> test whether an element is zero;
+	SIGNUM  <MATH CLASS="INLINE">
+-
+</MATH> the sign of a ring element (+1, <MATH CLASS="INLINE">
+-
+</MATH>1 or zero);
+	UNIT	<MATH CLASS="INLINE">
+-
+</MATH> the unit of the ring;
+	NUMERATOR <MATH CLASS="INLINE">
+-
+</MATH> the numerator, if a ring of fractions
+	DENOMINATOR <MATH CLASS="INLINE">
+-
+</MATH> the denominator, if a ring of fractions
+	LENGTH  <MATH CLASS="INLINE">
+-
+</MATH> an integer giving the approximate length
+		of the representation; for example, for integers
+		its default binding is #'integer<MATH CLASS="INLINE">
+-
+</MATH>length;</BLOCKQUOTE><H4><A NAME="SECTION00050020000000000000">
+<I>*ring<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>integers*</I></A>
+</H4>
+<P><IMG WIDTH="482" HEIGHT="90" ALIGN="MIDDLE" BORDER="0"
+ SRC="img110.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em (make$-$ring :+ \char93 '+ :$-$\space \char...
+ ...$-$length :numerator \char93 'numerator
+ :denominator \char93 'denominator) \/}$"> [<EM>VARIABLE</EM>]
+<BLOCKQUOTE>
+Operations in the ring of integers.</BLOCKQUOTE><H4><A NAME="SECTION00050030000000000000">
+<I>*field<MATH CLASS="INLINE">
+-
+</MATH>of<MATH CLASS="INLINE">
+-
+</MATH>rationals*</I></A>
+</H4>
+<P><IMG WIDTH="475" HEIGHT="110" ALIGN="MIDDLE" BORDER="0"
+ SRC="img111.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em (make$-$ring :+ \char93 '+ :$-$\space \char...
+ ...or x))))
+ :numerator \char93 'numerator :denominator
+ \char93 'denominator) \/}$"> [<EM>VARIABLE</EM>]
+<BLOCKQUOTE>
+Operations on the field of rational numbers.</BLOCKQUOTE><H4><A NAME="SECTION00050040000000000000">
+<I>field<MATH CLASS="INLINE">
+-
+</MATH>modulo<MATH CLASS="INLINE">
+-
+</MATH>prime</I></A>
+</H4>
+<P><IMG WIDTH="467" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img112.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em modulus \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return a RING structure with operations bound
+to the arithmetical operations modulo MODULUS, which
+should be a prime.</BLOCKQUOTE><H4><A NAME="SECTION00050050000000000000">
+<I>*coefficient<MATH CLASS="INLINE">
+-
+</MATH>ring*</I></A>
+</H4>
+<P><IMG WIDTH="492" HEIGHT="30" ALIGN="MIDDLE" BORDER="0"
+ SRC="img113.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em *ring$-$of$-$integers* \/}$"> [<EM>VARIABLE</EM>]
+<BLOCKQUOTE>
+The default RING structure, used in most operations
+on the coefficients of polynomials. It should be carefully
+set if rings other than the default ring is used.</BLOCKQUOTE><HR>
+<!--Navigation Panel-->
+<A NAME="tex2html917"
+ HREF="node6.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html914"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html908"
+ HREF="node4.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html916"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html918"
+ HREF="node6.html">The Division Package</A>
+<B> Up:</B> <A NAME="tex2html915"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html909"
+ HREF="node4.html">The Comprehensive Gr&#246;bner basis</A>
+<!--End of Navigation Panel-->
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node6.html
===================================================================
--- /trunk/latex-doc/manual/node6.html	(revision 8)
+++ /trunk/latex-doc/manual/node6.html	(revision 8)
@@ -0,0 +1,98 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>The Division Package</TITLE>
+<META NAME="description" CONTENT="The Division Package">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node7.html">
+<LINK REL="previous" HREF="node5.html">
+<LINK REL="up" HREF="manual.html">
+<LINK REL="next" HREF="node7.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html933"
+ HREF="node7.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html930"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html924"
+ HREF="node5.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html932"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html934"
+ HREF="node7.html">The Dynamical Systems package</A>
+<B> Up:</B> <A NAME="tex2html931"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html925"
+ HREF="node5.html">The Coefficient Ring package</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<!--Table of Child-Links-->
+<A NAME="CHILD_LINKS"><strong>Subsections</strong></A>
+<UL>
+<LI><A NAME="tex2html935"
+ HREF="node6.html#SECTION00060010000000000000">
+<I>divide</I></A>
+<LI><A NAME="tex2html936"
+ HREF="node6.html#SECTION00060020000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>exact<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+</UL>
+<!--End of Table of Child-Links-->
+<HR>
+<H1><A NAME="SECTION00060000000000000000">
+The Division Package</A>
+</H1>
+<H4><A NAME="SECTION00060010000000000000">
+<I>divide</I></A>
+</H4>
+<P><IMG WIDTH="571" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img114.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f fl {\sf \&optional} (pred \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) {\sf \&aux} (s
+ (length
+ fl)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Divide polynomial F by a list of polynomials FL; use predicate PRED
+to sort monomials; assumes that the polynomials have initially been
+sorted according to PRED. It returnes multiple values. The first
+value is a list of quotients A.  The second value is the remainder R.
+These object satisfy the quation F = SUM A[J]*FL[I] + R.</BLOCKQUOTE><H4><A NAME="SECTION00060020000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>exact<MATH CLASS="INLINE">
+-
+</MATH>divide</I></A>
+</H4>
+<P><IMG WIDTH="480" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img115.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g {\sf \&optional} (order
+ \char93 'lex$\gt$) (ring
+ *coefficient$-$ring*) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Divide a polynomial F by another polynomial G. Assume that exact
+division with no remainder is possible. Returns the quotient.</BLOCKQUOTE>
+<BR><HR>
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node7.html
===================================================================
--- /trunk/latex-doc/manual/node7.html	(revision 8)
+++ /trunk/latex-doc/manual/node7.html	(revision 8)
@@ -0,0 +1,703 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>The Dynamical Systems package</TITLE>
+<META NAME="description" CONTENT="The Dynamical Systems package">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node8.html">
+<LINK REL="previous" HREF="node6.html">
+<LINK REL="up" HREF="manual.html">
+<LINK REL="next" HREF="node8.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html946"
+ HREF="node8.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html943"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html937"
+ HREF="node6.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html945"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html947"
+ HREF="node8.html">The Geometric Theorem Prover</A>
+<B> Up:</B> <A NAME="tex2html944"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html938"
+ HREF="node6.html">The Division Package</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<!--Table of Child-Links-->
+<A NAME="CHILD_LINKS"><strong>Subsections</strong></A>
+<UL>
+<LI><A NAME="tex2html948"
+ HREF="node7.html#SECTION00070010000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>composition</I></A>
+<LI><A NAME="tex2html949"
+ HREF="node7.html#SECTION00070020000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>composition</I></A>
+<LI><A NAME="tex2html950"
+ HREF="node7.html#SECTION00070030000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>dynamic<MATH CLASS="INLINE">
+-
+</MATH>power</I></A>
+<LI><A NAME="tex2html951"
+ HREF="node7.html#SECTION00070040000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>evaluate</I></A>
+<LI><A NAME="tex2html952"
+ HREF="node7.html#SECTION00070050000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>evaluate</I></A>
+<LI><A NAME="tex2html953"
+ HREF="node7.html#SECTION00070060000000000000">
+<I>factorial</I></A>
+<LI><A NAME="tex2html954"
+ HREF="node7.html#SECTION00070070000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+<LI><A NAME="tex2html955"
+ HREF="node7.html#SECTION00070080000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+<LI><A NAME="tex2html956"
+ HREF="node7.html#SECTION00070090000000000000">
+<I>standard<MATH CLASS="INLINE">
+-
+</MATH>vector</I></A>
+<LI><A NAME="tex2html957"
+ HREF="node7.html#SECTION000700100000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>partial</I></A>
+<LI><A NAME="tex2html958"
+ HREF="node7.html#SECTION000700110000000000000">
+<I>partial</I></A>
+<LI><A NAME="tex2html959"
+ HREF="node7.html#SECTION000700120000000000000">
+<I>determinant</I></A>
+<LI><A NAME="tex2html960"
+ HREF="node7.html#SECTION000700130000000000000">
+<I>minor</I></A>
+<LI><A NAME="tex2html961"
+ HREF="node7.html#SECTION000700140000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>row</I></A>
+<LI><A NAME="tex2html962"
+ HREF="node7.html#SECTION000700150000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>column</I></A>
+<LI><A NAME="tex2html963"
+ HREF="node7.html#SECTION000700160000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>elt</I></A>
+<LI><A NAME="tex2html964"
+ HREF="node7.html#SECTION000700170000000000000">
+<I>matrix<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html965"
+ HREF="node7.html#SECTION000700180000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html966"
+ HREF="node7.html#SECTION000700190000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html967"
+ HREF="node7.html#SECTION000700200000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html968"
+ HREF="node7.html#SECTION000700210000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>list<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+<LI><A NAME="tex2html969"
+ HREF="node7.html#SECTION000700220000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html970"
+ HREF="node7.html#SECTION000700230000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html971"
+ HREF="node7.html#SECTION000700240000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html972"
+ HREF="node7.html#SECTION000700250000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>combination</I></A>
+<LI><A NAME="tex2html973"
+ HREF="node7.html#SECTION000700260000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>combination<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+<LI><A NAME="tex2html974"
+ HREF="node7.html#SECTION000700270000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html975"
+ HREF="node7.html#SECTION000700280000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>polynomial</I></A>
+<LI><A NAME="tex2html976"
+ HREF="node7.html#SECTION000700290000000000000">
+<I>identity<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html977"
+ HREF="node7.html#SECTION000700300000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html978"
+ HREF="node7.html#SECTION000700310000000000000">
+<I>jacobi<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+<LI><A NAME="tex2html979"
+ HREF="node7.html#SECTION000700320000000000000">
+<I>jacobian</I></A>
+</UL>
+<!--End of Table of Child-Links-->
+<HR>
+<H1><A NAME="SECTION00070000000000000000">
+The Dynamical Systems package</A>
+</H1>
+<H4><A NAME="SECTION00070010000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>composition</I></A>
+</H4>
+<P><IMG WIDTH="435" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img116.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g {\sf \&optional} (order \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns a polynomial obtained by substituting a list of polynomials
+G=(G1,G2,...,GN) into a polynomial F(X1,X2,...,XN). All polynomials
+are assumed to be in the internal form, so variables do not
+explicitly apprear in the calculation. </BLOCKQUOTE><H4><A NAME="SECTION00070020000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>composition</I></A>
+</H4>
+<P><IMG WIDTH="435" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img116.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g {\sf \&optional} (order \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return the composition of a polynomial map F with a polynomial map
+G. Both maps are represented as lists of polynomials, and each
+polynomial is in the internal alist representation. The restriction
+is that the length of the list G must be the number of variables in
+the list F. </BLOCKQUOTE><H4><A NAME="SECTION00070030000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>dynamic<MATH CLASS="INLINE">
+-
+</MATH>power</I></A>
+</H4>
+<P><IMG WIDTH="459" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img117.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f n {\sf \&optional} (order \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Calculate the composition FoFo...oF (n times), where
+F is a polynomial map represented as a list of polynomials.</BLOCKQUOTE><H4><A NAME="SECTION00070040000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>evaluate</I></A>
+</H4>
+<P><IMG WIDTH="461" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img118.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f x {\sf \&optional} (order \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Evaluate a polynomial F at a point X. This operation is implemented
+through POLY<MATH CLASS="INLINE">
+-
+</MATH>SCALAR<MATH CLASS="INLINE">
+-
+</MATH>COMPOSITION.</BLOCKQUOTE><H4><A NAME="SECTION00070050000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>evaluate</I></A>
+</H4>
+<P><IMG WIDTH="461" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img118.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f x {\sf \&optional} (order \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Evaluate a polynomial map F, represented as list of polynomials, at a
+point X. </BLOCKQUOTE><H4><A NAME="SECTION00070060000000000000">
+<I>factorial</I></A>
+</H4>
+<P><IMG WIDTH="556" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img119.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em n {\sf \&optional} (k n) {\sf \&aux} (result 1) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return N!/(N<MATH CLASS="INLINE">
+-
+</MATH>K)!=N(N<MATH CLASS="INLINE">
+-
+</MATH>1)(N<MATH CLASS="INLINE">
+-
+</MATH>K+1).</BLOCKQUOTE><H4><A NAME="SECTION00070070000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>scalar<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+</H4>
+<P><IMG WIDTH="496" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img120.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f m \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return the partial derivative of a polynomial F over multiple
+ variables according to multiindex M.</BLOCKQUOTE><H4><A NAME="SECTION00070080000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>diff</I></A>
+</H4>
+<P><IMG WIDTH="496" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img120.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f m \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return the partial derivative of a polynomial map F, represented as a
+list of polynomials, with respect to several variables, according to
+multi<MATH CLASS="INLINE">
+-
+</MATH>index M. </BLOCKQUOTE><H4><A NAME="SECTION00070090000000000000">
+<I>standard<MATH CLASS="INLINE">
+-
+</MATH>vector</I></A>
+</H4>
+<P><IMG WIDTH="497" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img121.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em n k {\sf \&optional} (coeff
+ 1) {\sf \&aux} (v
+ (make$-$list
+ n
+ :initial$-$element
+ 0)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns vector (0 0 ... 1 ... 0 0) of length N, where 1 appears on
+K<MATH CLASS="INLINE">
+-
+</MATH>th place. </BLOCKQUOTE><H4><A NAME="SECTION000700100000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>partial</I></A>
+</H4>
+<P><IMG WIDTH="516" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img122.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f k {\sf \&optional} (l 1) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the L<MATH CLASS="INLINE">
+-
+</MATH>th partial derivative of a polynomial F over the
+K<MATH CLASS="INLINE">
+-
+</MATH>th variable. </BLOCKQUOTE><H4><A NAME="SECTION000700110000000000000">
+<I>partial</I></A>
+</H4>
+<P><IMG WIDTH="516" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img122.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f k {\sf \&optional} (l 1) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the L<MATH CLASS="INLINE">
+-
+</MATH>th partial derivative over the K<MATH CLASS="INLINE">
+-
+</MATH>th variable, of a
+polynomial map F, represented as a list of polynomials.</BLOCKQUOTE><H4><A NAME="SECTION000700120000000000000">
+<I>determinant</I></A>
+</H4>
+<P><IMG WIDTH="528" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img123.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (order \char93 'lex$\gt$) {\sf \&aux} (result nil) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the determinant of a polynomial matrix F, which is a list of
+rows of the matrix, each row is a list of polynomials.  The algorithm
+is recursive expansion along columns.</BLOCKQUOTE><H4><A NAME="SECTION000700130000000000000">
+<I>minor</I></A>
+</H4>
+<P><IMG WIDTH="572" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img124.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f i j {\sf \&optional} (order \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Calculate the minor of a polynomial matrix F with respect to entry
+(I,J). </BLOCKQUOTE><H4><A NAME="SECTION000700140000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>row</I></A>
+</H4>
+<P><IMG WIDTH="543" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img125.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f i \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Discards the I<MATH CLASS="INLINE">
+-
+</MATH>th row from a polynomial matrix F.</BLOCKQUOTE><H4><A NAME="SECTION000700150000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>column</I></A>
+</H4>
+<P><IMG WIDTH="517" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img126.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f j \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Discards the J<MATH CLASS="INLINE">
+-
+</MATH>th column from a polynomial matrix F.</BLOCKQUOTE><H4><A NAME="SECTION000700160000000000000">
+<I>drop<MATH CLASS="INLINE">
+-
+</MATH>elt</I></A>
+</H4>
+<P><IMG WIDTH="550" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img127.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em lst j \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Discards the J<MATH CLASS="INLINE">
+-
+</MATH>th element from a list LST.</BLOCKQUOTE><H4><A NAME="SECTION000700170000000000000">
+<I>matrix<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="435" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img116.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g {\sf \&optional} (order \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns difference of two polynomial matrices F and G.</BLOCKQUOTE><H4><A NAME="SECTION000700180000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+</H4>
+<P><IMG WIDTH="466" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img128.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em s f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns a product of a polynomial S by a polynomial matrix F.</BLOCKQUOTE><H4><A NAME="SECTION000700190000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+</H4>
+<P><IMG WIDTH="453" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img129.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns a product of a monomial M by a polynomial matrix F.</BLOCKQUOTE><H4><A NAME="SECTION000700200000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+</H4>
+<P><IMG WIDTH="472" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img130.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns a product of a term TERM by a polynomial matrix F.</BLOCKQUOTE><H4><A NAME="SECTION000700210000000000000">
+<I>poly<MATH CLASS="INLINE">
+-
+</MATH>list<MATH CLASS="INLINE">
+-
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="435" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img116.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f g {\sf \&optional} (order \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the list of differences of two lists of polynomials
+F and G (polynomial maps).</BLOCKQUOTE><H4><A NAME="SECTION000700220000000000000">
+<I>scalar<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+</H4>
+<P><IMG WIDTH="466" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img128.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em s f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the list of products of a polynomial S by the
+list of polynomials F.</BLOCKQUOTE><H4><A NAME="SECTION000700230000000000000">
+<I>monom<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+</H4>
+<P><IMG WIDTH="453" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img129.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the list of products of a monomial M by the
+list of polynomials F.</BLOCKQUOTE><H4><A NAME="SECTION000700240000000000000">
+<I>term<MATH CLASS="INLINE">
+-
+</MATH>times<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+</H4>
+<P><IMG WIDTH="472" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img130.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em term f \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the list of products of a term TERM by the
+list of polynomials F.</BLOCKQUOTE><H4><A NAME="SECTION000700250000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>combination</I></A>
+</H4>
+<P><IMG WIDTH="423" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img131.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b {\sf \&optional} (order
+ \char93 'lex$\gt$) {\sf \&aux} (n
+ (length
+ b)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns A <MATH CLASS="INLINE">
+-
+</MATH> U1 * B1 <MATH CLASS="INLINE">
+-
+</MATH> U2 * B2 <MATH CLASS="INLINE">
+-
+</MATH> ... <MATH CLASS="INLINE">
+-
+</MATH> UM * BM where A is a
+polynomial and B=(B1,B2,...,BM) is a polynomial list, where U1, U2,
+... , UM are new variables. These variables will be added to every
+polynomial A and BI as the last M variables.</BLOCKQUOTE><H4><A NAME="SECTION000700260000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>combination<MATH CLASS="INLINE">
+-
+</MATH>poly<MATH CLASS="INLINE">
+-
+</MATH>list</I></A>
+</H4>
+<P><IMG WIDTH="348" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img132.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b {\sf \&optional} (order
+ \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns A <MATH CLASS="INLINE">
+-
+</MATH> U1 * B1 <MATH CLASS="INLINE">
+-
+</MATH> U2 * B2 <MATH CLASS="INLINE">
+-
+</MATH> ... <MATH CLASS="INLINE">
+-
+</MATH> UM * BM where A is a
+polynomial list and B=(B1, B2, ... , BM) is a list of polynomial
+lists, where U1, U2, ... ,UM are new variables. These variables will
+be added to every polynomial A and BI as the last M variables. Se
+also CHARACTERISTIC<MATH CLASS="INLINE">
+-
+</MATH>COMBINATION. </BLOCKQUOTE><H4><A NAME="SECTION000700270000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+</H4>
+<P><IMG WIDTH="463" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img133.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a {\sf \&optional} (order
+ \char93 'lex$\gt$) (b
+ (list
+ (identity$-$matrix
+ (length a)
+ (length
+ (caaaar a))))) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns A <MATH CLASS="INLINE">
+-
+</MATH> U1*B1 <MATH CLASS="INLINE">
+-
+</MATH> U2*B2 <MATH CLASS="INLINE">
+-
+</MATH> ... <MATH CLASS="INLINE">
+-
+</MATH> UM * BM where A is a
+polynomial matrix and B=(B1,B2,...,BM) is a list of polynomial
+matrices, where U1, U2, .., UM are new variables. These variables
+will be added to every polynomial A and BI as the last M variables.
+Se also CHARACTERISTIC<MATH CLASS="INLINE">
+-
+</MATH>COMBINATION. </BLOCKQUOTE><H4><A NAME="SECTION000700280000000000000">
+<I>characteristic<MATH CLASS="INLINE">
+-
+</MATH>polynomial</I></A>
+</H4>
+<P><IMG WIDTH="463" HEIGHT="50" ALIGN="MIDDLE" BORDER="0"
+ SRC="img133.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a {\sf \&optional} (order
+ \char93 'lex$\gt$) (b
+ (list
+ (identity$-$matrix
+ (length a)
+ (length
+ (caaaar a))))) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the generalized characteristic polynomial, i.e. the
+determinant DET(A <MATH CLASS="INLINE">
+-
+</MATH> U1 * B1 <MATH CLASS="INLINE">
+-
+</MATH> U2 * B2 <MATH CLASS="INLINE">
+-
+</MATH> ... <MATH CLASS="INLINE">
+-
+</MATH> UM * BM), where
+A and BI are square polynomial matrices in N variables. The resulting
+polynomial will have N+M variables, with U1, U2, ..., UM added as the
+last M variables. </BLOCKQUOTE><H4><A NAME="SECTION000700290000000000000">
+<I>identity<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+</H4>
+<P><IMG WIDTH="503" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img134.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em dim nvars \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return the polynomial matrix which is the identity matrix. DIM is the
+requested dimension and NVARS is the number of variables of each
+entry. </BLOCKQUOTE><H4><A NAME="SECTION000700300000000000000">
+<I>print<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+</H4>
+<P><IMG WIDTH="522" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img135.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f vars \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Prints a polynomial matrix F, using a list of symbols VARS as
+variable names. </BLOCKQUOTE><H4><A NAME="SECTION000700310000000000000">
+<I>jacobi<MATH CLASS="INLINE">
+-
+</MATH>matrix</I></A>
+</H4>
+<P><IMG WIDTH="514" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img136.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (m (length f)) (n (length (caaaar f))) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the Jacobi matrix of a polynomial list F over the first N
+variables. </BLOCKQUOTE><H4><A NAME="SECTION000700320000000000000">
+<I>jacobian</I></A>
+</H4>
+<P><IMG WIDTH="554" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img137.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em f {\sf \&optional} (order \char93 'lex$\gt$) (m
+ (length f)) (n
+ (length
+ (caaaar f))) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Returns the Jacobian (determinant) of a polynomial list F over the
+first N variables. </BLOCKQUOTE><HR>
+<!--Navigation Panel-->
+<A NAME="tex2html946"
+ HREF="node8.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html943"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html937"
+ HREF="node6.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html945"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html947"
+ HREF="node8.html">The Geometric Theorem Prover</A>
+<B> Up:</B> <A NAME="tex2html944"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html938"
+ HREF="node6.html">The Division Package</A>
+<!--End of Navigation Panel-->
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node8.html
===================================================================
--- /trunk/latex-doc/manual/node8.html	(revision 8)
+++ /trunk/latex-doc/manual/node8.html	(revision 8)
@@ -0,0 +1,385 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>The Geometric Theorem Prover package</TITLE>
+<META NAME="description" CONTENT="The Geometric Theorem Prover package">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node9.html">
+<LINK REL="previous" HREF="node7.html">
+<LINK REL="up" HREF="manual.html">
+<LINK REL="next" HREF="node9.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html989"
+ HREF="node9.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html986"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html980"
+ HREF="node7.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html988"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html990"
+ HREF="node9.html">The Monomial Order Package</A>
+<B> Up:</B> <A NAME="tex2html987"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html981"
+ HREF="node7.html">The Dynamical Systems package</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<!--Table of Child-Links-->
+<A NAME="CHILD_LINKS"><strong>Subsections</strong></A>
+<UL>
+<LI><A NAME="tex2html991"
+ HREF="node8.html#SECTION00080010000000000000">
+<I>*prover<MATH CLASS="INLINE">
+-
+</MATH>order*</I></A>
+<LI><A NAME="tex2html992"
+ HREF="node8.html#SECTION00080020000000000000">
+<I>csym</I></A>
+<LI><A NAME="tex2html993"
+ HREF="node8.html#SECTION00080030000000000000">
+<I>real<MATH CLASS="INLINE">
+-
+</MATH>identical<MATH CLASS="INLINE">
+-
+</MATH>points</I></A>
+<LI><A NAME="tex2html994"
+ HREF="node8.html#SECTION00080040000000000000">
+<I>identical<MATH CLASS="INLINE">
+-
+</MATH>points</I></A>
+<LI><A NAME="tex2html995"
+ HREF="node8.html#SECTION00080050000000000000">
+<I>perpendicular</I></A>
+<LI><A NAME="tex2html996"
+ HREF="node8.html#SECTION00080060000000000000">
+<I>parallel</I></A>
+<LI><A NAME="tex2html997"
+ HREF="node8.html#SECTION00080070000000000000">
+<I>collinear</I></A>
+<LI><A NAME="tex2html998"
+ HREF="node8.html#SECTION00080080000000000000">
+<I>equidistant</I></A>
+<LI><A NAME="tex2html999"
+ HREF="node8.html#SECTION00080090000000000000">
+<I>euclidean<MATH CLASS="INLINE">
+-
+</MATH>distance</I></A>
+<LI><A NAME="tex2html1000"
+ HREF="node8.html#SECTION000800100000000000000">
+<I>midpoint</I></A>
+<LI><A NAME="tex2html1001"
+ HREF="node8.html#SECTION000800110000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>statements</I></A>
+<LI><A NAME="tex2html1002"
+ HREF="node8.html#SECTION000800120000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>assumptions</I></A>
+<LI><A NAME="tex2html1003"
+ HREF="node8.html#SECTION000800130000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>conclusions</I></A>
+<LI><A NAME="tex2html1004"
+ HREF="node8.html#SECTION000800140000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>theorem</I></A>
+<LI><A NAME="tex2html1005"
+ HREF="node8.html#SECTION000800150000000000000">
+<I>prove<MATH CLASS="INLINE">
+-
+</MATH>theorem</I></A>
+</UL>
+<!--End of Table of Child-Links-->
+<HR>
+<H1><A NAME="SECTION00080000000000000000">
+The Geometric Theorem Prover package</A>
+</H1>
+<H4><A NAME="SECTION00080010000000000000">
+<I>*prover<MATH CLASS="INLINE">
+-
+</MATH>order*</I></A>
+</H4>
+<P><IMG WIDTH="510" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img138.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em \char93 'grevlex$\gt$\space \/}$"> [<EM>VARIABLE</EM>]
+<BLOCKQUOTE>
+Admissible monomial order used internally in the proofs of theorems.</BLOCKQUOTE><H4><A NAME="SECTION00080020000000000000">
+<I>csym</I></A>
+</H4>
+<P><IMG WIDTH="577" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img139.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em symbol number \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return symbol whose name is a concatenation of (SYMBOL<MATH CLASS="INLINE">
+-
+</MATH>NAME SYMBOL)
+and a number NUMBER.</BLOCKQUOTE><H4><A NAME="SECTION00080030000000000000">
+<I>real<MATH CLASS="INLINE">
+-
+</MATH>identical<MATH CLASS="INLINE">
+-
+</MATH>points</I></A>
+</H4>
+<P><IMG WIDTH="504" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img140.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+Return [ (A1<MATH CLASS="INLINE">
+-
+</MATH>B1)**2 + (A2<MATH CLASS="INLINE">
+-
+</MATH>B2)**2 ] in lisp (prefix) notation.
+The second value is the list of variables (A1 B1 A2 B2). Note that
+if the distance between two complex points A, B is zero, it does not
+mean that the points are identical. Use IDENTICAL<MATH CLASS="INLINE">
+-
+</MATH>POINTS to express
+the fact that A and B are really identical. Use this macro in
+conclusions of theorems, as it may not be possible to prove that A
+and B are trully identical in the complex domain.</BLOCKQUOTE><H4><A NAME="SECTION00080040000000000000">
+<I>identical<MATH CLASS="INLINE">
+-
+</MATH>points</I></A>
+</H4>
+<P><IMG WIDTH="504" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img140.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+Return [ A1<MATH CLASS="INLINE">
+-
+</MATH>B1, A2<MATH CLASS="INLINE">
+-
+</MATH>B2 ] in lisp (prefix) notation.
+The second value is the list of variables (A1 B1 A2 B2). Note that
+sometimes one is able to prove only that (A1<MATH CLASS="INLINE">
+-
+</MATH>B1)**2 + (A2<MATH CLASS="INLINE">
+-
+</MATH>B2)**2
+= 0. This equation in the complex domain has solutions with A and B
+distinct. Use REAL<MATH CLASS="INLINE">
+-
+</MATH>IDENTICAL<MATH CLASS="INLINE">
+-
+</MATH>POINTS to express the fact that the
+distance between two points is 0. Use this macro in assumptions of
+theorems, although this is seldom necessary because we assume most of
+the time that in assumptions all points are distinct if they are
+denoted by different symbols. </BLOCKQUOTE><H4><A NAME="SECTION00080050000000000000">
+<I>perpendicular</I></A>
+</H4>
+<P><IMG WIDTH="562" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img141.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b c d \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+Return [ (A1<MATH CLASS="INLINE">
+-
+</MATH>B1) * (C1<MATH CLASS="INLINE">
+-
+</MATH>D1) + (A2<MATH CLASS="INLINE">
+-
+</MATH>B2) * (C2<MATH CLASS="INLINE">
+-
+</MATH>D2) ] in lisp
+(prefix) notation. The second value is the list of variables (A1 A2
+B1 B2 C1 C2 D1 D2). </BLOCKQUOTE><H4><A NAME="SECTION00080060000000000000">
+<I>parallel</I></A>
+</H4>
+<P><IMG WIDTH="562" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img141.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b c d \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+Return [ (A1<MATH CLASS="INLINE">
+-
+</MATH>B1) * (C2<MATH CLASS="INLINE">
+-
+</MATH>D2) <MATH CLASS="INLINE">
+-
+</MATH> (A2<MATH CLASS="INLINE">
+-
+</MATH>B2) * (C1<MATH CLASS="INLINE">
+-
+</MATH>D1) ] in lisp
+(prefix) notation. The second value is the list of variables (A1 A2
+B1 B2 C1 C2 D1 D2). </BLOCKQUOTE><H4><A NAME="SECTION00080070000000000000">
+<I>collinear</I></A>
+</H4>
+<P><IMG WIDTH="598" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img142.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b c \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+Return the determinant det([[A1,A2,1],[B1,B2,1],[C1,C2,1]]) in lisp
+(prefix) notation. The second value is the list of variables (A1 A2
+B1 B2 C1 C2). </BLOCKQUOTE><H4><A NAME="SECTION00080080000000000000">
+<I>equidistant</I></A>
+</H4>
+<P><IMG WIDTH="562" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img141.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b c d \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+Return the polynomial
+[(A1<MATH CLASS="INLINE">
+-
+</MATH>B1)**2+(A2<MATH CLASS="INLINE">
+-
+</MATH>B2)**2<MATH CLASS="INLINE">
+-
+</MATH>(C1<MATH CLASS="INLINE">
+-
+</MATH>D1)**2<MATH CLASS="INLINE">
+-
+</MATH>(C2<MATH CLASS="INLINE">
+-
+</MATH>D2)**2] in lisp
+(prefix) notation. The second value is the list of variables (A1 A2
+B1 B2 C1 C2 D1 D2). </BLOCKQUOTE><H4><A NAME="SECTION00080090000000000000">
+<I>euclidean<MATH CLASS="INLINE">
+-
+</MATH>distance</I></A>
+</H4>
+<P><IMG WIDTH="522" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img143.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b r \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+Return the polynomial [(A1<MATH CLASS="INLINE">
+-
+</MATH>B1)**2+(A2<MATH CLASS="INLINE">
+-
+</MATH>B2)**2<MATH CLASS="INLINE">
+-
+</MATH>R&#94;2] in
+lisp (prefix) notation. The second value is the list of variables (A1
+A2 B1 B2 R). </BLOCKQUOTE><H4><A NAME="SECTION000800100000000000000">
+<I>midpoint</I></A>
+</H4>
+<P><IMG WIDTH="598" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img142.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em a b c \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+Express the fact that C is a midpoint of the segment AB.
+Returns the list [ 2*C1<MATH CLASS="INLINE">
+-
+</MATH>A1<MATH CLASS="INLINE">
+-
+</MATH>B1, 2*C2<MATH CLASS="INLINE">
+-
+</MATH>A2<MATH CLASS="INLINE">
+-
+</MATH>B2 ]. The second value
+returned is the list of variables (A1 A2 B1 B2 C1 C2).</BLOCKQUOTE><H4><A NAME="SECTION000800110000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>statements</I></A>
+</H4>
+<P><IMG WIDTH="507" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img144.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em {\sf \&rest} statements \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000800120000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>assumptions</I></A>
+</H4>
+<P><IMG WIDTH="498" HEIGHT="29" ALIGN="MIDDLE" BORDER="0"
+ SRC="img145.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em {\sf \&rest} assumptions \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000800130000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>conclusions</I></A>
+</H4>
+<P><IMG WIDTH="504" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img146.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em {\sf \&rest} conclusions \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+  </BLOCKQUOTE><H4><A NAME="SECTION000800140000000000000">
+<I>translate<MATH CLASS="INLINE">
+-
+</MATH>theorem</I></A>
+</H4>
+<P><IMG WIDTH="526" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img147.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em ({\sf \&rest} assumptions) ({\sf \&rest} conclusions) \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+Translates a planar geometry theorem into a system of polynomial
+equations. Each assumption or conclusion takes form of a declaration
+(RELATION<MATH CLASS="INLINE">
+-
+</MATH>NAME A B C ...) where A B C are points, entered as
+symbols and RELATION<MATH CLASS="INLINE">
+-
+</MATH>NAME is a name of a geometric relation, for
+example, (COLLINEAR A B C) means that points A, B, C are all
+collinear. The translated equations use the convention that (A1,A2)
+are the coordinates of the point A. This macro returns multiple
+values. The first value is a list of polynomial expressions and the
+second value is an automatically generated list of variables from
+points A, B, C, etc. For convenience, several macros have been
+defined in order to make specifying common geometric relations easy. </BLOCKQUOTE><H4><A NAME="SECTION000800150000000000000">
+<I>prove<MATH CLASS="INLINE">
+-
+</MATH>theorem</I></A>
+</H4>
+<P><IMG WIDTH="549" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img148.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em ({\sf \&rest} assumptions) ({\sf \&rest}
+ conclusions) {\sf \&key} (order
+ *prover$-$order*) \/}$"> [<EM>MACRO</EM>]
+<BLOCKQUOTE>
+Proves a geometric theorem, specified in the same manner as in
+the macro TRANSLATE<MATH CLASS="INLINE">
+-
+</MATH>THEOREM. The proof is achieved by a call to
+IDEAL<MATH CLASS="INLINE">
+-
+</MATH>POLYSATURATION. The theorem is true if the returned value
+is a trivial ideal containing 1.</BLOCKQUOTE><HR>
+<!--Navigation Panel-->
+<A NAME="tex2html989"
+ HREF="node9.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html986"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html980"
+ HREF="node7.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html988"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html990"
+ HREF="node9.html">The Monomial Order Package</A>
+<B> Up:</B> <A NAME="tex2html987"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html981"
+ HREF="node7.html">The Dynamical Systems package</A>
+<!--End of Navigation Panel-->
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/manual/node9.html
===================================================================
--- /trunk/latex-doc/manual/node9.html	(revision 8)
+++ /trunk/latex-doc/manual/node9.html	(revision 8)
@@ -0,0 +1,230 @@
+<!--Converted with LaTeX2HTML 97.1 (release) (July 13th, 1997)
+ by Nikos Drakos (nikos@cbl.leeds.ac.uk), CBLU, University of Leeds
+* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
+* with significant contributions from:
+  Jens Lippman, Marek Rouchal, Martin Wilck and others -->
+<HTML>
+<HEAD>
+<TITLE>The Monomial Order Package</TITLE>
+<META NAME="description" CONTENT="The Monomial Order Package">
+<META NAME="keywords" CONTENT="manual">
+<META NAME="resource-type" CONTENT="document">
+<META NAME="distribution" CONTENT="global">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso_8859_1">
+<LINK REL="STYLESHEET" HREF="manual.css">
+<LINK REL="next" HREF="node10.html">
+<LINK REL="previous" HREF="node8.html">
+<LINK REL="up" HREF="manual.html">
+<LINK REL="next" HREF="node10.html">
+</HEAD>
+<BODY  bgcolor="#ffffff">
+<!--Navigation Panel-->
+<A NAME="tex2html1015"
+ HREF="node10.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html1012"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html1006"
+ HREF="node8.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html1014"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html1016"
+ HREF="node10.html">The Polynomial Package</A>
+<B> Up:</B> <A NAME="tex2html1013"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html1007"
+ HREF="node8.html">The Geometric Theorem Prover</A>
+<BR>
+<BR>
+<!--End of Navigation Panel-->
+<!--Table of Child-Links-->
+<A NAME="CHILD_LINKS"><strong>Subsections</strong></A>
+<UL>
+<LI><A NAME="tex2html1017"
+ HREF="node9.html#SECTION00090010000000000000">
+<I>lex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html1018"
+ HREF="node9.html#SECTION00090020000000000000">
+<I>total<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+<LI><A NAME="tex2html1019"
+ HREF="node9.html#SECTION00090030000000000000">
+<I>grlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html1020"
+ HREF="node9.html#SECTION00090040000000000000">
+<I>grevlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html1021"
+ HREF="node9.html#SECTION00090050000000000000">
+<I>revlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html1022"
+ HREF="node9.html#SECTION00090060000000000000">
+<I>invlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+<LI><A NAME="tex2html1023"
+ HREF="node9.html#SECTION00090070000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>order</I></A>
+<LI><A NAME="tex2html1024"
+ HREF="node9.html#SECTION00090080000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>order<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</UL>
+<!--End of Table of Child-Links-->
+<HR>
+<H1><A NAME="SECTION00090000000000000000">
+The Monomial Order Package</A>
+</H1>
+<H4><A NAME="SECTION00090010000000000000">
+<I>lex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="580" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img149.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q {\sf \&optional} (start 0) (end (length p)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return T if P<MATH CLASS="INLINE">
+&gt;
+</MATH>Q with respect to lexicographic order, otherwise NIL.
+The second returned value is T if P=Q, otherwise it is NIL.</BLOCKQUOTE><H4><A NAME="SECTION00090020000000000000">
+<I>total<MATH CLASS="INLINE">
+-
+</MATH>degree</I></A>
+</H4>
+<P><IMG WIDTH="522" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img150.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em m {\sf \&optional} (start 0) (end (length m)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return the todal degree of a monomoal M.</BLOCKQUOTE><H4><A NAME="SECTION00090030000000000000">
+<I>grlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="580" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img149.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q {\sf \&optional} (start 0) (end (length p)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return T if P<MATH CLASS="INLINE">
+&gt;
+</MATH>Q with respect to graded lexicographic order,
+otherwise NIL. The second returned value is T if P=Q, otherwise it is
+NIL. </BLOCKQUOTE><H4><A NAME="SECTION00090040000000000000">
+<I>grevlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="580" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img149.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q {\sf \&optional} (start 0) (end (length p)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return T if P<MATH CLASS="INLINE">
+&gt;
+</MATH>Q with respect to graded reverse lexicographic order,
+NIL otherwise. The second returned value is T if P=Q, otherwise it is
+NIL. </BLOCKQUOTE><H4><A NAME="SECTION00090050000000000000">
+<I>revlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="580" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img149.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q {\sf \&optional} (start 0) (end (length p)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return T if P<MATH CLASS="INLINE">
+&gt;
+</MATH>Q with respect to reverse lexicographic order, NIL
+otherwise.  The second returned value is T if P=Q, otherwise it is
+NIL. This is not and admissible monomial order because some sets do
+not have a minimal element. This order is useful in constructing
+other orders.</BLOCKQUOTE><H4><A NAME="SECTION00090060000000000000">
+<I>invlex<MATH CLASS="INLINE">
+&gt;
+</MATH></I></A>
+</H4>
+<P><IMG WIDTH="580" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img149.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em p q {\sf \&optional} (start 0) (end (length p)) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return T if P<MATH CLASS="INLINE">
+&gt;
+</MATH>Q with respect to inverse lexicographic order, NIL
+otherwise The second returned value is T if P=Q, otherwise it is NIL.</BLOCKQUOTE><H4><A NAME="SECTION00090070000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>order</I></A>
+</H4>
+<P><IMG WIDTH="488" HEIGHT="31" ALIGN="MIDDLE" BORDER="0"
+ SRC="img151.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em k {\sf \&key} (primary$-$order
+ \char93 'lex$\gt$) (secondary$-$order
+ \char93 'lex$\gt$) \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+Return a predicate which compares monomials according to the
+K<MATH CLASS="INLINE">
+-
+</MATH>th elimination order. Two optional arguments are PRIMARY<MATH CLASS="INLINE">
+-
+</MATH>ORDER
+and SECONDARY<MATH CLASS="INLINE">
+-
+</MATH>ORDER and they should be term orders which are used
+on the first K and the remaining variables.</BLOCKQUOTE><H4><A NAME="SECTION00090080000000000000">
+<I>elimination<MATH CLASS="INLINE">
+-
+</MATH>order<MATH CLASS="INLINE">
+-
+</MATH>1</I></A>
+</H4>
+<P><IMG WIDTH="466" HEIGHT="27" ALIGN="MIDDLE" BORDER="0"
+ SRC="img152.gif"
+ ALT="$\textstyle\parbox{\pboxargslen}{\em order \/}$"> [<EM>FUNCTION</EM>]
+<BLOCKQUOTE>
+A special case of the ELIMINATION<MATH CLASS="INLINE">
+-
+</MATH>ORDER when there is only
+one primary variable.</BLOCKQUOTE><HR>
+<!--Navigation Panel-->
+<A NAME="tex2html1015"
+ HREF="node10.html">
+<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next_motif.gif"></A> 
+<A NAME="tex2html1012"
+ HREF="manual.html">
+<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up_motif.gif"></A> 
+<A NAME="tex2html1006"
+ HREF="node8.html">
+<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="previous_motif.gif"></A> 
+<A NAME="tex2html1014"
+ HREF="node1.html">
+<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents_motif.gif"></A>  
+<BR>
+<B> Next:</B> <A NAME="tex2html1016"
+ HREF="node10.html">The Polynomial Package</A>
+<B> Up:</B> <A NAME="tex2html1013"
+ HREF="manual.html">CGBLisp User Guide and</A>
+<B> Previous:</B> <A NAME="tex2html1007"
+ HREF="node8.html">The Geometric Theorem Prover</A>
+<!--End of Navigation Panel-->
+<ADDRESS>
+<I>Marek Rychlik</I>
+<BR><I>3/21/1998</I>
+</ADDRESS>
+</BODY>
+</HTML>
Index: /trunk/latex-doc/modular-poly.tex
===================================================================
--- /trunk/latex-doc/modular-poly.tex	(revision 8)
+++ /trunk/latex-doc/modular-poly.tex	(revision 8)
@@ -0,0 +1,13 @@
+\begin{lisp:documentation}{modular$-$trace}{FUNCTION}{plist modulus }
+Return PLIST with coefficients reduced modulo prime MODULUS.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{modular$-$trace$-$1}{FUNCTION}{p modulus }
+Return a polynomial P with coefficients reduced modulo prime MODULUS.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{frobenius$-$kernel}{FUNCTION}{n modulus }
+Return a list of N polynomials of the form XI**MODULUS$-$XI, where
+XI is the I$-$th variable. Work in internal alist representation.
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/modular.tex
===================================================================
--- /trunk/latex-doc/modular.tex	(revision 8)
+++ /trunk/latex-doc/modular.tex	(revision 8)
@@ -0,0 +1,26 @@
+\begin{lisp:documentation}{modular$-$inverse}{FUNCTION}{x p }
+Find the inverse of X modulo prime P, using Euclid algorithm.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{modular$-$division}{FUNCTION}{x y p }
+Divide X by Y modulo prime P.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{*inverse$-$by$-$lookup$-$limit*}{VARIABLE}{100000 }
+If prime modulus is $<$ this number then the division algorithm
+will use a lookup table of inverses created at the time when
+field$-$modulo$-$prime is called. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{make$-$inverse$-$table}{FUNCTION}{modulus {\sf \&aux} (table (list 0)) }
+Make a vector of length MODULUS containing all inverses modulo
+MODULUS, which should be a prime number. The inverse of 0 is 0.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{make$-$modular$-$division}{FUNCTION}{modulus }
+Return a function of two arguments which will perform division
+modulo MODULUS. Currently, if MODULUS is $<$
+*INVERSE$-$BY$-$LOOKUP$-$LIMIT* then the returned function does table
+lookup, otherwise it uses the Euclid algorithm to find the inverse.
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/monom.tex
===================================================================
--- /trunk/latex-doc/monom.tex	(revision 8)
+++ /trunk/latex-doc/monom.tex	(revision 8)
@@ -0,0 +1,37 @@
+\begin{lisp:documentation}{monom/}{FUNCTION}{m1 m2 }
+Divide monomial M1 by monomial M2.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom*}{FUNCTION}{m1 m2 }
+Multiply monomial M1 by monomial M2.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{nmonom*}{FUNCTION}{m1 m2 }
+Multiply monomials M1 and M2 $-$ destructive version.
+ M1 is destructively modified, M2 is not modified.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$divides$-$p}{FUNCTION}{m1 m2 }
+Returns T if monomial M1 divides monomial M2, NIL otherwise.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$divisible$-$by$-$p}{FUNCTION}{m1 m2 }
+Returns T if monomial M1 is divisible by monomial M2, NIL otherwise.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$rel$-$prime}{FUNCTION}{m1 m2 }
+Returns T if two monomials M1 and M2 are relatively prime (disjoint).
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$equal}{FUNCTION}{m1 m2 }
+Returns T if two monomials M1 and M2 are equal.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$lcm}{FUNCTION}{m1 m2 }
+Returns least common multiple of monomials M1 and M2.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$gcd}{FUNCTION}{m1 m2 }
+Returns greatest common divisor of monomials M1 and M2.
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/order.tex
===================================================================
--- /trunk/latex-doc/order.tex	(revision 8)
+++ /trunk/latex-doc/order.tex	(revision 8)
@@ -0,0 +1,46 @@
+\begin{lisp:documentation}{lex$>$}{FUNCTION}{p q {\sf \&optional} (start 0) (end (length p)) }
+Return T if P$>$Q with respect to lexicographic order, otherwise NIL.
+The second returned value is T if P=Q, otherwise it is NIL.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{total$-$degree}{FUNCTION}{m {\sf \&optional} (start 0) (end (length m)) }
+Return the todal degree of a monomoal M.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{grlex$>$}{FUNCTION}{p q {\sf \&optional} (start 0) (end (length p)) }
+Return T if P$>$Q with respect to graded lexicographic order,
+otherwise NIL. The second returned value is T if P=Q, otherwise it is
+NIL. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{grevlex$>$}{FUNCTION}{p q {\sf \&optional} (start 0) (end (length p)) }
+Return T if P$>$Q with respect to graded reverse lexicographic order,
+NIL otherwise. The second returned value is T if P=Q, otherwise it is
+NIL. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{revlex$>$}{FUNCTION}{p q {\sf \&optional} (start 0) (end (length p)) }
+Return T if P$>$Q with respect to reverse lexicographic order, NIL
+otherwise.  The second returned value is T if P=Q, otherwise it is
+NIL. This is not and admissible monomial order because some sets do
+not have a minimal element. This order is useful in constructing
+other orders.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{invlex$>$}{FUNCTION}{p q {\sf \&optional} (start 0) (end (length p)) }
+Return T if P$>$Q with respect to inverse lexicographic order, NIL
+otherwise The second returned value is T if P=Q, otherwise it is NIL.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{elimination$-$order}{FUNCTION}{k {\sf \&key} (primary$-$order \#'lex$>$) (secondary$-$order \#'lex$>$) }
+Return a predicate which compares monomials according to the
+K$-$th elimination order. Two optional arguments are PRIMARY$-$ORDER
+and SECONDARY$-$ORDER and they should be term orders which are used
+on the first K and the remaining variables.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{elimination$-$order$-$1}{FUNCTION}{order }
+A special case of the ELIMINATION$-$ORDER when there is only
+one primary variable.
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/parse.tex
===================================================================
--- /trunk/latex-doc/parse.tex	(revision 8)
+++ /trunk/latex-doc/parse.tex	(revision 8)
@@ -0,0 +1,159 @@
+\begin{lisp:documentation}{parse}{FUNCTION}{{\sf \&optional} stream }
+Parser of infis expressions with integer/rational coefficients
+The parser will recognize two kinds of polynomial expressions:
+$-$ polynomials in fully expanded forms with coefficients
+ written in front of symbolic expressions; constants can be
+optionally enclosed in (); for example, the infix form
+X\symbol{94}2$-$Y\symbol{94}2+($-$4/3)*U\symbol{94}2*W\symbol{94}3$-$5 parses to
+	(+ ($-$ (EXPT X 2) (EXPT Y 2)) (* ($-$ (/ 4 3)) (EXPT U 2) (EXPT W
+3)) ($-$ 5)) 
+$-$ lists of polynomials; for example
+       [X$-$Y, X\symbol{94}2+3*Z]          
+ parses to
+	  (:[ ($-$ X Y) (+ (EXPT X 2) (* 3 Z)))
+ where the first symbol [ marks a list of polynomials.
+$-$other infix expressions, for example
+       [(X$-$Y)*(X+Y)/Z,(X+1)\symbol{94}2]
+parses to:
+	(:[ (/ (* ($-$ X Y) (+ X Y)) Z) (EXPT (+ X 1) 2))
+Currently this function is implemented using M. Kantrowitz's INFIX
+package. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{alist$-$form}{FUNCTION}{plist vars }
+Translates an expression PLIST, which should be a list of polynomials
+in variables VARS, to an alist representation of a polynomial.
+It returns the alist. See also PARSE$-$TO$-$ALIST.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{alist$-$form$-$1}{FUNCTION}{p vars {\sf \&aux} (ht (make$-$hash$-$table :test \#'equal :size 16)) stack }
+{\ } % NO DOCUMENTATION FOR ALIST-FORM-1
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{powers}{FUNCTION}{monom vars {\sf \&aux} (tab (pairlis vars (make$-$list (length vars) :initial$-$element 0))) }
+{\ } % NO DOCUMENTATION FOR POWERS
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{parse$-$to$-$alist}{FUNCTION}{vars {\sf \&optional} stream }
+Parse an expression already in prefix form to an association list
+form according to the internal CGBlisp polynomial syntax: a
+polynomial is an alist of pairs (MONOM . COEFFICIENT). For example:
+ (WITH$-$INPUT$-$FROM$-$STRING (S
+"X\symbol{94}2$-$Y\symbol{94}2+($-$4/3)*U\symbol{94}2*W\symbol{94}3$-$5") (PARSE$-$TO$-$ALIST '(X Y U W) S))
+evaluates to
+(((0 0 2 3) . $-$4/3) ((0 2 0 0) . $-$1) ((2 0 0 0) . 1) ((0 0 0 0) .
+$-$5)) 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{parse$-$string$-$to$-$alist}{FUNCTION}{str vars }
+Parse string STR and return a polynomial as a sorted association
+list of pairs (MONOM . COEFFICIENT). For example:
+(parse$-$string$-$to$-$alist
+"[x\symbol{94}2$-$y\symbol{94}2+($-$4/3)*u\symbol{94}2*w\symbol{94}3$-$5,y]" '(x y u w)) ([ (((0 0 2 3) . $-$4/3) ((0 2 0 0) . $-$1) ((2 0 0 0) . 1)
+    ((0 0 0 0) . $-$5))
+   (((0 1 0 0) . 1)))
+The functions PARSE$-$TO$-$SORTED$-$ALIST and
+PARSE$-$STRING$-$TO$-$SORTED$-$ALIST sort terms by the predicate
+defined in the ORDER package. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{parse$-$to$-$sorted$-$alist}{FUNCTION}{vars {\sf \&optional} (order \#'lex$>$) (stream t) }
+Parses streasm STREAM and returns a polynomial represented as 
+a sorted alist. For example:
+(WITH$-$INPUT$-$FROM$-$STRING (S
+"X\symbol{94}2$-$Y\symbol{94}2+($-$4/3)*U\symbol{94}2*W\symbol{94}3$-$5") (PARSE$-$TO$-$SORTED$-$ALIST '(X Y U W) S))
+returns
+(((2 0 0 0) . 1) ((0 2 0 0) . $-$1) ((0 0 2 3) . $-$4/3) ((0 0 0 0) .
+$-$5)) and
+(WITH$-$INPUT$-$FROM$-$STRING (S
+"X\symbol{94}2$-$Y\symbol{94}2+($-$4/3)*U\symbol{94}2*W\symbol{94}3$-$5") (PARSE$-$TO$-$SORTED$-$ALIST '(X Y U W) T \#'GRLEX$>$) S)
+returns
+(((0 0 2 3) . $-$4/3) ((2 0 0 0) . 1) ((0 2 0 0) . $-$1) ((0 0 0 0) .
+$-$5)) 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{parse$-$string$-$to$-$sorted$-$alist}{FUNCTION}{str vars {\sf \&optional} (order \#'lex$>$) }
+Parse a string to a sorted alist form, the internal representation
+of polynomials used by our system.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{sort$-$poly$-$1}{FUNCTION}{p order }
+Sort the terms of a single polynomial P using an admissible monomial
+order ORDER. Returns the sorted polynomial. Destructively modifies P.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{sort$-$poly}{FUNCTION}{poly$-$or$-$poly$-$list {\sf \&optional} (order \#'lex$>$) }
+Sort POLY$-$OR$-$POLY$-$LIST, which could be either a single
+polynomial or a list of polynomials in internal alist representation,
+using admissible monomial order ORDER. Each polynomial is sorted
+using SORT$-$POLY$-$1.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$eval$-$1}{FUNCTION}{expr vars order ring {\sf \&aux} (n (length vars)) }
+Evaluate an expression EXPR as polynomial
+by substituting operators + $-$ * expt with
+corresponding polynomial operators
+and variables VARS with monomials (1 0 ... 0), (0 1 ... 0) etc.
+We use special versions of binary
+operators \$poly+, \$poly$-$, \$minus$-$poly, \$poly* and
+\$poly$-$expt which work like the corresponding functions in the
+POLY package, but accept scalars as arguments as well.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$eval}{FUNCTION}{expr vars {\sf \&optional} (order \#'lex$>$) (ring *coefficient$-$ring*) }
+Evaluate an expression EXPR, which should be a polynomial
+expression or a list of polynomial expressions (a list of expressions
+marked by prepending keyword :[ to it) given in lisp prefix notation,
+in variables VARS, which should be a list of symbols. The result of
+the evaluation is a polynomial or a list of polynomials (marked by
+prepending symbol '[) in the internal alist form. This evaluator is
+used by the PARSE package to convert input from strings directly to
+internal form.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$basis}{FUNCTION}{n {\sf \&aux} (basis (copy$-$tree (make$-$list n :initial$-$element (list 'quote (list (cons (make$-$list n :initial$-$element 0) 1)))))) }
+Generate a list of monomials ((1 0 ... 0) (0 1 0 ... 0) ... (0 0 ...
+1) which correspond to linear monomials X1, X2, ... XN.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{convert$-$number}{FUNCTION}{number$-$or$-$poly n }
+Returns NUMBER$-$OR$-$POLY, if it is a polynomial. If it is a number,
+it converts it to the constant monomial in N variables. If the result
+is a number then convert it to a polynomial in N variables.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{\$poly+}{FUNCTION}{p q n order ring }
+Add two polynomials P and Q, where each polynomial is either a
+numeric constant or a polynomial in internal representation. If the
+result is a number then convert it to a polynomial in N variables.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{\$poly$-$}{FUNCTION}{p q n order ring }
+Subtract two polynomials P and Q, where each polynomial is either a
+numeric constant or a polynomial in internal representation. If the
+result is a number then convert it to a polynomial in N variables.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{\$minus$-$poly}{FUNCTION}{p n ring }
+Negation of P is a polynomial is either a numeric constant or a
+polynomial in internal representation. If the result is a number then
+convert it to a polynomial in N variables.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{\$poly*}{FUNCTION}{p q n order ring }
+Multiply two polynomials P and Q, where each polynomial is either a
+numeric constant or a polynomial in internal representation. If the
+result is a number then convert it to a polynomial in N variables.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{\$poly/}{FUNCTION}{p q ring }
+Divide a polynomials P which is either a numeric constant or a
+polynomial in internal representation, by a number Q.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{\$poly$-$expt}{FUNCTION}{p l n order ring }
+Raise polynomial P, which is a polynomial in internal
+representation or a numeric constant, to power L. If P is a number,
+convert the result to a polynomial in N variables.
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/poly-gcd.tex
===================================================================
--- /trunk/latex-doc/poly-gcd.tex	(revision 8)
+++ /trunk/latex-doc/poly-gcd.tex	(revision 8)
@@ -0,0 +1,36 @@
+\begin{lisp:documentation}{poly$-$gcd}{FUNCTION}{a b }
+{\ } % NO DOCUMENTATION FOR POLY-GCD
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$pseudo$-$divide}{FUNCTION}{f g }
+{\ } % NO DOCUMENTATION FOR POLY-PSEUDO-DIVIDE
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$pseudo$-$remainder}{FUNCTION}{f g }
+{\ } % NO DOCUMENTATION FOR POLY-PSEUDO-REMAINDER
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{mdeg}{FUNCTION}{b }
+{\ } % NO DOCUMENTATION FOR MDEG
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{lcoeff}{FUNCTION}{b }
+{\ } % NO DOCUMENTATION FOR LCOEFF
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{lrest}{FUNCTION}{b }
+{\ } % NO DOCUMENTATION FOR LREST
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{lpart}{FUNCTION}{b }
+{\ } % NO DOCUMENTATION FOR LPART
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$primitive$-$part}{FUNCTION}{f }
+{\ } % NO DOCUMENTATION FOR POLY-PRIMITIVE-PART
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$content}{FUNCTION}{f }
+{\ } % NO DOCUMENTATION FOR POLY-CONTENT
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/poly-with-sugar.tex
===================================================================
--- /trunk/latex-doc/poly-with-sugar.tex	(revision 8)
+++ /trunk/latex-doc/poly-with-sugar.tex	(revision 8)
@@ -0,0 +1,92 @@
+\begin{lisp:documentation}{poly$-$with$-$sugar$-$poly}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR POLY-WITH-SUGAR-POLY
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$with$-$sugar$-$sugar}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR POLY-WITH-SUGAR-SUGAR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$with$-$sugar$-$tail}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR POLY-WITH-SUGAR-TAIL
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{(setf poly$-$with$-$sugar$-$poly)}{SETF MAPPING}{poly }
+{\ } % NO DOCUMENTATION FOR (SETF POLY-WITH-SUGAR-POLY)
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{(setf poly$-$with$-$sugar$-$sugar)}{SETF MAPPING}{sugar }
+{\ } % NO DOCUMENTATION FOR (SETF POLY-WITH-SUGAR-SUGAR)
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{(setf poly$-$with$-$sugar$-$tail)}{SETF MAPPING}{tail }
+{\ } % NO DOCUMENTATION FOR (SETF POLY-WITH-SUGAR-TAIL)
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$sugar}{FUNCTION}{m }
+{\ } % NO DOCUMENTATION FOR MONOM-SUGAR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{coefficient$-$sugar}{FUNCTION}{c ring }
+{\ } % NO DOCUMENTATION FOR COEFFICIENT-SUGAR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{term$-$sugar}{FUNCTION}{term ring }
+{\ } % NO DOCUMENTATION FOR TERM-SUGAR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$add$-$sugar}{FUNCTION}{poly ring }
+{\ } % NO DOCUMENTATION FOR POLY-ADD-SUGAR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{scalar$-$times$-$poly$-$with$-$sugar}{FUNCTION}{c p ring }
+{\ } % NO DOCUMENTATION FOR SCALAR-TIMES-POLY-WITH-SUGAR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{term$-$times$-$poly$-$with$-$sugar}{FUNCTION}{term f ring }
+{\ } % NO DOCUMENTATION FOR TERM-TIMES-POLY-WITH-SUGAR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$times$-$poly$-$with$-$sugar}{FUNCTION}{m f }
+{\ } % NO DOCUMENTATION FOR MONOM-TIMES-POLY-WITH-SUGAR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{minus$-$poly$-$with$-$sugar}{FUNCTION}{f ring }
+{\ } % NO DOCUMENTATION FOR MINUS-POLY-WITH-SUGAR
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$with$-$sugar+}{FUNCTION}{p q pred ring }
+{\ } % NO DOCUMENTATION FOR POLY-WITH-SUGAR+
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$with$-$sugar$-$}{FUNCTION}{p q pred ring }
+{\ } % NO DOCUMENTATION FOR POLY-WITH-SUGAR-
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$with$-$sugar$-$op}{FUNCTION}{f term g pred ring }
+{\ } % NO DOCUMENTATION FOR POLY-WITH-SUGAR-OP
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$with$-$sugar$-$nreverse}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR POLY-WITH-SUGAR-NREVERSE
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$with$-$sugar$-$append}{FUNCTION}{p q }
+{\ } % NO DOCUMENTATION FOR POLY-WITH-SUGAR-APPEND
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$with$-$sugar$-$zerop}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR POLY-WITH-SUGAR-ZEROP
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$with$-$sugar$-$lm}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR POLY-WITH-SUGAR-LM
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$with$-$sugar$-$lc}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR POLY-WITH-SUGAR-LC
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$with$-$sugar$-$lt}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR POLY-WITH-SUGAR-LT
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/poly.tex
===================================================================
--- /trunk/latex-doc/poly.tex	(revision 8)
+++ /trunk/latex-doc/poly.tex	(revision 8)
@@ -0,0 +1,91 @@
+\begin{lisp:documentation}{scalar$-$times$-$poly}{FUNCTION}{c p {\sf \&optional} (ring *coefficient$-$ring*) }
+Return product of a scalar C by a polynomial P with coefficient ring
+RING. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{term$-$times$-$poly}{FUNCTION}{term f {\sf \&optional} (ring *coefficient$-$ring*) }
+Return product of a term TERM by a polynomial F with coefficient ring
+RING. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$times$-$poly}{FUNCTION}{m f }
+Return product of a monomial M by a polynomial F with coefficient
+ring RING. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{minus$-$poly}{FUNCTION}{f {\sf \&optional} (ring *coefficient$-$ring*) }
+Changes the sign of a polynomial F with coefficients in coefficient
+ring RING, and returns the result.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{sort$-$poly}{FUNCTION}{poly {\sf \&optional} (pred \#'lex$>$) (start 0) (end (unless (null poly) (length (caar poly)))) }
+Destructively Sorts a polynomial POLY by predicate PRED; the
+predicate is assumed to take arguments START and END in addition to
+the pair of monomials, as the functions in the ORDER package do.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly+}{FUNCTION}{p q {\sf \&optional} (pred \#'lex$>$) (ring *coefficient$-$ring*) }
+Returns the sum of two polynomials P and Q with coefficients in
+ring RING, with terms ordered according to monomial order PRED.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$}{FUNCTION}{p q {\sf \&optional} (pred \#'lex$>$) (ring *coefficient$-$ring*) }
+Returns the difference of two polynomials P and Q with coefficients
+in ring RING, with terms ordered according to monomial order PRED.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly*}{FUNCTION}{p q {\sf \&optional} (pred \#'lex$>$) (ring *coefficient$-$ring*) }
+Returns the product of two polynomials P and Q with coefficients in
+ring RING, with terms ordered according to monomial order PRED.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$op}{FUNCTION}{f m g pred ring }
+Returns F$-$M*G, where F and G are polynomials with coefficients in
+ring RING, ordered according to monomial order PRED and M is a
+monomial.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$expt}{FUNCTION}{poly n {\sf \&optional} (pred \#'lex$>$) (ring *coefficient$-$ring*) }
+Exponentiate a polynomial POLY to power N. The terms of the
+polynomial are assumed to be ordered by monomial order PRED and with
+coefficients in ring RING.  Use the Chinese algorithm; assume N$>$=0
+and POLY is non$-$zero (not NIL).
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$mexpt}{FUNCTION}{plist monom {\sf \&optional} (pred \#'lex$>$) (ring *coefficient$-$ring*) }
+Raise a polynomial vector represented ad a list of polynomials
+PLIST to power MULTIINDEX.  Every polynomial has its terms ordered by
+predicate PRED and coefficients in the ring RING.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$constant$-$p}{FUNCTION}{p }
+Returns T if P is a constant polynomial.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$extend}{FUNCTION}{p {\sf \&optional} (m (list 0)) }
+Given a polynomial P in k[x[r+1],...,xn], it returns the same
+polynomial as an element of k[x1,...,xn], optionally multiplying it
+by a monomial x1\symbol{94}m1*x2\symbol{94}m2*...*xr\symbol{94}mr,
+where m=(m1,m2,...,mr) is a multiindex.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$extend$-$end}{FUNCTION}{p {\sf \&optional} (m (list 0)) }
+Similar to POLY$-$EXTEND, but it adds new variables at the end.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$zerop}{FUNCTION}{p }
+Returns T if P is a zero polynomial.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{lt}{FUNCTION}{p }
+Returns the leading term of a polynomial P.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{lm}{FUNCTION}{p }
+Returns the leading monomial of a polynomial P.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{lc}{FUNCTION}{p }
+Returns the leading coefficient of a polynomial P.
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/printer.tex
===================================================================
--- /trunk/latex-doc/printer.tex	(revision 8)
+++ /trunk/latex-doc/printer.tex	(revision 8)
@@ -0,0 +1,29 @@
+\begin{lisp:documentation}{poly$-$print}{FUNCTION}{plist vars {\sf \&optional} (stream t) }
+Prints a polynomial or  a list of polynomials PLIST using infix
+syntax compatible with most software systems. The following data
+representations are assumed: 1) Polynomial list is ([ poly1 poly2
+...) 2) Polynomial is a list (term1 term2 ...)
+3) Term is (monom . number)
+4) Monom is (number1 number2 ...) and is a list of powers at
+corresponding variables
+Variable names must be provided to the printer explicitly.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$print$-$1}{FUNCTION}{p vars {\sf \&optional} (stream t) }
+An auxillary function of POLY$-$PRINT. It prints a single polynomial
+P. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$print$-$2}{FUNCTION}{plist vars stream {\sf \&optional} (beg t) }
+An auxillary function of POLY$-$PRINT. It prints a comma$-$separated
+list of polynomials PLIST. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{print$-$term}{FUNCTION}{l vars {\sf \&optional} (stream t) beg }
+An auxillary function of POLY$-$PRINT. It prints a single term L.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{print$-$monom}{FUNCTION}{l vars {\sf \&optional} (stream t) beg }
+An auxillary function of POLY$-$PRINT. It prints a single monomial L.
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/prover.tex
===================================================================
--- /trunk/latex-doc/prover.tex	(revision 8)
+++ /trunk/latex-doc/prover.tex	(revision 8)
@@ -0,0 +1,101 @@
+\begin{lisp:documentation}{*prover$-$order*}{VARIABLE}{\#'grevlex$>$ }
+Admissible monomial order used internally in the proofs of theorems.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{csym}{FUNCTION}{symbol number }
+Return symbol whose name is a concatenation of (SYMBOL$-$NAME SYMBOL)
+and a number NUMBER.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{real$-$identical$-$points}{MACRO}{a b }
+Return [ (A1$-$B1)**2 + (A2$-$B2)**2 ] in lisp (prefix) notation.
+The second value is the list of variables (A1 B1 A2 B2). Note that
+if the distance between two complex points A, B is zero, it does not
+mean that the points are identical. Use IDENTICAL$-$POINTS to express
+the fact that A and B are really identical. Use this macro in
+conclusions of theorems, as it may not be possible to prove that A
+and B are trully identical in the complex domain.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{identical$-$points}{MACRO}{a b }
+Return [ A1$-$B1, A2$-$B2 ] in lisp (prefix) notation.
+The second value is the list of variables (A1 B1 A2 B2). Note that
+sometimes one is able to prove only that (A1$-$B1)**2 + (A2$-$B2)**2
+= 0. This equation in the complex domain has solutions with A and B
+distinct. Use REAL$-$IDENTICAL$-$POINTS to express the fact that the
+distance between two points is 0. Use this macro in assumptions of
+theorems, although this is seldom necessary because we assume most of
+the time that in assumptions all points are distinct if they are
+denoted by different symbols. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{perpendicular}{MACRO}{a b c d }
+Return [ (A1$-$B1) * (C1$-$D1) + (A2$-$B2) * (C2$-$D2) ] in lisp
+(prefix) notation. The second value is the list of variables (A1 A2
+B1 B2 C1 C2 D1 D2). 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{parallel}{MACRO}{a b c d }
+Return [ (A1$-$B1) * (C2$-$D2) $-$ (A2$-$B2) * (C1$-$D1) ] in lisp
+(prefix) notation. The second value is the list of variables (A1 A2
+B1 B2 C1 C2 D1 D2). 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{collinear}{MACRO}{a b c }
+Return the determinant det([[A1,A2,1],[B1,B2,1],[C1,C2,1]]) in lisp
+(prefix) notation. The second value is the list of variables (A1 A2
+B1 B2 C1 C2). 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{equidistant}{MACRO}{a b c d }
+Return the polynomial
+[(A1$-$B1)**2+(A2$-$B2)**2$-$(C1$-$D1)**2$-$(C2$-$D2)**2] in lisp
+(prefix) notation. The second value is the list of variables (A1 A2
+B1 B2 C1 C2 D1 D2). 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{euclidean$-$distance}{MACRO}{a b r }
+Return the polynomial [(A1$-$B1)**2+(A2$-$B2)**2$-$R\symbol{94}2] in
+lisp (prefix) notation. The second value is the list of variables (A1
+A2 B1 B2 R). 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{midpoint}{MACRO}{a b c }
+Express the fact that C is a midpoint of the segment AB.
+Returns the list [ 2*C1$-$A1$-$B1, 2*C2$-$A2$-$B2 ]. The second value
+returned is the list of variables (A1 A2 B1 B2 C1 C2).
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{translate$-$statements}{MACRO}{{\sf \&rest} statements }
+{\ } % NO DOCUMENTATION FOR TRANSLATE-STATEMENTS
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{translate$-$assumptions}{MACRO}{{\sf \&rest} assumptions }
+{\ } % NO DOCUMENTATION FOR TRANSLATE-ASSUMPTIONS
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{translate$-$conclusions}{MACRO}{{\sf \&rest} conclusions }
+{\ } % NO DOCUMENTATION FOR TRANSLATE-CONCLUSIONS
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{translate$-$theorem}{MACRO}{({\sf \&rest} assumptions) ({\sf \&rest} conclusions) }
+Translates a planar geometry theorem into a system of polynomial
+equations. Each assumption or conclusion takes form of a declaration
+(RELATION$-$NAME A B C ...) where A B C are points, entered as
+symbols and RELATION$-$NAME is a name of a geometric relation, for
+example, (COLLINEAR A B C) means that points A, B, C are all
+collinear. The translated equations use the convention that (A1,A2)
+are the coordinates of the point A. This macro returns multiple
+values. The first value is a list of polynomial expressions and the
+second value is an automatically generated list of variables from
+points A, B, C, etc. For convenience, several macros have been
+defined in order to make specifying common geometric relations easy. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{prove$-$theorem}{MACRO}{({\sf \&rest} assumptions) ({\sf \&rest} conclusions) {\sf \&key} (order *prover$-$order*) }
+Proves a geometric theorem, specified in the same manner as in
+the macro TRANSLATE$-$THEOREM. The proof is achieved by a call to
+IDEAL$-$POLYSATURATION. The theorem is true if the returned value
+is a trivial ideal containing 1.
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/rat.tex
===================================================================
--- /trunk/latex-doc/rat.tex	(revision 8)
+++ /trunk/latex-doc/rat.tex	(revision 8)
@@ -0,0 +1,61 @@
+\begin{lisp:documentation}{num}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR NUM
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{denom}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR DENOM
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{rat$-$simplify$-$2}{FUNCTION}{num denom }
+{\ } % NO DOCUMENTATION FOR RAT-SIMPLIFY-2
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{rat$-$simplify}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR RAT-SIMPLIFY
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{rat+}{FUNCTION}{p q }
+{\ } % NO DOCUMENTATION FOR RAT+
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{rat$-$}{FUNCTION}{p q }
+{\ } % NO DOCUMENTATION FOR RAT-
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{rat*}{FUNCTION}{p q }
+{\ } % NO DOCUMENTATION FOR RAT*
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{rat/}{FUNCTION}{p q }
+{\ } % NO DOCUMENTATION FOR RAT/
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{scalar$-$times$-$rat}{FUNCTION}{scalar p }
+{\ } % NO DOCUMENTATION FOR SCALAR-TIMES-RAT
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{scalar$-$div$-$rat}{FUNCTION}{scalar p }
+{\ } % NO DOCUMENTATION FOR SCALAR-DIV-RAT
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{rat$-$zerop}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR RAT-ZEROP
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{rat$-$uminus}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR RAT-UMINUS
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{rat$-$expt}{FUNCTION}{p n }
+{\ } % NO DOCUMENTATION FOR RAT-EXPT
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{rat$-$constant}{FUNCTION}{c n }
+Make a constant rational function equal to c with n variables
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{rat$-$to$-$poly}{FUNCTION}{p }
+Attempt to convert a rational function to a polynomial by
+dividing numerator by denominator. Error if not divisible
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/ratpoly.tex
===================================================================
--- /trunk/latex-doc/ratpoly.tex	(revision 8)
+++ /trunk/latex-doc/ratpoly.tex	(revision 8)
@@ -0,0 +1,100 @@
+\begin{lisp:documentation}{ratpoly+}{FUNCTION}{p q }
+Add polynomials P and Q.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly$-$}{FUNCTION}{p q }
+{\ } % NO DOCUMENTATION FOR RATPOLY-
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly$-$uminus}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR RATPOLY-UMINUS
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly*}{FUNCTION}{p q }
+Multiply polynomials P and Q.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{scalar$-$times$-$ratpoly}{FUNCTION}{scalar p }
+Multiply scalar SCALAR by a polynomial P.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{rat$-$times$-$ratpoly}{FUNCTION}{scalar p }
+Multiply rational function SCALAR by a polynomial P.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly$-$divide}{FUNCTION}{f g }
+Divide polynomial F by G. Return quotient and remainder as multiple
+values. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly$-$remainder}{FUNCTION}{f g }
+The remainder of the division of a polynomial F by G.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly$-$gcd}{FUNCTION}{f g }
+Return GCD of polynomials F and G.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly$-$diff}{FUNCTION}{f }
+Differentiate a polynomial.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly$-$square$-$free}{FUNCTION}{f }
+Return the square$-$free part of a polynomial F.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly$-$normalize}{FUNCTION}{f }
+Divide a non$-$zero polynomial by the coefficient at the highest
+power. 
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly$-$resultant}{FUNCTION}{f g }
+Return the resultant of polynomials F and G.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{deg}{FUNCTION}{s }
+{\ } % NO DOCUMENTATION FOR DEG
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{lead}{FUNCTION}{s }
+{\ } % NO DOCUMENTATION FOR LEAD
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly$-$discriminant}{FUNCTION}{p {\sf \&aux} (l (deg p)) }
+The discriminant of a polynomial P.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly$-$print}{FUNCTION}{p vars {\sf \&optional} (stream t) (beg t) (p$-$orig p) }
+{\ } % NO DOCUMENTATION FOR RATPOLY-PRINT
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$to$-$ratpoly}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR POLY-TO-RATPOLY
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$to$-$poly1}{FUNCTION}{p {\sf \&aux} (htab (make$-$hash$-$table)) q }
+{\ } % NO DOCUMENTATION FOR POLY-TO-POLY1
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly1$-$to$-$ratpoly}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR POLY1-TO-RATPOLY
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly$-$to$-$poly1}{FUNCTION}{p }
+Convert every coefficient of ratpoly to polynomial if possible
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly1$-$to$-$poly}{FUNCTION}{p }
+Convert a ratpoly, whose coeffs have been converted to poly,
+into a poly structure, i.e. tack in powers of first variable.
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{ratpoly$-$to$-$poly}{FUNCTION}{p }
+{\ } % NO DOCUMENTATION FOR RATPOLY-TO-POLY
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$resultant}{FUNCTION}{f g }
+Calculate resultant of F and G given in poly i.e. alist
+representation. 
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/string-grobner.tex
===================================================================
--- /trunk/latex-doc/string-grobner.tex	(revision 8)
+++ /trunk/latex-doc/string-grobner.tex	(revision 8)
@@ -0,0 +1,151 @@
+\begin{lisp:documentation}{string$-$normal$-$form}{FUNCTION}{f fl vars {\sf \&key} (stream t) (print t) (order \#'lex$>$) (top$-$reduction$-$only nil) (ring *coefficient$-$ring*) (suppress$-$value
+                                                                                                                                                                                    t) {\sf \&aux} (vars
+                                                                                                                                                                                                    (read$-$vars
+                                                                                                                                                                                                     vars)) }
+{\ } % NO DOCUMENTATION FOR STRING-NORMAL-FORM
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$grobner}{FUNCTION}{plist vars {\sf \&key} (order \#'lex$>$) (start 0) (stream t) (reduce t) (reduce$-$before t) (suppress$-$value t) (top$-$reduction$-$only nil) (ring
+                                                                                                                                                                                                       *coefficient$-$ring*) (print
+                                                                                                                                                                                                                              t) {\sf \&aux} (vars
+                                                                                                                                                                                                                                              (read$-$vars
+                                                                                                                                                                                                                                               vars)) }
+{\ } % NO DOCUMENTATION FOR STRING-GROBNER
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$elimination$-$ideal}{FUNCTION}{flist vars k {\sf \&key} (stream t) (key \#'identity) (primary$-$order \#'grevlex$>$) (secondary$-$order \#'grevlex$>$) (suppress$-$value
+                                                                                                                                                                                            t) (order
+                                                                                                                                                                                                (elimination$-$order
+                                                                                                                                                                                                 k
+                                                                                                                                                                                                 :primary$-$order
+                                                                                                                                                                                                 primary$-$order
+                                                                                                                                                                                                 :secondary$-$order
+                                                                                                                                                                                                 secondary$-$order)) {\sf \&aux} (vars
+                                                                                                                                                                                                                                  (read$-$vars
+                                                                                                                                                                                                                                   vars)) }
+{\ } % NO DOCUMENTATION FOR STRING-ELIMINATION-IDEAL
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$ideal$-$intersection}{FUNCTION}{f g vars {\sf \&key} (order \#'lex$>$) (top$-$reduction$-$only nil) (ring *coefficient$-$ring*) (stream t) (suppress$-$value
+                                                                                                                                                                                t) {\sf \&aux} (vars
+                                                                                                                                                                                                (read$-$vars
+                                                                                                                                                                                                 vars)) (f
+                                                                                                                                                                                                         (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                          f
+                                                                                                                                                                                                          vars
+                                                                                                                                                                                                          order)) (g
+                                                                                                                                                                                                                   (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                                    g
+                                                                                                                                                                                                                    vars
+                                                                                                                                                                                                                    order)) }
+{\ } % NO DOCUMENTATION FOR STRING-IDEAL-INTERSECTION
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$poly$-$lcm}{FUNCTION}{f g vars {\sf \&key} (order \#'lex$>$) (ring *coefficient$-$ring*) (stream t) (suppress$-$value t) {\sf \&aux} (vars (read$-$vars vars)) (f
+                                                                                                                                                                                                    (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                     f
+                                                                                                                                                                                                     vars
+                                                                                                                                                                                                     order)) (g
+                                                                                                                                                                                                              (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                               g
+                                                                                                                                                                                                               vars
+                                                                                                                                                                                                               order)) }
+{\ } % NO DOCUMENTATION FOR STRING-POLY-LCM
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$ideal$-$saturation$-$1}{FUNCTION}{f p vars {\sf \&key} (order \#'lex$>$) (start 0) (top$-$reduction$-$only nil) (ring *coefficient$-$ring*) (stream
+                                                                                                                                                                                 t) (suppress$-$value
+                                                                                                                                                                                     t) {\sf \&aux} (vars
+                                                                                                                                                                                                     (read$-$vars
+                                                                                                                                                                                                      vars)) (f
+                                                                                                                                                                                                              (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                               f
+                                                                                                                                                                                                               vars
+                                                                                                                                                                                                               order)) (p
+                                                                                                                                                                                                                        (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                                         p
+                                                                                                                                                                                                                         vars
+                                                                                                                                                                                                                         order)) }
+{\ } % NO DOCUMENTATION FOR STRING-IDEAL-SATURATION-1
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$ideal$-$polysaturation$-$1}{FUNCTION}{f plist vars {\sf \&key} (order \#'lex$>$) (start 0) (top$-$reduction$-$only nil) (ring *coefficient$-$ring*) (stream
+                                                                                                                                                                                         t) (suppress$-$value
+                                                                                                                                                                                             t) {\sf \&aux} (vars
+                                                                                                                                                                                                             (read$-$vars
+                                                                                                                                                                                                              vars)) (f
+                                                                                                                                                                                                                      (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                                       f
+                                                                                                                                                                                                                       vars
+                                                                                                                                                                                                                       order)) (plist
+                                                                                                                                                                                                                                (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                                                 plist
+                                                                                                                                                                                                                                 vars
+                                                                                                                                                                                                                                 order)) }
+{\ } % NO DOCUMENTATION FOR STRING-IDEAL-POLYSATURATION-1
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$ideal$-$saturation}{FUNCTION}{f g vars {\sf \&key} (order \#'lex$>$) (start 0) (top$-$reduction$-$only nil) (ring *coefficient$-$ring*) (stream
+                                                                                                                                                                             t) (suppress$-$value
+                                                                                                                                                                                 t) {\sf \&aux} (vars
+                                                                                                                                                                                                 (read$-$vars
+                                                                                                                                                                                                  vars)) (f
+                                                                                                                                                                                                          (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                           f
+                                                                                                                                                                                                           vars
+                                                                                                                                                                                                           order)) (g
+                                                                                                                                                                                                                    (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                                     g
+                                                                                                                                                                                                                     vars
+                                                                                                                                                                                                                     order)) }
+{\ } % NO DOCUMENTATION FOR STRING-IDEAL-SATURATION
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$ideal$-$polysaturation}{FUNCTION}{f ideal$-$list vars {\sf \&key} (order \#'lex$>$) (start 0) (top$-$reduction$-$only nil) (ring *coefficient$-$ring*) (stream
+                                                                                                                                                                                            t) (suppress$-$value
+                                                                                                                                                                                                t) {\sf \&aux} (vars
+                                                                                                                                                                                                                (read$-$vars
+                                                                                                                                                                                                                 vars)) (f
+                                                                                                                                                                                                                         (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                                          f
+                                                                                                                                                                                                                          vars
+                                                                                                                                                                                                                          order)) (ideal$-$list
+                                                                                                                                                                                                                                   (mapcar
+                                                                                                                                                                                                                                    \#'(lambda (g) (parse$-$string$-$to$-$sorted$-$alist g vars order))
+                                                                                                                                                                                                                                    ideal$-$list)) }
+{\ } % NO DOCUMENTATION FOR STRING-IDEAL-POLYSATURATION
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$colon$-$ideal}{FUNCTION}{f g vars {\sf \&key} (top$-$reduction$-$only nil) (ring *coefficient$-$ring*) (stream t) (order \#'lex$>$) (suppress$-$value t) {\sf \&aux} (vars
+                                                                                                                                                                                                          (read$-$vars
+                                                                                                                                                                                                           vars)) (f
+                                                                                                                                                                                                                   (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                                    f
+                                                                                                                                                                                                                    vars
+                                                                                                                                                                                                                    order)) (g
+                                                                                                                                                                                                                             (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                                              g
+                                                                                                                                                                                                                              vars
+                                                                                                                                                                                                                              order)) }
+{\ } % NO DOCUMENTATION FOR STRING-COLON-IDEAL
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{string$-$read$-$poly}{FUNCTION}{f vars {\sf \&key} (order \#'lex$>$) (suppress$-$value nil) (stream t) (convert$-$rational$-$to$-$integer t) {\sf \&aux} (vars
+                                                                                                                                                                                     (read$-$vars vars)) (f
+                                                                                                                                                                                                          (parse$-$string$-$to$-$sorted$-$alist
+                                                                                                                                                                                                           f
+                                                                                                                                                                                                           vars
+                                                                                                                                                                                                           order)) }
+{\ } % NO DOCUMENTATION FOR STRING-READ-POLY
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{poly$-$rational$-$to$-$integer}{FUNCTION}{p {\sf \&optional} (ring *coefficient$-$ring*) }
+{\ } % NO DOCUMENTATION FOR POLY-RATIONAL-TO-INTEGER
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{read$-$vars}{FUNCTION}{string$-$or$-$list }
+Read a list of variables, specified either as a list of symbols or a
+string listing variables in the form of a comma$-$separated list,
+delimited by [,] 
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/term.tex
===================================================================
--- /trunk/latex-doc/term.tex	(revision 8)
+++ /trunk/latex-doc/term.tex	(revision 8)
@@ -0,0 +1,32 @@
+\begin{lisp:documentation}{term*}{FUNCTION}{term1 term2 {\sf \&optional} (ring *coefficient$-$ring*) }
+{\ } % NO DOCUMENTATION FOR TERM*
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{term/}{FUNCTION}{term1 term2 {\sf \&optional} (ring *coefficient$-$ring*) }
+{\ } % NO DOCUMENTATION FOR TERM/
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{monom$-$times$-$term}{FUNCTION}{m term }
+{\ } % NO DOCUMENTATION FOR MONOM-TIMES-TERM
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{term$-$divides$-$p}{FUNCTION}{term1 term2 }
+{\ } % NO DOCUMENTATION FOR TERM-DIVIDES-P
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{term$-$monom}{MACRO}{term }
+{\ } % NO DOCUMENTATION FOR TERM-MONOM
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{term$-$coefficient}{MACRO}{term }
+{\ } % NO DOCUMENTATION FOR TERM-COEFFICIENT
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{(setf term$-$monom)}{SETF MAPPING}{monom }
+{\ } % NO DOCUMENTATION FOR (SETF TERM-MONOM)
+\end{lisp:documentation}
+
+\begin{lisp:documentation}{(setf term$-$coefficient)}{SETF MAPPING}{coefficient }
+{\ } % NO DOCUMENTATION FOR (SETF TERM-COEFFICIENT)
+\end{lisp:documentation}
+
Index: /trunk/latex-doc/xgcd.tex
===================================================================
--- /trunk/latex-doc/xgcd.tex	(revision 8)
+++ /trunk/latex-doc/xgcd.tex	(revision 8)
@@ -0,0 +1,11 @@
+\begin{lisp:documentation}{xgcd}{FUNCTION}{x y }
+Extended gcd; the call
+     (xgcd X Y)
+returns a multiple value list:
+$-$ GCD
+$-$ U,V  such that they solve the equation
+    GCD=U*X+V*Y
+$-$ U1,V1 such that
+    LCM=U1*X=V1*Y (up to the sign).
+\end{lisp:documentation}
+
