\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}