;;; 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 [,] 
;;;