
(/VERSIONCHECK 2) 

(DEFUN |PGROEB;lexGroebner;LLL;1| (|lp| |lv| $)
  (PROG (PP |DPoly| DP OV #0=#:G1820 |pol| #1=#:G1821 |b| |gb|
            #2=#:G1822 |pp| #3=#:G1823)
    (RETURN
      (SEQ (LETT PP (|PolToPol| |lv| (QREFELT $ 6))
                 . #4=(|PGROEB;lexGroebner;LLL;1|))
           (LETT |DPoly|
                 (|DistributedMultivariatePolynomial| |lv|
                     (QREFELT $ 6)) . #4#)
           (LETT DP
                 (|DirectProduct| (LENGTH |lv|) (|NonNegativeInteger|)) . #4#)
           (LETT OV (|OrderedVariableList| |lv|) . #4#)
           (LETT |b|
                 (PROGN
                   (LETT #0# NIL . #4#)
                   (SEQ (LETT |pol| NIL . #4#) (LETT #1# |lp| . #4#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN
                                 (LETT |pol| (CAR #1#) . #4#)
                                 NIL))
                           #5=(GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL |pol|
                                      (|compiledLookupCheck| '|pToDmp|
                                       (LIST
                                        (LIST
                                         '|DistributedMultivariatePolynomial|
                                         |lv| (|devaluate| (ELT $ 6)))
                                        (LIST '|Polynomial|
                                         (|devaluate| (ELT $ 6))))
                                       PP))
                                     #0#) . #4#)))
                        (LETT #1# (CDR #1#) . #4#) #6=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #4#)
           (LETT |gb|
                 (SPADCALL |b|
                     (|compiledLookupCheck| '|groebner|
                         (LIST (LIST '|List| (|devaluate| |DPoly|))
                               (LIST '|List| (|devaluate| |DPoly|)))
                         (|GroebnerPackage| (ELT $ 6) DP OV |DPoly|))) . #4#)
           (EXIT (PROGN
                   (LETT #2# NIL . #4#)
                   (SEQ (LETT |pp| NIL . #4#) (LETT #3# |gb| . #4#)
                        G190
                        (COND
                          ((OR (ATOM #3#)
                               (PROGN (LETT |pp| (CAR #3#) . #4#) NIL))
                           #5#))
                        (SEQ (EXIT (LETT #2#
                                    (CONS
                                     (SPADCALL |pp|
                                      (|compiledLookupCheck| '|dmpToP|
                                       (LIST
                                        (LIST '|Polynomial|
                                         (|devaluate| (ELT $ 6)))
                                        (LIST
                                         '|DistributedMultivariatePolynomial|
                                         |lv| (|devaluate| (ELT $ 6))))
                                       PP))
                                     #2#) . #4#)))
                        (LETT #3# (CDR #3#) . #4#) #6# G191
                        (EXIT (NREVERSE0 #2#))))))))) 

(DEFUN |PGROEB;totalGroebner;LLL;2| (|lp| |lv| $)
  (PROG (PP |HDPoly| HDP OV #0=#:G1828 |pol| #1=#:G1829 |b| |gb|
            #2=#:G1830 |pp| #3=#:G1831)
    (RETURN
      (SEQ (LETT PP (|PolToPol| |lv| (QREFELT $ 6))
                 . #4=(|PGROEB;totalGroebner;LLL;2|))
           (LETT |HDPoly|
                 (|HomogeneousDistributedMultivariatePolynomial| |lv|
                     (QREFELT $ 6)) . #4#)
           (LETT HDP
                 (|HomogeneousDirectProduct| (LENGTH |lv|)
                     (|NonNegativeInteger|)) . #4#)
           (LETT OV (|OrderedVariableList| |lv|) . #4#)
           (LETT |b|
                 (PROGN
                   (LETT #0# NIL . #4#)
                   (SEQ (LETT |pol| NIL . #4#) (LETT #1# |lp| . #4#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN
                                 (LETT |pol| (CAR #1#) . #4#)
                                 NIL))
                           #5=(GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL |pol|
                                      (|compiledLookupCheck| '|pToHdmp|
                                       (LIST
                                        (LIST
                                         '|HomogeneousDistributedMultivariatePolynomial|
                                         |lv| (|devaluate| (ELT $ 6)))
                                        (LIST '|Polynomial|
                                         (|devaluate| (ELT $ 6))))
                                       PP))
                                     #0#) . #4#)))
                        (LETT #1# (CDR #1#) . #4#) #6=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #4#)
           (LETT |gb|
                 (SPADCALL |b|
                     (|compiledLookupCheck| '|groebner|
                         (LIST (LIST '|List| (|devaluate| |HDPoly|))
                               (LIST '|List| (|devaluate| |HDPoly|)))
                         (|GroebnerPackage| (ELT $ 6) HDP OV |HDPoly|))) . #4#)
           (EXIT (PROGN
                   (LETT #2# NIL . #4#)
                   (SEQ (LETT |pp| NIL . #4#) (LETT #3# |gb| . #4#)
                        G190
                        (COND
                          ((OR (ATOM #3#)
                               (PROGN (LETT |pp| (CAR #3#) . #4#) NIL))
                           #5#))
                        (SEQ (EXIT (LETT #2#
                                    (CONS
                                     (SPADCALL |pp|
                                      (|compiledLookupCheck| '|hdmpToP|
                                       (LIST
                                        (LIST '|Polynomial|
                                         (|devaluate| (ELT $ 6)))
                                        (LIST
                                         '|HomogeneousDistributedMultivariatePolynomial|
                                         |lv| (|devaluate| (ELT $ 6))))
                                       PP))
                                     #2#) . #4#)))
                        (LETT #3# (CDR #3#) . #4#) #6# G191
                        (EXIT (NREVERSE0 #2#))))))))) 

(DEFUN |PolyGroebner| (#0=#:G1832)
  (PROG ()
    (RETURN
      (PROG (#1=#:G1833)
        (RETURN
          (COND
            ((LETT #1#
                   (|lassocShiftWithFunction| (LIST (|devaluate| #0#))
                       (HGET |$ConstructorCache| '|PolyGroebner|)
                       '|domainEqualList|)
                   . #2=(|PolyGroebner|))
             (|CDRwithIncrement| #1#))
            ('T
             (UNWIND-PROTECT
               (PROG1 (|PolyGroebner;| #0#) (LETT #1# T . #2#))
               (COND
                 ((NOT #1#) (HREM |$ConstructorCache| '|PolyGroebner|))))))))))) 

(DEFUN |PolyGroebner;| (|#1|)
  (PROG (DV$1 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|PolyGroebner|))
        (LETT |dv$| (LIST '|PolyGroebner| DV$1) . #0#)
        (LETT $ (GETREFV 11) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|PolyGroebner| (LIST DV$1)
            (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        $)))) 

(MAKEPROP '|PolyGroebner| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|)
             (|List| (|Polynomial| 6)) (|List| (|Symbol|))
             |PGROEB;lexGroebner;LLL;1| |PGROEB;totalGroebner;LLL;2|)
          '#(|totalGroebner| 0 |lexGroebner| 6) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 10
                                '(2 0 7 7 8 10 2 0 7 7 8 9)))))
          '|lookupComplete|)) 
