diff --git a/books/bookvol10.2.pamphlet b/books/bookvol10.2.pamphlet index 35305df..5685fd5 100644 --- a/books/bookvol10.2.pamphlet +++ b/books/bookvol10.2.pamphlet @@ -853,6 +853,7 @@ digraph pic { {\bf See:}\\ \pageto{Collection}{CLAGG} \pageto{MonogenicAlgebra}{MONOGEN} +\pageto{PolynomialCategory}{POLYCAT} \pagefrom{Category}{CATEGORY} {\bf Exports:}\\ @@ -1191,6 +1192,7 @@ digraph pic { {\bf See:}\\ \pageto{Evalable}{EVALAB} +\pageto{PolynomialCategory}{POLYCAT} \pagefrom{Category}{CATEGORY} {\bf Exports:}\\ @@ -1253,6 +1255,16 @@ InnerEvalable(A:SetCategory, B:Type): Category == with "InnerEvalable(a:SetCategory,b:SetCategory)" -> "InnerEvalable(a:SetCategory,b:Type)" +"InnerEvalable(a:OrderedSet,b:Ring)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=IEVALAB"]; +"InnerEvalable(a:OrderedSet,b:Ring)" -> + "InnerEvalable(a:SetCategory,b:Type)" + +"InnerEvalable(a:OrderedSet,b:PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=IEVALAB"]; +"InnerEvalable(a:OrderedSet,b:PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" -> + "InnerEvalable(a:SetCategory,b:Type)" + "InnerEvalable(a:Ring,MultivariateTaylorSeriesCategory(a:Ring,b:OrderedSet))" [color=seagreen,href="bookvol10.2.pdf#nameddest=IEVALAB"]; "InnerEvalable(a:Ring,MultivariateTaylorSeriesCategory(a:Ring,b:OrderedSet))" @@ -1485,6 +1497,7 @@ digraph pic { \pageto{FiniteAlgebraicExtensionField}{FAXF} \pageto{FullyRetractableTo}{FRETRCT} \pageto{GradedAlgebra}{GRALG} +\pageto{PolynomialCategory}{POLYCAT} \pagefrom{Category}{CATEGORY} {\bf Exports:}\\ @@ -1545,6 +1558,10 @@ RetractableTo(S: Type): Category == with [color=seagreen,href="bookvol10.2.pdf#nameddest=RETRACT"]; "RetractableTo(SetCategory)" -> "RetractableTo(a:Type)" +"RetractableTo(OrderedSet)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=RETRACT"]; +"RetractableTo(OrderedSet)" -> "RetractableTo(a:Type)" + "RetractableTo(Symbol)" [color=seagreen,href="bookvol10.2.pdf#nameddest=RETRACT"]; "RetractableTo(Symbol)" -> "RetractableTo(a:Type)" @@ -2059,10 +2076,12 @@ digraph pic { \pagepic{ps/v102evalable.ps}{EVALAB}{1.00} {\bf See:}\\ +\pageto{PolynomialCategory}{POLYCAT} \pagefrom{InnerEvalable}{IEVALAB} {\bf Exports:}\\ -\begin{tabular}{lllll} +\begin{tabular}{l} +\cross{EVALAB}{eval} \end{tabular} These are directly exported but not implemented: @@ -2127,6 +2146,11 @@ Evalable(R:SetCategory): Category == InnerEvalable(R,R) with [color=seagreen,href="bookvol10.2.pdf#nameddest=EVALAB"]; "Evalable(ExpressionSpace)" -> "Evalable(a:SetCategory)" +"Evalable(PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet))" + [color=seagreen,href="bookvol10.2.pdf#nameddest=EVALAB"]; +"Evalable(PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet))" + -> "Evalable(a:SetCategory)" + @ <>= digraph pic { @@ -3961,6 +3985,7 @@ digraph pic { \pageto{OrderedAbelianSemiGroup}{OASGP} \pageto{OrderedFinite}{ORDFIN} \pageto{OrderedMonoid}{ORDMON} +\pageto{PolynomialCategory}{POLYCAT} \pagefrom{SetCategory}{SETCAT} {\bf Exports:}\\ @@ -4087,6 +4112,7 @@ digraph pic { \pagepic{ps/v102patternmatchable.ps}{PATMAB}{1.00} {\bf See:}\\ +\pageto{PolynomialCategory}{POLYCAT} \pagefrom{SetCategory}{SETCAT} {\bf Exports:}\\ @@ -4149,7 +4175,13 @@ PatternMatchable(S:SetCategory): Category == SetCategory with "PatternMatchable(a:SetCategory)" [color=lightblue,href="bookvol10.2.pdf#nameddest=PATMAB"]; "PatternMatchable(a:SetCategory)" -> "SetCategory()" + +"PatternMatchable(Integer)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=PATMAB"]; "PatternMatchable(Integer)" -> "PatternMatchable(a:SetCategory)" + +"PatternMatchable(Float)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=PATMAB"]; "PatternMatchable(Float)" -> "PatternMatchable(a:SetCategory)" @ @@ -17406,6 +17438,7 @@ digraph pic { {\bf See:}\\ \pageto{IntegralDomain}{INTDOM} \pageto{MonogenicAlgebra}{MONOGEN} +\pageto{PolynomialCategory}{POLYCAT} \pagefrom{BiModule}{BMODULE} \pagefrom{Ring}{RING} @@ -17432,14 +17465,13 @@ digraph pic { \cross{COMRING}{?=?} & \end{tabular} -{\bf Attributes:} +{\bf Attributes exported:} \begin{itemize} \item {\bf \cross{COMRING}{commutative("*")}} is true if it has an operation $"*": (D,D) -> D$ which is commutative. \end{itemize} - These exports come from \refto{Ring}(): \begin{verbatim} 0 : () -> % @@ -18244,6 +18276,7 @@ digraph pic { {\bf See:}\\ \pageto{DifferentialExtension}{DIFEXT} +\pageto{PolynomialCategory}{POLYCAT} \pagefrom{Ring}{RING} {\bf Exports:}\\ @@ -18278,13 +18311,13 @@ These are directly exported but not implemented: These are implemented by this category: \begin{verbatim} - differentiate : (%,List S) -> % - differentiate : (%,S,NonNegativeInteger) -> % - differentiate : (%,List S,List NonNegativeInteger) -> % D : (%,S) -> % D : (%,List S) -> % D : (%,S,NonNegativeInteger) -> % D : (%,List S,List NonNegativeInteger) -> % + differentiate : (%,List S) -> % + differentiate : (%,S,NonNegativeInteger) -> % + differentiate : (%,List S,List NonNegativeInteger) -> % \end{verbatim} These exports come from \refto{Ring}(): @@ -18657,6 +18690,7 @@ digraph pic { \pagepic{ps/v102finiteabelianmonoidring.ps}{FAMR}{0.40} {\bf See:}\\ +\pageto{PolynomialCategory}{POLYCAT} \pagefrom{AbelianMonoidRing}{AMR} \pagefrom{FullyRetractableTo}{FRETRCT} @@ -18935,6 +18969,11 @@ FiniteAbelianMonoidRing(R:Ring, E:OrderedAbelianMonoid): Category == "FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> "FullyRetractableTo(a:Ring)" +"FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoidSup)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=FAMR"]; +"FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoidSup)" -> + "FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" + @ <>= digraph pic { @@ -19007,6 +19046,7 @@ digraph pic { \pagepic{ps/v102fullylinearlyexplicitringover.ps}{FLINEXP}{1.00} {\bf See:}\\ +\pageto{PolynomialCategory}{POLYCAT} \pagefrom{LinearlyExplicitRingOver}{LINEXP} {\bf Exports:}\\ @@ -21646,6 +21686,7 @@ digraph pic { \pagepic{ps/v102gcddomain.ps}{GCDDOM}{0.65} {\bf See:}\\ +\pageto{PolynomialCategory}{POLYCAT} \pageto{PrincipalIdealDomain}{PID} \pageto{UniqueFactorizationDomain}{UFD} \pagefrom{IntegralDomain}{INTDOM} @@ -21698,23 +21739,23 @@ These are implemented by this category: These exports come from \refto{IntegralDomain}(): \begin{verbatim} - associates? : (%,%) -> Boolean - exquo : (%,%) -> Union(%,"failed") - unit? : % -> Boolean - unitCanonical : % -> % - unitNormal : % -> Record(unit: %,canonical: %,associate: %) 0 : () -> % 1 : () -> % + associates? : (%,%) -> Boolean characteristic : () -> NonNegativeInteger coerce : % -> % coerce : Integer -> % coerce : % -> OutputForm + exquo : (%,%) -> Union(%,"failed") hash : % -> SingleInteger latex : % -> String one? : % -> Boolean recip : % -> Union(%,"failed") sample : () -> % subtractIfCan : (%,%) -> Union(%,"failed") + unit? : % -> Boolean + unitCanonical : % -> % + unitNormal : % -> Record(unit: %,canonical: %,associate: %) zero? : % -> Boolean ?+? : (%,%) -> % ?=? : (%,%) -> Boolean @@ -22700,6 +22741,7 @@ digraph pic { \pagepic{ps/v102polynomialfactorizationexplicit.ps}{PFECAT}{0.75} {\bf See:}\\ +\pageto{PolynomialCategory}{POLYCAT} \pagefrom{UniqueFactorizationDomain}{UFD} {\bf Exports:}\\ @@ -23180,6 +23222,946 @@ digraph pic { } @ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{PolynomialCategory}{POLYCAT} +\pagepic{ps/v102polynomialcategory.ps}{POLYCAT}{1.00} + +{\bf See:}\\ +\pagefrom{CommutativeRing}{COMRING} +\pagefrom{ConvertibleTo}{KONVERT} +\pagefrom{Evalable}{EVALAB} +\pagefrom{FiniteAbelianMonoidRing}{FAMR} +\pagefrom{FullyLinearlyExplicitRingOver}{FLINEXP} +\pagefrom{GcdDomain}{GCDDOM} +\pagefrom{InnerEvalable}{IEVALAB} +\pagefrom{OrderedSet}{ORDSET} +\pagefrom{PartialDifferentialRing}{PDRING} +\pagefrom{PatternMatchable}{PATMAB} +\pagefrom{PolynomialFactorizationExplicit}{PFECAT} +\pagefrom{RetractableTo}{RETRACT} + +{\bf Exports:}\\ +\begin{tabular}{lll} +\cross{POLYCAT}{0} & +\cross{POLYCAT}{1} & +\cross{POLYCAT}{associates?} \\ +\cross{POLYCAT}{binomThmExpt} & +\cross{POLYCAT}{characteristic} & +\cross{POLYCAT}{charthRoot} \\ +\cross{POLYCAT}{coefficient} & +\cross{POLYCAT}{coefficients} & +\cross{POLYCAT}{coerce} \\ +\cross{POLYCAT}{conditionP} & +\cross{POLYCAT}{content} & +\cross{POLYCAT}{convert} \\ +\cross{POLYCAT}{D} & +\cross{POLYCAT}{degree} & +\cross{POLYCAT}{differentiate} \\ +\cross{POLYCAT}{discriminant} & +\cross{POLYCAT}{eval} & +\cross{POLYCAT}{exquo} \\ +\cross{POLYCAT}{factor} & +\cross{POLYCAT}{factorPolynomial} & +\cross{POLYCAT}{factorSquareFreePolynomial} \\ +\cross{POLYCAT}{gcd} & +\cross{POLYCAT}{gcdPolynomial} & +\cross{POLYCAT}{ground} \\ +\cross{POLYCAT}{ground?} & +\cross{POLYCAT}{hash} & +\cross{POLYCAT}{isExpt} \\ +\cross{POLYCAT}{isPlus} & +\cross{POLYCAT}{isTimes} & +\cross{POLYCAT}{latex} \\ +\cross{POLYCAT}{lcm} & +\cross{POLYCAT}{leadingCoefficient} & +\cross{POLYCAT}{leadingMonomial} \\ +\cross{POLYCAT}{mainVariable} & +\cross{POLYCAT}{map} & +\cross{POLYCAT}{mapExponents} \\ +\cross{POLYCAT}{max} & +\cross{POLYCAT}{min} & +\cross{POLYCAT}{minimumDegree} \\ +\cross{POLYCAT}{monicDivide} & +\cross{POLYCAT}{monomial} & +\cross{POLYCAT}{monomial?} \\ +\cross{POLYCAT}{monomials} & +\cross{POLYCAT}{multivariate} & +\cross{POLYCAT}{numberOfMonomials} \\ +\cross{POLYCAT}{one?} & +\cross{POLYCAT}{patternMatch} & +\cross{POLYCAT}{pomopo!} \\ +\cross{POLYCAT}{prime?} & +\cross{POLYCAT}{primitiveMonomials} & +\cross{POLYCAT}{primitivePart} \\ +\cross{POLYCAT}{recip} & +\cross{POLYCAT}{reducedSystem} & +\cross{POLYCAT}{reductum} \\ +\cross{POLYCAT}{resultant} & +\cross{POLYCAT}{retract} & +\cross{POLYCAT}{retractIfCan} \\ +\cross{POLYCAT}{sample} & +\cross{POLYCAT}{solveLinearPolynomialEquation} & +\cross{POLYCAT}{squareFree} \\ +\cross{POLYCAT}{squareFreePart} & +\cross{POLYCAT}{squareFreePolynomial} & +\cross{POLYCAT}{subtractIfCan} \\ +\cross{POLYCAT}{totalDegree} & +\cross{POLYCAT}{unit?} & +\cross{POLYCAT}{unitCanonical} \\ +\cross{POLYCAT}{unitNormal} & +\cross{POLYCAT}{univariate} & +\cross{POLYCAT}{variables} \\ +\cross{POLYCAT}{zero?} & +\cross{POLYCAT}{?*?} & +\cross{POLYCAT}{?**?} \\ +\cross{POLYCAT}{?+?} & +\cross{POLYCAT}{?-?} & +\cross{POLYCAT}{-?} \\ +\cross{POLYCAT}{?=?} & +\cross{POLYCAT}{?\^{}?} & +\cross{POLYCAT}{?\~{}=?} \\ +\cross{POLYCAT}{?/?} & +\cross{POLYCAT}{?$<$?} & +\cross{POLYCAT}{?$<=$?} \\ +\cross{POLYCAT}{?$>$?} & +\cross{POLYCAT}{?$>=$?} & +\end{tabular} + +{\bf Attributes exported:} +\begin{itemize} +\item if R has canonicalUnitNormal then canonicalUnitNormal where +{\bf \cross{POLYCAT}{canonicalUnitNormal}} +is true if we can choose a canonical representative for each class +of associate elements, that is {\tt associates?(a,b)} returns true +if and only if {\tt unitCanonical(a) = unitCanonical(b)}. +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + degree : (%,VarSet) -> NonNegativeInteger + degree : (%,List VarSet) -> List NonNegativeInteger + mainVariable : % -> Union(VarSet,"failed") + minimumDegree : (%,List VarSet) -> List NonNegativeInteger + minimumDegree : (%,VarSet) -> NonNegativeInteger + monomial : (%,VarSet,NonNegativeInteger) -> % + multivariate : (SparseUnivariatePolynomial %,VarSet) -> % + multivariate : (SparseUnivariatePolynomial R,VarSet) -> % + univariate : (%,VarSet) -> SparseUnivariatePolynomial % + univariate : % -> SparseUnivariatePolynomial R + variables : % -> List VarSet +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + charthRoot : % -> Union(%,"failed") + if + and(has($,CharacteristicNonZero), + has(R,PolynomialFactorizationExplicit)) + or R has CHARNZ + coefficient : (%,VarSet,NonNegativeInteger) -> % + coefficient : (%,List VarSet,List NonNegativeInteger) -> % + conditionP : Matrix % -> Union(Vector %,"failed") + if + and(has($,CharacteristicNonZero), + has(R,PolynomialFactorizationExplicit)) + content : (%,VarSet) -> % if R has GCDDOM + convert : % -> Pattern Integer + if VarSet has KONVERT PATTERN INT + and R has KONVERT PATTERN INT + convert : % -> Pattern Float + if VarSet has KONVERT PATTERN FLOAT + and R has KONVERT PATTERN FLOAT + convert : % -> InputForm + if VarSet has KONVERT INFORM + and R has KONVERT INFORM + discriminant : (%,VarSet) -> % if R has COMRING + eval : (%,List Equation %) -> % + factor : % -> Factored % if R has PFECAT + factorPolynomial : + SparseUnivariatePolynomial % -> + Factored SparseUnivariatePolynomial % + if R has PFECAT + factorSquareFreePolynomial : + SparseUnivariatePolynomial % -> + Factored SparseUnivariatePolynomial % + if R has PFECAT + gcdPolynomial : (SparseUnivariatePolynomial %, + SparseUnivariatePolynomial %) -> + SparseUnivariatePolynomial % + if R has GCDDOM + isExpt : % -> + Union(Record(var: VarSet,exponent: NonNegativeInteger),"failed") + isPlus : % -> Union(List %,"failed") + isTimes : % -> Union(List %,"failed") + monicDivide : (%,%,VarSet) -> Record(quotient: %,remainder: %) + monomial : (%,List VarSet,List NonNegativeInteger) -> % + monomials : % -> List % + patternMatch : + (%,Pattern Integer,PatternMatchResult(Integer,%)) -> + PatternMatchResult(Integer,%) + if VarSet has PATMAB INT + and R has PATMAB INT + patternMatch : + (%,Pattern Float,PatternMatchResult(Float,%)) -> + PatternMatchResult(Float,%) + if VarSet has PATMAB FLOAT + and R has PATMAB FLOAT + primitiveMonomials : % -> List % + primitivePart : % -> % if R has GCDDOM + primitivePart : (%,VarSet) -> % if R has GCDDOM + reducedSystem : Matrix % -> Matrix R + reducedSystem : (Matrix %,Vector %) -> + Record(mat: Matrix R,vec: Vector R) + resultant : (%,%,VarSet) -> % if R has COMRING + retract : % -> VarSet + retractIfCan : % -> Union(VarSet,"failed") + solveLinearPolynomialEquation : + (List SparseUnivariatePolynomial %, + SparseUnivariatePolynomial %) -> + Union(List SparseUnivariatePolynomial %,"failed") + if R has PFECAT + squareFree : % -> Factored % if R has GCDDOM + squareFreePart : % -> % if R has GCDDOM + totalDegree : % -> NonNegativeInteger + totalDegree : (%,List VarSet) -> NonNegativeInteger + ? Boolean if R has ORDSET +\end{verbatim} + +These exports come from \refto{PartialDifferentialRing}(VarSet)\\ +where VarSet:OrderedSet: +\begin{verbatim} + 0 : () -> % + 1 : () -> % + characteristic : () -> NonNegativeInteger + coerce : Integer -> % + coerce : % -> OutputForm + D : (%,List VarSet) -> % + D : (%,VarSet) -> % + D : (%,List VarSet,List NonNegativeInteger) -> % + D : (%,VarSet,NonNegativeInteger) -> % + differentiate : (%,VarSet) -> % + differentiate : (%,List VarSet,List NonNegativeInteger) -> % + differentiate : (%,VarSet,NonNegativeInteger) -> % + differentiate : (%,List VarSet) -> % + hash : % -> SingleInteger + latex : % -> String + one? : % -> Boolean + recip : % -> Union(%,"failed") + sample : () -> % + subtractIfCan : (%,%) -> Union(%,"failed") + zero? : % -> Boolean + ?+? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (%,%) -> % + ?*? : (Integer,%) -> % + ?*? : (PositiveInteger,%) -> % + ?*? : (NonNegativeInteger,%) -> % + ?-? : (%,%) -> % + -? : % -> % + ?^? : (%,PositiveInteger) -> % + ?^? : (%,NonNegativeInteger) -> % + ?**? : (%,NonNegativeInteger) -> % + ?**? : (%,PositiveInteger) -> % +\end{verbatim} + +These exports come from \refto{FiniteAbelianMonoidRing}(R,E)\\ +where R:Ring and E:OrderedAbelianMonoidSup: +\begin{verbatim} + associates? : (%,%) -> Boolean if R has INTDOM + binomThmExpt : (%,%,NonNegativeInteger) -> % + if R has COMRING + coefficient : (%,E) -> R + coefficients : % -> List R + coerce : R -> % + coerce : Fraction Integer -> % + if R has RETRACT FRAC INT + or R has ALGEBRA FRAC INT + coerce : % -> % if R has INTDOM + content : % -> R if R has GCDDOM + degree : % -> E + exquo : (%,R) -> Union(%,"failed") if R has INTDOM + exquo : (%,%) -> Union(%,"failed") if R has INTDOM + ground : % -> R + ground? : % -> Boolean + leadingCoefficient : % -> R + leadingMonomial : % -> % + map : ((R -> R),%) -> % + mapExponents : ((E -> E),%) -> % + minimumDegree : % -> E + monomial : (R,E) -> % + monomial? : % -> Boolean + numberOfMonomials : % -> NonNegativeInteger + pomopo! : (%,R,E,%) -> % + reductum : % -> % + retract : % -> Integer if R has RETRACT INT + retract : % -> Fraction Integer + if R has RETRACT FRAC INT + retractIfCan : % -> Union(Integer,"failed") + if R has RETRACT INT + retractIfCan : % -> Union(Fraction Integer,"failed") + if R has RETRACT FRAC INT + unit? : % -> Boolean if R has INTDOM + unitCanonical : % -> % if R has INTDOM + unitNormal : % -> Record(unit: %,canonical: %,associate: %) + if R has INTDOM + ?*? : (%,R) -> % + ?*? : (R,%) -> % + ?*? : (Fraction Integer,%) -> % + if R has ALGEBRA FRAC INT + ?*? : (%,Fraction Integer) -> % + if R has ALGEBRA FRAC INT + ?/? : (%,R) -> % if R has FIELD +\end{verbatim} + +These exports come from \refto{Evalable}(PolynomialCategory(...)): +\begin{verbatim} + eval : (%,Equation %) -> % + eval : (%,List %,List %) -> % + eval : (%,%,%) -> % +\end{verbatim} + +These exports come from \refto{InnerEvalable}(VarSet,R)\\ +where VarSet:OrderedSet and R:Ring +\begin{verbatim} + eval : (%,VarSet,R) -> % + eval : (%,List VarSet,List R) -> % +\end{verbatim} + +These exports come from \refto{InnerEvalable}(VarSet,R)\\ +where VarSet:OrderedSet and R:PolynomialCategory(...): +\begin{verbatim} + eval : (%,VarSet,%) -> % + eval : (%,List VarSet,List %) -> % +\end{verbatim} + +These exports come from \refto{RetractableTo}(VarSet)\\ +where VarSet:OrderedSet: +\begin{verbatim} + coerce : VarSet -> % + retract : % -> R + retractIfCan : % -> Union(R,"failed") +\end{verbatim} + +These exports come from \refto{FullyLinearlyExplicitRingOver}(R)\\ +where R:Ring: +\begin{verbatim} + reducedSystem : (Matrix %,Vector %) -> + Record(mat: Matrix Integer,vec: Vector Integer) + if R has LINEXP INT + reducedSystem : Matrix % -> Matrix Integer + if R has LINEXP INT +\end{verbatim} + +These exports come from \refto{OrderedSet}(): +\begin{verbatim} + max : (%,%) -> % if R has ORDSET + min : (%,%) -> % if R has ORDSET + ?<=? : (%,%) -> Boolean if R has ORDSET + ?>? : (%,%) -> Boolean if R has ORDSET + ?>=? : (%,%) -> Boolean if R has ORDSET +\end{verbatim} + +These exports come from \refto{GcdDomain}(): +\begin{verbatim} + gcd : (%,%) -> % if R has GCDDOM + gcd : List % -> % if R has GCDDOM + lcm : (%,%) -> % if R has GCDDOM + lcm : List % -> % if R has GCDDOM +\end{verbatim} + +These exports come from \refto{PolynomialFactorizationExplicit}(): +\begin{verbatim} + prime? : % -> Boolean if R has PFECAT + squareFreePolynomial : SparseUnivariatePolynomial % -> + Factored SparseUnivariatePolynomial % + if R has PFECAT +\end{verbatim} + +These exports come from \refto{ConvertibleTo}(InputForm): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{ConvertibleTo}(Pattern(Integer)): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{ConvertibleTo}(Pattern(Float)): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{PatternMatchable}(Pattern(Integer)): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{PatternMatchable}(Pattern(Float)): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{CommutativeRing}(): +\begin{verbatim} +\end{verbatim} + +<>= +)abbrev category POLYCAT PolynomialCategory +++ Author: +++ Date Created: +++ Date Last Updated: +++ Basic Functions: Ring, monomial, coefficient, differentiate, eval +++ Related Constructors: Polynomial, DistributedMultivariatePolynomial +++ Also See: UnivariatePolynomialCategory +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: +++ The category for general multi-variate polynomials over a ring +++ R, in variables from VarSet, with exponents from the +++ \spadtype{OrderedAbelianMonoidSup}. + +PolynomialCategory(R:Ring, E:OrderedAbelianMonoidSup, VarSet:OrderedSet): + Category == + Join(PartialDifferentialRing VarSet, FiniteAbelianMonoidRing(R, E), + Evalable %, InnerEvalable(VarSet, R), + InnerEvalable(VarSet, %), RetractableTo VarSet, + FullyLinearlyExplicitRingOver R) with + degree : (%,VarSet) -> NonNegativeInteger + ++ degree(p,v) gives the degree of polynomial p with respect + ++ to the variable v. + degree : (%,List(VarSet)) -> List(NonNegativeInteger) + ++ degree(p,lv) gives the list of degrees of polynomial p + ++ with respect to each of the variables in the list lv. + coefficient: (%,VarSet,NonNegativeInteger) -> % + ++ coefficient(p,v,n) views the polynomial p as a univariate + ++ polynomial in v and returns the coefficient of the \spad{v**n} term. + coefficient: (%,List VarSet,List NonNegativeInteger) -> % + ++ coefficient(p, lv, ln) views the polynomial p as a polynomial + ++ in the variables of lv and returns the coefficient of the term + ++ \spad{lv**ln}, i.e. \spad{prod(lv_i ** ln_i)}. + monomials: % -> List % + ++ monomials(p) returns the list of non-zero monomials of + ++ polynomial p, i.e. + ++ \spad{monomials(sum(a_(i) X^(i))) = [a_(1) X^(1),...,a_(n) X^(n)]}. + univariate : (%,VarSet) -> SparseUnivariatePolynomial(%) + ++ univariate(p,v) converts the multivariate polynomial p + ++ into a univariate polynomial in v, whose coefficients are still + ++ multivariate polynomials (in all the other variables). + univariate : % -> SparseUnivariatePolynomial(R) + ++ univariate(p) converts the multivariate polynomial p, + ++ which should actually involve only one variable, + ++ into a univariate polynomial + ++ in that variable, whose coefficients are in the ground ring. + ++ Error: if polynomial is genuinely multivariate + mainVariable : % -> Union(VarSet,"failed") + ++ mainVariable(p) returns the biggest variable which actually + ++ occurs in the polynomial p, or "failed" if no variables are + ++ present. + ++ fails precisely if polynomial satisfies ground? + minimumDegree : (%,VarSet) -> NonNegativeInteger + ++ minimumDegree(p,v) gives the minimum degree of polynomial p + ++ with respect to v, i.e. viewed a univariate polynomial in v + minimumDegree : (%,List(VarSet)) -> List(NonNegativeInteger) + ++ minimumDegree(p, lv) gives the list of minimum degrees of the + ++ polynomial p with respect to each of the variables in the list lv + monicDivide : (%,%,VarSet) -> Record(quotient:%,remainder:%) + ++ monicDivide(a,b,v) divides the polynomial a by the polynomial b, + ++ with each viewed as a univariate polynomial in v returning + ++ both the quotient and remainder. + ++ Error: if b is not monic with respect to v. + monomial : (%,VarSet,NonNegativeInteger) -> % + ++ monomial(a,x,n) creates the monomial \spad{a*x**n} where \spad{a} is + ++ a polynomial, x is a variable and n is a nonnegative integer. + monomial : (%,List VarSet,List NonNegativeInteger) -> % + ++ monomial(a,[v1..vn],[e1..en]) returns \spad{a*prod(vi**ei)}. + multivariate : (SparseUnivariatePolynomial(R),VarSet) -> % + ++ multivariate(sup,v) converts an anonymous univariable + ++ polynomial sup to a polynomial in the variable v. + multivariate : (SparseUnivariatePolynomial(%),VarSet) -> % + ++ multivariate(sup,v) converts an anonymous univariable + ++ polynomial sup to a polynomial in the variable v. + isPlus: % -> Union(List %, "failed") + ++ isPlus(p) returns \spad{[m1,...,mn]} if polynomial + ++ \spad{p = m1 + ... + mn} and + ++ \spad{n >= 2} and each mi is a nonzero monomial. + isTimes: % -> Union(List %, "failed") + ++ isTimes(p) returns \spad{[a1,...,an]} if polynomial + ++ \spad{p = a1 ... an} and \spad{n >= 2}, and, for each i, + ++ ai is either a nontrivial constant in R or else of the + ++ form \spad{x**e}, where \spad{e > 0} is an integer + ++ and x in a member of VarSet. + isExpt: % -> Union(Record(var:VarSet, exponent:NonNegativeInteger),_ + "failed") + ++ isExpt(p) returns \spad{[x, n]} if polynomial p has the + ++ form \spad{x**n} and \spad{n > 0}. + totalDegree : % -> NonNegativeInteger + ++ totalDegree(p) returns the largest sum over all monomials + ++ of all exponents of a monomial. + totalDegree : (%,List VarSet) -> NonNegativeInteger + ++ totalDegree(p, lv) returns the maximum sum (over all monomials + ++ of polynomial p) of the variables in the list lv. + variables : % -> List(VarSet) + ++ variables(p) returns the list of those variables actually + ++ appearing in the polynomial p. + primitiveMonomials: % -> List % + ++ primitiveMonomials(p) gives the list of monomials of the + ++ polynomial p with their coefficients removed. Note: + ++ \spad{primitiveMonomials(sum(a_(i) X^(i))) = [X^(1),...,X^(n)]}. + if R has OrderedSet then OrderedSet + -- OrderedRing view removed to allow EXPR to define abs + --if R has OrderedRing then OrderedRing + if (R has ConvertibleTo InputForm) and + (VarSet has ConvertibleTo InputForm) then + ConvertibleTo InputForm + if (R has ConvertibleTo Pattern Integer) and + (VarSet has ConvertibleTo Pattern Integer) then + ConvertibleTo Pattern Integer + if (R has ConvertibleTo Pattern Float) and + (VarSet has ConvertibleTo Pattern Float) then + ConvertibleTo Pattern Float + if (R has PatternMatchable Integer) and + (VarSet has PatternMatchable Integer) then + PatternMatchable Integer + if (R has PatternMatchable Float) and + (VarSet has PatternMatchable Float) then + PatternMatchable Float + if R has CommutativeRing then + resultant : (%,%,VarSet) -> % + ++ resultant(p,q,v) returns the resultant of the polynomials + ++ p and q with respect to the variable v. + discriminant : (%,VarSet) -> % + ++ discriminant(p,v) returns the disriminant of the polynomial p + ++ with respect to the variable v. + if R has GcdDomain then + GcdDomain + content: (%,VarSet) -> % + ++ content(p,v) is the gcd of the coefficients of the polynomial p + ++ when p is viewed as a univariate polynomial with respect to the + ++ variable v. + ++ Thus, for polynomial 7*x**2*y + 14*x*y**2, the gcd of the + ++ coefficients with respect to x is 7*y. + primitivePart: % -> % + ++ primitivePart(p) returns the unitCanonical associate of the + ++ polynomial p with its content divided out. + primitivePart: (%,VarSet) -> % + ++ primitivePart(p,v) returns the unitCanonical associate of the + ++ polynomial p with its content with respect to the variable v + ++ divided out. + squareFree: % -> Factored % + ++ squareFree(p) returns the square free factorization of the + ++ polynomial p. + squareFreePart: % -> % + ++ squareFreePart(p) returns product of all the irreducible factors + ++ of polynomial p each taken with multiplicity one. + + -- assertions + if R has canonicalUnitNormal then canonicalUnitNormal + ++ we can choose a unique representative for each + ++ associate class. + ++ This normalization is chosen to be normalization of + ++ leading coefficient (by default). + if R has PolynomialFactorizationExplicit then + PolynomialFactorizationExplicit + add + p:% + v:VarSet + ln:List NonNegativeInteger + lv:List VarSet + n:NonNegativeInteger + pp,qq:SparseUnivariatePolynomial % + + eval(p:%, l:List Equation %) == + empty? l => p + for e in l repeat + retractIfCan(lhs e)@Union(VarSet,"failed") case "failed" => + error "cannot find a variable to evaluate" + lvar:=[retract(lhs e)@VarSet for e in l] + eval(p, lvar,[rhs e for e in l]$List(%)) + + monomials p == +-- zero? p => empty() +-- concat(leadingMonomial p, monomials reductum p) +-- replaced by sequential version for efficiency, by WMSIT, 7/30/90 + ml:= empty$List(%) + while p ^= 0 repeat + ml:=concat(leadingMonomial p, ml) + p:= reductum p + reverse ml + + isPlus p == + empty? rest(l := monomials p) => "failed" + l + + isTimes p == + empty?(lv := variables p) or not monomial? p => "failed" + l := [monomial(1, v, degree(p, v)) for v in lv] +-- one?(r := leadingCoefficient p) => + ((r := leadingCoefficient p) = 1) => + empty? rest lv => "failed" + l + concat(r::%, l) + + isExpt p == + (u := mainVariable p) case "failed" => "failed" + p = monomial(1, u::VarSet, d := degree(p, u::VarSet)) => + [u::VarSet, d] + "failed" + + coefficient(p,v,n) == coefficient(univariate(p,v),n) + + coefficient(p,lv,ln) == + empty? lv => + empty? ln => p + error "mismatched lists in coefficient" + empty? ln => error "mismatched lists in coefficient" + coefficient(coefficient(univariate(p,first lv),first ln), + rest lv,rest ln) + + monomial(p,lv,ln) == + empty? lv => + empty? ln => p + error "mismatched lists in monomial" + empty? ln => error "mismatched lists in monomial" + monomial(monomial(p,first lv, first ln),rest lv, rest ln) + + retract(p:%):VarSet == + q := mainVariable(p)::VarSet + q::% = p => q + error "Polynomial is not a single variable" + + retractIfCan(p:%):Union(VarSet, "failed") == + ((q := mainVariable p) case VarSet) and (q::VarSet::% = p) => q + "failed" + + mkPrim(p:%):% == monomial(1,degree p) + + primitiveMonomials p == [mkPrim q for q in monomials p] + + totalDegree p == + ground? p => 0 + u := univariate(p, mainVariable(p)::VarSet) + d: NonNegativeInteger := 0 + while u ^= 0 repeat + d := max(d, degree u + totalDegree leadingCoefficient u) + u := reductum u + d + + totalDegree(p,lv) == + ground? p => 0 + u := univariate(p, v:=(mainVariable(p)::VarSet)) + d: NonNegativeInteger := 0 + w: NonNegativeInteger := 0 + if member?(v, lv) then w:=1 + while u ^= 0 repeat + d := max(d, w*(degree u) + totalDegree(leadingCoefficient u,lv)) + u := reductum u + d + + if R has CommutativeRing then + resultant(p1,p2,mvar) == + resultant(univariate(p1,mvar),univariate(p2,mvar)) + + discriminant(p,var) == + discriminant(univariate(p,var)) + + if R has IntegralDomain then + allMonoms(l:List %):List(%) == + removeDuplicates_! concat [primitiveMonomials p for p in l] + + P2R(p:%, b:List E, n:NonNegativeInteger):Vector(R) == + w := new(n, 0)$Vector(R) + for i in minIndex w .. maxIndex w for bj in b repeat + qsetelt_!(w, i, coefficient(p, bj)) + w + + eq2R(l:List %, b:List E):Matrix(R) == + matrix [[coefficient(p, bj) for p in l] for bj in b] + + reducedSystem(m:Matrix %):Matrix(R) == + l := listOfLists m + b := removeDuplicates_! + concat [allMonoms r for r in l]$List(List(%)) + d := [degree bj for bj in b] + mm := eq2R(first l, d) + l := rest l + while not empty? l repeat + mm := vertConcat(mm, eq2R(first l, d)) + l := rest l + mm + + reducedSystem(m:Matrix %, v:Vector %): + Record(mat:Matrix R, vec:Vector R) == + l := listOfLists m + r := entries v + b : List % := removeDuplicates_! concat(allMonoms r, + concat [allMonoms s for s in l]$List(List(%))) + d := [degree bj for bj in b] + n := #d + mm := eq2R(first l, d) + w := P2R(first r, d, n) + l := rest l + r := rest r + while not empty? l repeat + mm := vertConcat(mm, eq2R(first l, d)) + w := concat(w, P2R(first r, d, n)) + l := rest l + r := rest r + [mm, w] + + if R has PolynomialFactorizationExplicit then + -- we might be in trouble if its actually only + -- a univariate polynomial category - have to remember to + -- over-ride these in UnivariatePolynomialCategory + + PFBR ==>PolynomialFactorizationByRecursion(R,E,VarSet,%) + + gcdPolynomial(pp,qq) == + gcdPolynomial(pp,qq)$GeneralPolynomialGcdPackage(E,VarSet,R,%) + + solveLinearPolynomialEquation(lpp,pp) == + solveLinearPolynomialEquationByRecursion(lpp,pp)$PFBR + + factorPolynomial(pp) == + factorByRecursion(pp)$PFBR + + factorSquareFreePolynomial(pp) == + factorSquareFreeByRecursion(pp)$PFBR + + factor p == + v:Union(VarSet,"failed"):=mainVariable p + v case "failed" => + ansR:=factor leadingCoefficient p + makeFR(unit(ansR)::%, + [[w.flg,w.fctr::%,w.xpnt] for w in factorList ansR]) + up:SparseUnivariatePolynomial %:=univariate(p,v) + ansSUP:=factorByRecursion(up)$PFBR + makeFR(multivariate(unit(ansSUP),v), + [[ww.flg,multivariate(ww.fctr,v),ww.xpnt] + for ww in factorList ansSUP]) + if R has CharacteristicNonZero then + mat: Matrix % + + conditionP mat == + ll:=listOfLists transpose mat --hence each list corresponds to a + --column, i.e. to one variable + llR:List List R := [ empty() for z in first ll] + monslist:List List % := empty() + ch:=characteristic()$% + for l in ll repeat + mons:= "setUnion"/[primitiveMonomials u for u in l] + redmons:List % :=[] + for m in mons repeat + vars:=variables m + degs:=degree(m,vars) + deg1:List NonNegativeInteger + deg1:=[ ((nd:=d:Integer exquo ch:Integer) + case "failed" => return "failed" ; + nd::Integer::NonNegativeInteger) + for d in degs ] + redmons:=[monomial(1,vars,deg1),:redmons] + llR:=[[ground coefficient(u,vars,degs),:v]_ + for u in l for v in llR] + monslist:=[redmons,:monslist] + ans:=conditionP transpose matrix llR + ans case "failed" => "failed" + i:NonNegativeInteger:=0 + [ +/[m*(ans.(i:=i+1))::% for m in mons ] + for mons in monslist] + + if R has CharacteristicNonZero then + charthRootlv:(%,List VarSet,NonNegativeInteger) ->_ + Union(%,"failed") + charthRoot p == + vars:= variables p + empty? vars => + ans := charthRoot ground p + ans case "failed" => "failed" + ans::R::% + ch:=characteristic()$% + charthRootlv(p,vars,ch) + + charthRootlv(p,vars,ch) == + empty? vars => + ans := charthRoot ground p + ans case "failed" => "failed" + ans::R::% + v:=first vars + vars:=rest vars + d:=degree(p,v) + ans:% := 0 + while (d>0) repeat + (dd:=(d::Integer exquo ch::Integer)) case "failed" => + return "failed" + cp:=coefficient(p,v,d) + p:=p-monomial(cp,v,d) + ansx:=charthRootlv(cp,vars,ch) + ansx case "failed" => return "failed" + d:=degree(p,v) + ans:=ans+monomial(ansx,v,dd::Integer::NonNegativeInteger) + ansx:=charthRootlv(p,vars,ch) + ansx case "failed" => return "failed" + return ans+ansx + + monicDivide(p1,p2,mvar) == + result:=monicDivide(univariate(p1,mvar),univariate(p2,mvar)) + [multivariate(result.quotient,mvar), + multivariate(result.remainder,mvar)] + + if R has GcdDomain then + if R has EuclideanDomain and R has CharacteristicZero then + squareFree p == squareFree(p)$MultivariateSquareFree(E,VarSet,R,%) + else + squareFree p == squareFree(p)$PolynomialSquareFree(VarSet,E,R,%) + + squareFreePart p == + unit(s := squareFree p) * */[f.factor for f in factors s] + + content(p,v) == content univariate(p,v) + + primitivePart p == + zero? p => p + unitNormal((p exquo content p) ::%).canonical + + primitivePart(p,v) == + zero? p => p + unitNormal((p exquo content(p,v)) ::%).canonical + + if R has OrderedSet then + p:% < q:% == + (dp:= degree p) < (dq := degree q) => (leadingCoefficient q) > 0 + dq < dp => (leadingCoefficient p) < 0 + leadingCoefficient(p - q) < 0 + + if (R has PatternMatchable Integer) and + (VarSet has PatternMatchable Integer) then + patternMatch(p:%, pat:Pattern Integer, + l:PatternMatchResult(Integer, %)) == + patternMatch(p, pat, + l)$PatternMatchPolynomialCategory(Integer,E,VarSet,R,%) + + if (R has PatternMatchable Float) and + (VarSet has PatternMatchable Float) then + patternMatch(p:%, pat:Pattern Float, + l:PatternMatchResult(Float, %)) == + patternMatch(p, pat, + l)$PatternMatchPolynomialCategory(Float,E,VarSet,R,%) + + if (R has ConvertibleTo Pattern Integer) and + (VarSet has ConvertibleTo Pattern Integer) then + convert(x:%):Pattern(Integer) == + map(convert, convert, + x)$PolynomialCategoryLifting(E,VarSet,R,%,Pattern Integer) + + if (R has ConvertibleTo Pattern Float) and + (VarSet has ConvertibleTo Pattern Float) then + convert(x:%):Pattern(Float) == + map(convert, convert, + x)$PolynomialCategoryLifting(E, VarSet, R, %, Pattern Float) + + if (R has ConvertibleTo InputForm) and + (VarSet has ConvertibleTo InputForm) then + convert(p:%):InputForm == + map(convert, convert, + p)$PolynomialCategoryLifting(E,VarSet,R,%,InputForm) + +@ +<>= +"POLYCAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=POLYCAT"]; +"POLYCAT" -> "PDRING" +"POLYCAT" -> "FAMR" +"POLYCAT" -> "EVALAB" +"POLYCAT" -> "IEVALAB" +"POLYCAT" -> "RETRACT" +"POLYCAT" -> "FLINEXP" +"POLYCAT" -> "ORDSET" +"POLYCAT" -> "GCDDOM" +"POLYCAT" -> "PFECAT" +"POLYCAT" -> "KONVERT" +"POLYCAT" -> "PATMAB" +"POLYCAT" -> "COMRING" + +@ +<>= +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=POLYCAT"]; +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "PartialDifferentialRing(a:OrderedSet)" +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoidSup)" +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "Evalable(PolynomialCategory(...))" +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "InnerEvalable(a:OrderedSet,b:Ring)" +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "InnerEvalable(a:OrderedSet,b:PolynomialCategory(...))" +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "RetractableTo(a:OrderedSet)" +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "FullyLinearlyExplicitRingOver(a:Ring)" +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "OrderedSet()" +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "GcdDomain()" +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "PolynomialFactorizationExplicit()" +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "ConvertibleTo(InputForm)" +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "PatternMatchable(Pattern(Integer))" +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "PatternMatchable(Pattern(Float))" +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "CommutativeRing()" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=POLYCAT"]; +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "PDRING..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "FAMR..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "EVALAB..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "IEVALAB..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "RETRACT..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "FLINEXP..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "ORDSET..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "GCDDOM..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "PFECAT..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "KONVERT..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "PATMAB..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "COMRING..." + +"PDRING..." [color=lightblue]; +"FAMR..." [color=lightblue]; +"EVALAB..." [color=lightblue]; +"IEVALAB..." [color=lightblue]; +"RETRACT..." [color=lightblue]; +"FLINEXP..." [color=lightblue]; +"ORDSET..." [color=lightblue]; +"GCDDOM..." [color=lightblue]; +"PFECAT..." [color=lightblue]; +"KONVERT..." [color=lightblue]; +"PATMAB..." [color=lightblue]; +"COMRING..." [color=lightblue]; + +} + +@ \chapter{Category Layer 17} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{FieldOfPrimeCharacteristic}{FPC} @@ -31124,6 +32106,1668 @@ Note that this code is not included in the generated catdef.spad file. 1 6 0 0 18 1 0 16 0 17 1 0 8 0 10 1 0 8 0 11 1 0 0 0 19)))))) (QUOTE |lookupComplete|))) @ +\section{POLYCAT.lsp BOOTSTRAP} +{\bf POLYCAT} depends on itself. We need to break this cycle to build +the algebra. So we keep a cached copy of the translated {\bf POLYCAT} +category which we can write into the {\bf MID} directory. We compile +the lisp code and copy the {\bf POLYCAT.o} file to the {\bf OUT} directory. +This is eventually forcibly replaced by a recompiled version. + +Note that this code is not included in the generated catdef.spad file. + +<>= + +(/VERSIONCHECK 2) + +(SETQ |PolynomialCategory;CAT| (QUOTE NIL)) + +(SETQ |PolynomialCategory;AL| (QUOTE NIL)) + +(DEFUN |PolynomialCategory| (&REST #0=#:G1430 &AUX #1=#:G1428) + (DSETQ #1# #0#) + (LET (#2=#:G1429) + (COND + ((SETQ #2# (|assoc| (|devaluateList| #1#) |PolynomialCategory;AL|)) + (CDR #2#)) + (T + (SETQ |PolynomialCategory;AL| + (|cons5| + (CONS (|devaluateList| #1#) + (SETQ #2# (APPLY (FUNCTION |PolynomialCategory;|) #1#))) + |PolynomialCategory;AL|)) + #2#)))) + +(DEFUN |PolynomialCategory;| (|t#1| |t#2| |t#3|) + (PROG (#0=#:G1427) + (RETURN + (PROG1 + (LETT #0# + (|sublisV| + (PAIR (QUOTE (|t#1| |t#2| |t#3|)) (LIST (|devaluate| |t#1|) (|devaluate| |t#2|) (|devaluate| |t#3|))) + (COND + (|PolynomialCategory;CAT|) + ((QUOTE T) + (LETT |PolynomialCategory;CAT| + (|Join| + (|PartialDifferentialRing| (QUOTE |t#3|)) + (|FiniteAbelianMonoidRing| (QUOTE |t#1|) (QUOTE |t#2|)) + (|Evalable| (QUOTE $)) + (|InnerEvalable| (QUOTE |t#3|) (QUOTE |t#1|)) + (|InnerEvalable| (QUOTE |t#3|) (QUOTE $)) + (|RetractableTo| (QUOTE |t#3|)) + (|FullyLinearlyExplicitRingOver| (QUOTE |t#1|)) + (|mkCategory| (QUOTE |domain|) + (QUOTE + (((|degree| ((|NonNegativeInteger|) $ |t#3|)) T) + ((|degree| ((|List| (|NonNegativeInteger|)) $ (|List| |t#3|))) T) + ((|coefficient| ($ $ |t#3| (|NonNegativeInteger|))) T) + ((|coefficient| ($ $ (|List| |t#3|) + (|List| (|NonNegativeInteger|)))) T) + ((|monomials| ((|List| $) $)) T) + ((|univariate| ((|SparseUnivariatePolynomial| $) $ |t#3|)) T) + ((|univariate| ((|SparseUnivariatePolynomial| |t#1|) $)) T) + ((|mainVariable| ((|Union| |t#3| "failed") $)) T) + ((|minimumDegree| ((|NonNegativeInteger|) $ |t#3|)) T) + ((|minimumDegree| ((|List| (|NonNegativeInteger|)) $ + (|List| |t#3|))) T) + ((|monicDivide| + ((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $ |t#3|)) + T) + ((|monomial| ($ $ |t#3| (|NonNegativeInteger|))) T) + ((|monomial| ($ $ (|List| |t#3|) (|List| (|NonNegativeInteger|)))) + T) + ((|multivariate| ($ (|SparseUnivariatePolynomial| |t#1|) |t#3|)) + T) + ((|multivariate| ($ (|SparseUnivariatePolynomial| $) |t#3|)) T) + ((|isPlus| ((|Union| (|List| $) "failed") $)) T) + ((|isTimes| ((|Union| (|List| $) "failed") $)) T) + ((|isExpt| + ((|Union| + (|Record| (|:| |var| |t#3|) + (|:| |exponent| (|NonNegativeInteger|))) + "failed") $)) + T) + ((|totalDegree| ((|NonNegativeInteger|) $)) T) + ((|totalDegree| ((|NonNegativeInteger|) $ (|List| |t#3|))) T) + ((|variables| ((|List| |t#3|) $)) T) + ((|primitiveMonomials| ((|List| $) $)) T) + ((|resultant| ($ $ $ |t#3|)) (|has| |t#1| (|CommutativeRing|))) + ((|discriminant| ($ $ |t#3|)) (|has| |t#1| (|CommutativeRing|))) + ((|content| ($ $ |t#3|)) (|has| |t#1| (|GcdDomain|))) + ((|primitivePart| ($ $)) (|has| |t#1| (|GcdDomain|))) + ((|primitivePart| ($ $ |t#3|)) (|has| |t#1| (|GcdDomain|))) + ((|squareFree| ((|Factored| $) $)) (|has| |t#1| (|GcdDomain|))) + ((|squareFreePart| ($ $)) (|has| |t#1| (|GcdDomain|))))) + (QUOTE + (((|OrderedSet|) (|has| |t#1| (|OrderedSet|))) + ((|ConvertibleTo| (|InputForm|)) + (AND (|has| |t#3| (|ConvertibleTo| (|InputForm|))) + (|has| |t#1| (|ConvertibleTo| (|InputForm|))))) + ((|ConvertibleTo| (|Pattern| (|Integer|))) + (AND (|has| |t#3| (|ConvertibleTo| (|Pattern| (|Integer|)))) + (|has| |t#1| (|ConvertibleTo| (|Pattern| (|Integer|)))))) + ((|ConvertibleTo| (|Pattern| (|Float|))) + (AND (|has| |t#3| (|ConvertibleTo| (|Pattern| (|Float|)))) + (|has| |t#1| (|ConvertibleTo| (|Pattern| (|Float|)))))) + ((|PatternMatchable| (|Integer|)) + (AND + (|has| |t#3| (|PatternMatchable| (|Integer|))) + (|has| |t#1| (|PatternMatchable| (|Integer|))))) + ((|PatternMatchable| (|Float|)) + (AND + (|has| |t#3| (|PatternMatchable| (|Float|))) + (|has| |t#1| (|PatternMatchable| (|Float|))))) + ((|GcdDomain|) (|has| |t#1| (|GcdDomain|))) + (|canonicalUnitNormal| + (|has| |t#1| (ATTRIBUTE |canonicalUnitNormal|))) + ((|PolynomialFactorizationExplicit|) + (|has| |t#1| (|PolynomialFactorizationExplicit|))))) + (QUOTE + ((|Factored| $) + (|List| $) + (|List| |t#3|) + (|NonNegativeInteger|) + (|SparseUnivariatePolynomial| $) + (|SparseUnivariatePolynomial| |t#1|) + (|List| (|NonNegativeInteger|)))) + NIL)) + . #1=(|PolynomialCategory|))))) + . #1#) + (SETELT #0# 0 + (LIST (QUOTE |PolynomialCategory|) + (|devaluate| |t#1|) (|devaluate| |t#2|) (|devaluate| |t#3|))))))) + +@ +\section{POLYCAT-.lsp BOOTSTRAP} +{\bf POLYCAT-} depends on {\bf POLYCAT}. We need to break this cycle to build +the algebra. So we keep a cached copy of the translated {\bf POLYCAT-} +category which we can write into the {\bf MID} directory. We compile +the lisp code and copy the {\bf POLYCAT-.o} file to the {\bf OUT} directory. +This is eventually forcibly replaced by a recompiled version. + +Note that this code is not included in the generated catdef.spad file. + +<>= + +(|/VERSIONCHECK| 2) + + +(/VERSIONCHECK 2) + +(DEFUN |POLYCAT-;eval;SLS;1| (|p| |l| $) + (PROG (#0=#:G1444 #1=#:G1438 #2=#:G1445 #3=#:G1446 |lvar| #4=#:G1447 + |e| #5=#:G1448) + (RETURN + (SEQ + (COND + ((NULL |l|) |p|) + ((QUOTE T) + (SEQ + (SEQ + (EXIT + (SEQ + (LETT |e| NIL |POLYCAT-;eval;SLS;1|) + (LETT #0# |l| |POLYCAT-;eval;SLS;1|) + G190 + (COND + ((OR (ATOM #0#) + (PROGN (LETT |e| (CAR #0#) |POLYCAT-;eval;SLS;1|) NIL)) + (GO G191))) + (SEQ + (EXIT + (COND + ((QEQCAR + (SPADCALL (SPADCALL |e| (QREFELT $ 11)) (QREFELT $ 13)) 1) + (PROGN + (LETT #1# + (|error| "cannot find a variable to evaluate") + |POLYCAT-;eval;SLS;1|) + (GO #1#)))))) + (LETT #0# (CDR #0#) |POLYCAT-;eval;SLS;1|) + (GO G190) + G191 + (EXIT NIL))) + #1# (EXIT #1#)) + (LETT |lvar| + (PROGN + (LETT #2# NIL |POLYCAT-;eval;SLS;1|) + (SEQ + (LETT |e| NIL |POLYCAT-;eval;SLS;1|) + (LETT #3# |l| |POLYCAT-;eval;SLS;1|) + G190 + (COND + ((OR (ATOM #3#) + (PROGN (LETT |e| (CAR #3#) |POLYCAT-;eval;SLS;1|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #2# + (CONS (SPADCALL (SPADCALL |e| (QREFELT $ 11)) (QREFELT $ 14)) + #2#) + |POLYCAT-;eval;SLS;1|))) + (LETT #3# (CDR #3#) |POLYCAT-;eval;SLS;1|) + (GO G190) + G191 + (EXIT (NREVERSE0 #2#)))) + |POLYCAT-;eval;SLS;1|) + (EXIT + (SPADCALL |p| |lvar| + (PROGN + (LETT #4# NIL |POLYCAT-;eval;SLS;1|) + (SEQ + (LETT |e| NIL |POLYCAT-;eval;SLS;1|) + (LETT #5# |l| |POLYCAT-;eval;SLS;1|) + G190 + (COND + ((OR (ATOM #5#) + (PROGN (LETT |e| (CAR #5#) |POLYCAT-;eval;SLS;1|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #4# (CONS (SPADCALL |e| (QREFELT $ 15)) #4#) + |POLYCAT-;eval;SLS;1|))) + (LETT #5# (CDR #5#) |POLYCAT-;eval;SLS;1|) + (GO G190) + G191 + (EXIT (NREVERSE0 #4#)))) + (QREFELT $ 18)))))))))) + +(DEFUN |POLYCAT-;monomials;SL;2| (|p| $) + (PROG (|ml|) + (RETURN + (SEQ + (LETT |ml| NIL |POLYCAT-;monomials;SL;2|) + (SEQ G190 + (COND + ((NULL + (COND + ((SPADCALL |p| (|spadConstant| $ 21) (QREFELT $ 24)) (QUOTE NIL)) + ((QUOTE T) (QUOTE T)))) + (GO G191))) + (SEQ + (LETT |ml| + (CONS (SPADCALL |p| (QREFELT $ 25)) |ml|) + |POLYCAT-;monomials;SL;2|) + (EXIT + (LETT |p| (SPADCALL |p| (QREFELT $ 26)) |POLYCAT-;monomials;SL;2|))) + NIL + (GO G190) + G191 + (EXIT NIL)) + (EXIT (REVERSE |ml|)))))) + +(DEFUN |POLYCAT-;isPlus;SU;3| (|p| $) + (PROG (|l|) + (RETURN + (COND + ((NULL + (CDR (LETT |l| (SPADCALL |p| (QREFELT $ 28)) |POLYCAT-;isPlus;SU;3|))) + (CONS 1 "failed")) + ((QUOTE T) (CONS 0 |l|)))))) + +(DEFUN |POLYCAT-;isTimes;SU;4| (|p| $) + (PROG (|lv| #0=#:G1470 |v| #1=#:G1471 |l| |r|) + (RETURN + (SEQ + (COND + ((OR (NULL + (LETT |lv| (SPADCALL |p| (QREFELT $ 31)) |POLYCAT-;isTimes;SU;4|)) + (NULL (SPADCALL |p| (QREFELT $ 32)))) + (CONS 1 "failed")) + ((QUOTE T) + (SEQ + (LETT |l| + (PROGN + (LETT #0# NIL |POLYCAT-;isTimes;SU;4|) + (SEQ + (LETT |v| NIL |POLYCAT-;isTimes;SU;4|) + (LETT #1# |lv| |POLYCAT-;isTimes;SU;4|) + G190 + (COND + ((OR (ATOM #1#) + (PROGN (LETT |v| (CAR #1#) |POLYCAT-;isTimes;SU;4|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #0# + (CONS + (SPADCALL (|spadConstant| $ 33) |v| + (SPADCALL |p| |v| (QREFELT $ 36)) (QREFELT $ 37)) + #0#) + |POLYCAT-;isTimes;SU;4|))) + (LETT #1# (CDR #1#) |POLYCAT-;isTimes;SU;4|) + (GO G190) + G191 + (EXIT (NREVERSE0 #0#)))) + |POLYCAT-;isTimes;SU;4|) + (LETT |r| (SPADCALL |p| (QREFELT $ 38)) |POLYCAT-;isTimes;SU;4|) + (EXIT + (COND + ((SPADCALL |r| (|spadConstant| $ 34) (QREFELT $ 39)) + (COND + ((NULL (CDR |lv|)) (CONS 1 "failed")) + ((QUOTE T) (CONS 0 |l|)))) + ((QUOTE T) + (CONS 0 (CONS (SPADCALL |r| (QREFELT $ 40)) |l|)))))))))))) + +(DEFUN |POLYCAT-;isExpt;SU;5| (|p| $) + (PROG (|u| |d|) + (RETURN + (SEQ + (LETT |u| (SPADCALL |p| (QREFELT $ 42)) |POLYCAT-;isExpt;SU;5|) + (EXIT + (COND + ((OR (QEQCAR |u| 1) + (NULL + (SPADCALL |p| + (SPADCALL (|spadConstant| $ 33) + (QCDR |u|) + (LETT |d| (SPADCALL |p| (QCDR |u|) (QREFELT $ 36)) + |POLYCAT-;isExpt;SU;5|) + (QREFELT $ 37)) + (QREFELT $ 24)))) + (CONS 1 "failed")) + ((QUOTE T) (CONS 0 (CONS (QCDR |u|) |d|))))))))) + +(DEFUN |POLYCAT-;coefficient;SVarSetNniS;6| (|p| |v| |n| $) + (SPADCALL (SPADCALL |p| |v| (QREFELT $ 47)) |n| (QREFELT $ 49))) + +(DEFUN |POLYCAT-;coefficient;SLLS;7| (|p| |lv| |ln| $) + (COND + ((NULL |lv|) + (COND + ((NULL |ln|) |p|) + ((QUOTE T) (|error| "mismatched lists in coefficient")))) + ((NULL |ln|) (|error| "mismatched lists in coefficient")) + ((QUOTE T) + (SPADCALL + (SPADCALL + (SPADCALL |p| (|SPADfirst| |lv|) (QREFELT $ 47)) + (|SPADfirst| |ln|) + (QREFELT $ 49)) + (CDR |lv|) + (CDR |ln|) + (QREFELT $ 52))))) + +(DEFUN |POLYCAT-;monomial;SLLS;8| (|p| |lv| |ln| $) + (COND + ((NULL |lv|) + (COND + ((NULL |ln|) |p|) + ((QUOTE T) (|error| "mismatched lists in monomial")))) + ((NULL |ln|) (|error| "mismatched lists in monomial")) + ((QUOTE T) + (SPADCALL + (SPADCALL |p| (|SPADfirst| |lv|) (|SPADfirst| |ln|) (QREFELT $ 37)) + (CDR |lv|) + (CDR |ln|) + (QREFELT $ 54))))) + +(DEFUN |POLYCAT-;retract;SVarSet;9| (|p| $) + (PROG (#0=#:G1496 |q|) + (RETURN + (SEQ + (LETT |q| + (PROG2 + (LETT #0# (SPADCALL |p| (QREFELT $ 42)) |POLYCAT-;retract;SVarSet;9|) + (QCDR #0#) + (|check-union| (QEQCAR #0# 0) (QREFELT $ 9) #0#)) + |POLYCAT-;retract;SVarSet;9|) + (EXIT + (COND + ((SPADCALL (SPADCALL |q| (QREFELT $ 56)) |p| (QREFELT $ 24)) |q|) + ((QUOTE T) (|error| "Polynomial is not a single variable")))))))) + +(DEFUN |POLYCAT-;retractIfCan;SU;10| (|p| $) + (PROG (|q| #0=#:G1504) + (RETURN + (SEQ + (EXIT + (SEQ + (SEQ + (LETT |q| (SPADCALL |p| (QREFELT $ 42)) |POLYCAT-;retractIfCan;SU;10|) + (EXIT + (COND + ((QEQCAR |q| 0) + (COND + ((SPADCALL (SPADCALL (QCDR |q|) (QREFELT $ 56)) |p| (QREFELT $ 24)) + (PROGN + (LETT #0# |q| |POLYCAT-;retractIfCan;SU;10|) + (GO #0#)))))))) + (EXIT (CONS 1 "failed")))) + #0# + (EXIT #0#))))) + +(DEFUN |POLYCAT-;mkPrim| (|p| $) + (SPADCALL + (|spadConstant| $ 34) + (SPADCALL |p| (QREFELT $ 59)) + (QREFELT $ 60))) + +(DEFUN |POLYCAT-;primitiveMonomials;SL;12| (|p| $) + (PROG (#0=#:G1509 |q| #1=#:G1510) + (RETURN + (SEQ + (PROGN + (LETT #0# NIL |POLYCAT-;primitiveMonomials;SL;12|) + (SEQ + (LETT |q| NIL |POLYCAT-;primitiveMonomials;SL;12|) + (LETT #1# (SPADCALL |p| (QREFELT $ 28)) |POLYCAT-;primitiveMonomials;SL;12|) + G190 + (COND + ((OR (ATOM #1#) + (PROGN + (LETT |q| (CAR #1#) |POLYCAT-;primitiveMonomials;SL;12|) + NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #0# (CONS (|POLYCAT-;mkPrim| |q| $) #0#) + |POLYCAT-;primitiveMonomials;SL;12|))) + (LETT #1# (CDR #1#) |POLYCAT-;primitiveMonomials;SL;12|) + (GO G190) + G191 + (EXIT (NREVERSE0 #0#)))))))) + +(DEFUN |POLYCAT-;totalDegree;SNni;13| (|p| $) + (PROG (#0=#:G1512 |d| |u|) + (RETURN + (SEQ + (COND + ((SPADCALL |p| (QREFELT $ 62)) 0) + ((QUOTE T) + (SEQ + (LETT |u| + (SPADCALL |p| + (PROG2 + (LETT #0# + (SPADCALL |p| (QREFELT $ 42)) + |POLYCAT-;totalDegree;SNni;13|) + (QCDR #0#) + (|check-union| (QEQCAR #0# 0) (QREFELT $ 9) #0#)) + (QREFELT $ 47)) + |POLYCAT-;totalDegree;SNni;13|) + (LETT |d| 0 |POLYCAT-;totalDegree;SNni;13|) + (SEQ G190 + (COND + ((NULL + (COND + ((SPADCALL |u| (|spadConstant| $ 63) (QREFELT $ 64)) (QUOTE NIL)) + ((QUOTE T) (QUOTE T)))) (GO G191))) + (SEQ + (LETT |d| + (MAX |d| + (+ + (SPADCALL |u| (QREFELT $ 65)) + (SPADCALL (SPADCALL |u| (QREFELT $ 66)) (QREFELT $ 67)))) + |POLYCAT-;totalDegree;SNni;13|) + (EXIT + (LETT |u| + (SPADCALL |u| (QREFELT $ 68)) |POLYCAT-;totalDegree;SNni;13|))) + NIL + (GO G190) + G191 + (EXIT NIL)) + (EXIT |d|)))))))) + +(DEFUN |POLYCAT-;totalDegree;SLNni;14| (|p| |lv| $) + (PROG (#0=#:G1520 |v| |w| |d| |u|) + (RETURN + (SEQ + (COND + ((SPADCALL |p| (QREFELT $ 62)) 0) + ((QUOTE T) + (SEQ + (LETT |u| + (SPADCALL |p| + (LETT |v| + (PROG2 + (LETT #0# + (SPADCALL |p| (QREFELT $ 42)) + |POLYCAT-;totalDegree;SLNni;14|) + (QCDR #0#) + (|check-union| (QEQCAR #0# 0) (QREFELT $ 9) #0#)) + |POLYCAT-;totalDegree;SLNni;14|) + (QREFELT $ 47)) + |POLYCAT-;totalDegree;SLNni;14|) + (LETT |d| 0 |POLYCAT-;totalDegree;SLNni;14|) + (LETT |w| 0 |POLYCAT-;totalDegree;SLNni;14|) + (COND + ((SPADCALL |v| |lv| (QREFELT $ 70)) + (LETT |w| 1 |POLYCAT-;totalDegree;SLNni;14|))) + (SEQ G190 + (COND + ((NULL + (COND + ((SPADCALL |u| (|spadConstant| $ 63) (QREFELT $ 64)) (QUOTE NIL)) + ((QUOTE T) (QUOTE T)))) (GO G191))) + (SEQ + (LETT |d| + (MAX |d| + (+ + (* |w| (SPADCALL |u| (QREFELT $ 65))) + (SPADCALL (SPADCALL |u| (QREFELT $ 66)) |lv| (QREFELT $ 71)))) + |POLYCAT-;totalDegree;SLNni;14|) + (EXIT + (LETT |u| + (SPADCALL |u| (QREFELT $ 68)) + |POLYCAT-;totalDegree;SLNni;14|))) + NIL + (GO G190) + G191 + (EXIT NIL)) + (EXIT |d|)))))))) + +(DEFUN |POLYCAT-;resultant;2SVarSetS;15| (|p1| |p2| |mvar| $) + (SPADCALL + (SPADCALL |p1| |mvar| (QREFELT $ 47)) + (SPADCALL |p2| |mvar| (QREFELT $ 47)) + (QREFELT $ 73))) + +(DEFUN |POLYCAT-;discriminant;SVarSetS;16| (|p| |var| $) + (SPADCALL (SPADCALL |p| |var| (QREFELT $ 47)) (QREFELT $ 75))) + +(DEFUN |POLYCAT-;allMonoms| (|l| $) + (PROG (#0=#:G1532 |p| #1=#:G1533) + (RETURN + (SEQ + (SPADCALL + (SPADCALL + (PROGN + (LETT #0# NIL |POLYCAT-;allMonoms|) + (SEQ + (LETT |p| NIL |POLYCAT-;allMonoms|) + (LETT #1# |l| |POLYCAT-;allMonoms|) + G190 + (COND + ((OR (ATOM #1#) (PROGN (LETT |p| (CAR #1#) |POLYCAT-;allMonoms|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #0# + (CONS (SPADCALL |p| (QREFELT $ 77)) #0#) + |POLYCAT-;allMonoms|))) + (LETT #1# (CDR #1#) |POLYCAT-;allMonoms|) + (GO G190) + G191 + (EXIT (NREVERSE0 #0#)))) + (QREFELT $ 79)) + (QREFELT $ 80)))))) + +(DEFUN |POLYCAT-;P2R| (|p| |b| |n| $) + (PROG (|w| |bj| #0=#:G1538 |i| #1=#:G1537) + (RETURN + (SEQ + (LETT |w| + (SPADCALL |n| (|spadConstant| $ 22) (QREFELT $ 82)) + |POLYCAT-;P2R|) + (SEQ + (LETT |bj| NIL |POLYCAT-;P2R|) + (LETT #0# |b| |POLYCAT-;P2R|) + (LETT |i| (SPADCALL |w| (QREFELT $ 84)) |POLYCAT-;P2R|) + (LETT #1# (QVSIZE |w|) |POLYCAT-;P2R|) + G190 + (COND + ((OR (> |i| #1#) + (ATOM #0#) + (PROGN (LETT |bj| (CAR #0#) |POLYCAT-;P2R|) NIL)) + (GO G191))) + (SEQ + (EXIT + (SPADCALL |w| |i| (SPADCALL |p| |bj| (QREFELT $ 85)) (QREFELT $ 86)))) + (LETT |i| + (PROG1 (+ |i| 1) (LETT #0# (CDR #0#) |POLYCAT-;P2R|)) |POLYCAT-;P2R|) + (GO G190) + G191 + (EXIT NIL)) + (EXIT |w|))))) + +(DEFUN |POLYCAT-;eq2R| (|l| |b| $) + (PROG (#0=#:G1542 |bj| #1=#:G1543 #2=#:G1544 |p| #3=#:G1545) + (RETURN + (SEQ + (SPADCALL + (PROGN + (LETT #0# NIL |POLYCAT-;eq2R|) + (SEQ + (LETT |bj| NIL |POLYCAT-;eq2R|) + (LETT #1# |b| |POLYCAT-;eq2R|) + G190 + (COND + ((OR (ATOM #1#) + (PROGN (LETT |bj| (CAR #1#) |POLYCAT-;eq2R|) NIL)) (GO G191))) + (SEQ + (EXIT + (LETT #0# + (CONS + (PROGN + (LETT #2# NIL |POLYCAT-;eq2R|) + (SEQ + (LETT |p| NIL |POLYCAT-;eq2R|) + (LETT #3# |l| |POLYCAT-;eq2R|) + G190 + (COND + ((OR (ATOM #3#) (PROGN (LETT |p| (CAR #3#) |POLYCAT-;eq2R|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #2# + (CONS (SPADCALL |p| |bj| (QREFELT $ 85)) #2#) + |POLYCAT-;eq2R|))) + (LETT #3# (CDR #3#) |POLYCAT-;eq2R|) + (GO G190) + G191 + (EXIT (NREVERSE0 #2#)))) + #0#) + |POLYCAT-;eq2R|))) + (LETT #1# (CDR #1#) |POLYCAT-;eq2R|) + (GO G190) + G191 + (EXIT (NREVERSE0 #0#)))) + (QREFELT $ 89)))))) + +(DEFUN |POLYCAT-;reducedSystem;MM;20| (|m| $) + (PROG (#0=#:G1555 |r| #1=#:G1556 |b| #2=#:G1557 |bj| #3=#:G1558 |d| |mm| |l|) + (RETURN + (SEQ + (LETT |l| (SPADCALL |m| (QREFELT $ 92)) |POLYCAT-;reducedSystem;MM;20|) + (LETT |b| + (SPADCALL + (SPADCALL + (PROGN + (LETT #0# NIL |POLYCAT-;reducedSystem;MM;20|) + (SEQ + (LETT |r| NIL |POLYCAT-;reducedSystem;MM;20|) + (LETT #1# |l| |POLYCAT-;reducedSystem;MM;20|) + G190 + (COND + ((OR (ATOM #1#) + (PROGN (LETT |r| (CAR #1#) |POLYCAT-;reducedSystem;MM;20|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #0# + (CONS (|POLYCAT-;allMonoms| |r| $) #0#) + |POLYCAT-;reducedSystem;MM;20|))) + (LETT #1# (CDR #1#) |POLYCAT-;reducedSystem;MM;20|) + (GO G190) + G191 + (EXIT (NREVERSE0 #0#)))) + (QREFELT $ 79)) + (QREFELT $ 80)) + |POLYCAT-;reducedSystem;MM;20|) + (LETT |d| + (PROGN + (LETT #2# NIL |POLYCAT-;reducedSystem;MM;20|) + (SEQ + (LETT |bj| NIL |POLYCAT-;reducedSystem;MM;20|) + (LETT #3# |b| |POLYCAT-;reducedSystem;MM;20|) + G190 + (COND + ((OR (ATOM #3#) + (PROGN (LETT |bj| (CAR #3#) |POLYCAT-;reducedSystem;MM;20|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #2# + (CONS (SPADCALL |bj| (QREFELT $ 59)) #2#) + |POLYCAT-;reducedSystem;MM;20|))) + (LETT #3# (CDR #3#) |POLYCAT-;reducedSystem;MM;20|) + (GO G190) + G191 + (EXIT (NREVERSE0 #2#)))) + |POLYCAT-;reducedSystem;MM;20|) + (LETT |mm| + (|POLYCAT-;eq2R| (|SPADfirst| |l|) |d| $) |POLYCAT-;reducedSystem;MM;20|) + (LETT |l| (CDR |l|) |POLYCAT-;reducedSystem;MM;20|) + (SEQ G190 + (COND + ((NULL (COND ((NULL |l|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) + (SEQ + (LETT |mm| + (SPADCALL |mm| (|POLYCAT-;eq2R| (|SPADfirst| |l|) |d| $) (QREFELT $ 93)) + |POLYCAT-;reducedSystem;MM;20|) + (EXIT (LETT |l| (CDR |l|) |POLYCAT-;reducedSystem;MM;20|))) + NIL + (GO G190) + G191 + (EXIT NIL)) + (EXIT |mm|))))) + +(DEFUN |POLYCAT-;reducedSystem;MVR;21| (|m| |v| $) + (PROG (#0=#:G1570 |s| #1=#:G1571 |b| #2=#:G1572 |bj| #3=#:G1573 |d| |n| + |mm| |w| |l| |r|) + (RETURN + (SEQ + (LETT |l| (SPADCALL |m| (QREFELT $ 92)) |POLYCAT-;reducedSystem;MVR;21|) + (LETT |r| (SPADCALL |v| (QREFELT $ 97)) |POLYCAT-;reducedSystem;MVR;21|) + (LETT |b| + (SPADCALL + (SPADCALL + (|POLYCAT-;allMonoms| |r| $) + (SPADCALL + (PROGN + (LETT #0# NIL |POLYCAT-;reducedSystem;MVR;21|) + (SEQ + (LETT |s| NIL |POLYCAT-;reducedSystem;MVR;21|) + (LETT #1# |l| |POLYCAT-;reducedSystem;MVR;21|) + G190 + (COND + ((OR (ATOM #1#) + (PROGN + (LETT |s| (CAR #1#) |POLYCAT-;reducedSystem;MVR;21|) + NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #0# + (CONS (|POLYCAT-;allMonoms| |s| $) #0#) + |POLYCAT-;reducedSystem;MVR;21|))) + (LETT #1# (CDR #1#) |POLYCAT-;reducedSystem;MVR;21|) + (GO G190) + G191 + (EXIT (NREVERSE0 #0#)))) + (QREFELT $ 79)) + (QREFELT $ 98)) + (QREFELT $ 80)) + |POLYCAT-;reducedSystem;MVR;21|) + (LETT |d| + (PROGN + (LETT #2# NIL |POLYCAT-;reducedSystem;MVR;21|) + (SEQ + (LETT |bj| NIL |POLYCAT-;reducedSystem;MVR;21|) + (LETT #3# |b| |POLYCAT-;reducedSystem;MVR;21|) + G190 + (COND + ((OR (ATOM #3#) + (PROGN (LETT |bj| (CAR #3#) |POLYCAT-;reducedSystem;MVR;21|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #2# + (CONS (SPADCALL |bj| (QREFELT $ 59)) #2#) + |POLYCAT-;reducedSystem;MVR;21|))) + (LETT #3# (CDR #3#) |POLYCAT-;reducedSystem;MVR;21|) + (GO G190) + G191 + (EXIT (NREVERSE0 #2#)))) + |POLYCAT-;reducedSystem;MVR;21|) + (LETT |n| (LENGTH |d|) |POLYCAT-;reducedSystem;MVR;21|) + (LETT |mm| + (|POLYCAT-;eq2R| (|SPADfirst| |l|) |d| $) + |POLYCAT-;reducedSystem;MVR;21|) + (LETT |w| + (|POLYCAT-;P2R| (|SPADfirst| |r|) |d| |n| $) + |POLYCAT-;reducedSystem;MVR;21|) + (LETT |l| (CDR |l|) |POLYCAT-;reducedSystem;MVR;21|) + (LETT |r| (CDR |r|) |POLYCAT-;reducedSystem;MVR;21|) + (SEQ G190 + (COND + ((NULL (COND ((NULL |l|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) + (GO G191))) + (SEQ + (LETT |mm| + (SPADCALL |mm| (|POLYCAT-;eq2R| (|SPADfirst| |l|) |d| $) (QREFELT $ 93)) + |POLYCAT-;reducedSystem;MVR;21|) + (LETT |w| + (SPADCALL |w| + (|POLYCAT-;P2R| (|SPADfirst| |r|) |d| |n| $) + (QREFELT $ 99)) + |POLYCAT-;reducedSystem;MVR;21|) + (LETT |l| (CDR |l|) |POLYCAT-;reducedSystem;MVR;21|) + (EXIT (LETT |r| (CDR |r|) |POLYCAT-;reducedSystem;MVR;21|))) + NIL + (GO G190) + G191 + (EXIT NIL)) + (EXIT (CONS |mm| |w|)))))) + +(DEFUN |POLYCAT-;gcdPolynomial;3Sup;22| (|pp| |qq| $) + (SPADCALL |pp| |qq| (QREFELT $ 104))) + +(DEFUN |POLYCAT-;solveLinearPolynomialEquation;LSupU;23| (|lpp| |pp| $) + (SPADCALL |lpp| |pp| (QREFELT $ 109))) + +(DEFUN |POLYCAT-;factorPolynomial;SupF;24| (|pp| $) + (SPADCALL |pp| (QREFELT $ 114))) + +(DEFUN |POLYCAT-;factorSquareFreePolynomial;SupF;25| (|pp| $) + (SPADCALL |pp| (QREFELT $ 117))) + +(DEFUN |POLYCAT-;factor;SF;26| (|p| $) + (PROG (|v| |ansR| #0=#:G1615 |w| #1=#:G1616 |up| |ansSUP| #2=#:G1617 + |ww| #3=#:G1618) + (RETURN + (SEQ + (LETT |v| (SPADCALL |p| (QREFELT $ 42)) |POLYCAT-;factor;SF;26|) + (EXIT + (COND + ((QEQCAR |v| 1) + (SEQ + (LETT |ansR| + (SPADCALL (SPADCALL |p| (QREFELT $ 38)) (QREFELT $ 120)) + |POLYCAT-;factor;SF;26|) + (EXIT + (SPADCALL + (SPADCALL (SPADCALL |ansR| (QREFELT $ 122)) (QREFELT $ 40)) + (PROGN + (LETT #0# NIL |POLYCAT-;factor;SF;26|) + (SEQ + (LETT |w| NIL |POLYCAT-;factor;SF;26|) + (LETT #1# + (SPADCALL |ansR| (QREFELT $ 126)) + |POLYCAT-;factor;SF;26|) + G190 + (COND + ((OR (ATOM #1#) + (PROGN (LETT |w| (CAR #1#) |POLYCAT-;factor;SF;26|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #0# + (CONS + (VECTOR (QVELT |w| 0) + (SPADCALL (QVELT |w| 1) (QREFELT $ 40)) (QVELT |w| 2)) + #0#) + |POLYCAT-;factor;SF;26|))) + (LETT #1# (CDR #1#) |POLYCAT-;factor;SF;26|) + (GO G190) + G191 + (EXIT (NREVERSE0 #0#)))) + (QREFELT $ 130))))) + ((QUOTE T) + (SEQ + (LETT |up| + (SPADCALL |p| (QCDR |v|) (QREFELT $ 47)) |POLYCAT-;factor;SF;26|) + (LETT |ansSUP| (SPADCALL |up| (QREFELT $ 114)) |POLYCAT-;factor;SF;26|) + (EXIT + (SPADCALL + (SPADCALL + (SPADCALL |ansSUP| (QREFELT $ 131)) (QCDR |v|) (QREFELT $ 132)) + (PROGN + (LETT #2# NIL |POLYCAT-;factor;SF;26|) + (SEQ + (LETT |ww| NIL |POLYCAT-;factor;SF;26|) + (LETT #3# + (SPADCALL |ansSUP| (QREFELT $ 135)) + |POLYCAT-;factor;SF;26|) + G190 + (COND + ((OR (ATOM #3#) + (PROGN (LETT |ww| (CAR #3#) |POLYCAT-;factor;SF;26|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #2# + (CONS + (VECTOR (QVELT |ww| 0) (SPADCALL (QVELT |ww| 1) (QCDR |v|) + (QREFELT $ 132)) (QVELT |ww| 2)) + #2#) + |POLYCAT-;factor;SF;26|))) + (LETT #3# (CDR #3#) |POLYCAT-;factor;SF;26|) + (GO G190) + G191 + (EXIT (NREVERSE0 #2#)))) + (QREFELT $ 130))))))))))) + +(DEFUN |POLYCAT-;conditionP;MU;27| (|mat| $) + (PROG (|ll| #0=#:G1653 |z| #1=#:G1654 |ch| |l| #2=#:G1655 #3=#:G1656 + #4=#:G1625 #5=#:G1623 #6=#:G1624 #7=#:G1657 |vars| |degs| + #8=#:G1658 |d| #9=#:G1659 |nd| #10=#:G1652 #11=#:G1632 |deg1| + |redmons| #12=#:G1660 |v| #13=#:G1662 |u| #14=#:G1661 |llR| + |monslist| |ans| #15=#:G1663 #16=#:G1664 |mons| #17=#:G1665 |m| + #18=#:G1666 |i| #19=#:G1648 #20=#:G1646 #21=#:G1647) + (RETURN + (SEQ + (EXIT + (SEQ + (LETT |ll| + (SPADCALL (SPADCALL |mat| (QREFELT $ 137)) (QREFELT $ 92)) + |POLYCAT-;conditionP;MU;27|) + (LETT |llR| + (PROGN + (LETT #0# NIL |POLYCAT-;conditionP;MU;27|) + (SEQ + (LETT |z| NIL |POLYCAT-;conditionP;MU;27|) + (LETT #1# (|SPADfirst| |ll|) |POLYCAT-;conditionP;MU;27|) + G190 + (COND + ((OR (ATOM #1#) + (PROGN (LETT |z| (CAR #1#) |POLYCAT-;conditionP;MU;27|) NIL)) + (GO G191))) + (SEQ (EXIT (LETT #0# (CONS NIL #0#) |POLYCAT-;conditionP;MU;27|))) + (LETT #1# (CDR #1#) |POLYCAT-;conditionP;MU;27|) + (GO G190) + G191 + (EXIT (NREVERSE0 #0#)))) + |POLYCAT-;conditionP;MU;27|) + (LETT |monslist| NIL |POLYCAT-;conditionP;MU;27|) + (LETT |ch| (SPADCALL (QREFELT $ 138)) |POLYCAT-;conditionP;MU;27|) + (SEQ + (LETT |l| NIL |POLYCAT-;conditionP;MU;27|) + (LETT #2# |ll| |POLYCAT-;conditionP;MU;27|) + G190 + (COND + ((OR (ATOM #2#) + (PROGN (LETT |l| (CAR #2#) |POLYCAT-;conditionP;MU;27|) NIL)) + (GO G191))) + (SEQ + (LETT |mons| + (PROGN + (LETT #6# NIL |POLYCAT-;conditionP;MU;27|) + (SEQ + (LETT |u| NIL |POLYCAT-;conditionP;MU;27|) + (LETT #3# |l| |POLYCAT-;conditionP;MU;27|) + G190 + (COND + ((OR (ATOM #3#) + (PROGN (LETT |u| (CAR #3#) |POLYCAT-;conditionP;MU;27|) NIL)) + (GO G191))) + (SEQ + (EXIT + (PROGN + (LETT #4# + (SPADCALL |u| (QREFELT $ 77)) + |POLYCAT-;conditionP;MU;27|) + (COND + (#6# + (LETT #5# + (SPADCALL #5# #4# (QREFELT $ 139)) + |POLYCAT-;conditionP;MU;27|)) + ((QUOTE T) + (PROGN + (LETT #5# #4# |POLYCAT-;conditionP;MU;27|) + (LETT #6# (QUOTE T) |POLYCAT-;conditionP;MU;27|))))))) + (LETT #3# (CDR #3#) |POLYCAT-;conditionP;MU;27|) + (GO G190) + G191 + (EXIT NIL)) + (COND (#6# #5#) ((QUOTE T) (|IdentityError| (QUOTE |setUnion|))))) + |POLYCAT-;conditionP;MU;27|) + (LETT |redmons| NIL |POLYCAT-;conditionP;MU;27|) + (SEQ + (LETT |m| NIL |POLYCAT-;conditionP;MU;27|) + (LETT #7# |mons| |POLYCAT-;conditionP;MU;27|) + G190 + (COND + ((OR (ATOM #7#) + (PROGN (LETT |m| (CAR #7#) |POLYCAT-;conditionP;MU;27|) NIL)) + (GO G191))) + (SEQ + (LETT |vars| + (SPADCALL |m| (QREFELT $ 31)) + |POLYCAT-;conditionP;MU;27|) + (LETT |degs| + (SPADCALL |m| |vars| (QREFELT $ 140)) + |POLYCAT-;conditionP;MU;27|) + (LETT |deg1| + (PROGN + (LETT #8# NIL |POLYCAT-;conditionP;MU;27|) + (SEQ + (LETT |d| NIL |POLYCAT-;conditionP;MU;27|) + (LETT #9# |degs| |POLYCAT-;conditionP;MU;27|) + G190 + (COND + ((OR (ATOM #9#) + (PROGN + (LETT |d| (CAR #9#) |POLYCAT-;conditionP;MU;27|) + NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #8# + (CONS + (SEQ + (LETT |nd| + (SPADCALL |d| |ch| (QREFELT $ 142)) + |POLYCAT-;conditionP;MU;27|) + (EXIT + (COND + ((QEQCAR |nd| 1) + (PROGN + (LETT #10# + (CONS 1 "failed") |POLYCAT-;conditionP;MU;27|) + (GO #10#))) + ((QUOTE T) + (PROG1 + (LETT #11# (QCDR |nd|) |POLYCAT-;conditionP;MU;27|) + (|check-subtype| + (>= #11# 0) (QUOTE (|NonNegativeInteger|)) #11#)))))) + #8#) + |POLYCAT-;conditionP;MU;27|))) + (LETT #9# (CDR #9#) |POLYCAT-;conditionP;MU;27|) + (GO G190) + G191 + (EXIT (NREVERSE0 #8#)))) + |POLYCAT-;conditionP;MU;27|) + (LETT |redmons| + (CONS + (SPADCALL (|spadConstant| $ 33) |vars| |deg1| (QREFELT $ 54)) + |redmons|) + |POLYCAT-;conditionP;MU;27|) + (EXIT + (LETT |llR| + (PROGN + (LETT #12# NIL |POLYCAT-;conditionP;MU;27|) + (SEQ + (LETT |v| NIL |POLYCAT-;conditionP;MU;27|) + (LETT #13# |llR| |POLYCAT-;conditionP;MU;27|) + (LETT |u| NIL |POLYCAT-;conditionP;MU;27|) + (LETT #14# |l| |POLYCAT-;conditionP;MU;27|) + G190 + (COND + ((OR (ATOM #14#) + (PROGN + (LETT |u| (CAR #14#) |POLYCAT-;conditionP;MU;27|) + NIL) + (ATOM #13#) + (PROGN (LETT |v| (CAR #13#) |POLYCAT-;conditionP;MU;27|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #12# + (CONS + (CONS + (SPADCALL + (SPADCALL |u| |vars| |degs| (QREFELT $ 52)) + (QREFELT $ 143)) + |v|) + #12#) + |POLYCAT-;conditionP;MU;27|))) + (LETT #14# + (PROG1 + (CDR #14#) + (LETT #13# (CDR #13#) |POLYCAT-;conditionP;MU;27|)) + |POLYCAT-;conditionP;MU;27|) + (GO G190) + G191 + (EXIT (NREVERSE0 #12#)))) + |POLYCAT-;conditionP;MU;27|))) + (LETT #7# (CDR #7#) |POLYCAT-;conditionP;MU;27|) + (GO G190) + G191 + (EXIT NIL)) + (EXIT + (LETT |monslist| + (CONS |redmons| |monslist|) + |POLYCAT-;conditionP;MU;27|))) + (LETT #2# (CDR #2#) |POLYCAT-;conditionP;MU;27|) + (GO G190) + G191 + (EXIT NIL)) + (LETT |ans| + (SPADCALL (SPADCALL (SPADCALL |llR| (QREFELT $ 89)) (QREFELT $ 144)) + (QREFELT $ 146)) + |POLYCAT-;conditionP;MU;27|) + (EXIT + (COND + ((QEQCAR |ans| 1) (CONS 1 "failed")) + ((QUOTE T) + (SEQ + (LETT |i| 0 |POLYCAT-;conditionP;MU;27|) + (EXIT + (CONS 0 + (PRIMVEC2ARR + (PROGN + (LETT #15# (GETREFV (SIZE |monslist|)) + |POLYCAT-;conditionP;MU;27|) + (SEQ + (LETT #16# 0 |POLYCAT-;conditionP;MU;27|) + (LETT |mons| NIL |POLYCAT-;conditionP;MU;27|) + (LETT #17# |monslist| |POLYCAT-;conditionP;MU;27|) + G190 + (COND + ((OR (ATOM #17#) + (PROGN + (LETT |mons| (CAR #17#) |POLYCAT-;conditionP;MU;27|) + NIL)) + (GO G191))) + (SEQ + (EXIT + (SETELT #15# #16# + (PROGN + (LETT #21# NIL |POLYCAT-;conditionP;MU;27|) + (SEQ + (LETT |m| NIL |POLYCAT-;conditionP;MU;27|) + (LETT #18# |mons| |POLYCAT-;conditionP;MU;27|) + G190 + (COND + ((OR (ATOM #18#) + (PROGN + (LETT |m| (CAR #18#) |POLYCAT-;conditionP;MU;27|) + NIL)) + (GO G191))) + (SEQ + (EXIT + (PROGN + (LETT #19# + (SPADCALL |m| + (SPADCALL + (SPADCALL + (QCDR |ans|) + (LETT |i| (+ |i| 1) |POLYCAT-;conditionP;MU;27|) + (QREFELT $ 147)) + (QREFELT $ 40)) + (QREFELT $ 148)) + |POLYCAT-;conditionP;MU;27|) + (COND + (#21# + (LETT #20# + (SPADCALL #20# #19# (QREFELT $ 149)) + |POLYCAT-;conditionP;MU;27|)) + ((QUOTE T) + (PROGN + (LETT #20# #19# |POLYCAT-;conditionP;MU;27|) + (LETT #21# + (QUOTE T) + |POLYCAT-;conditionP;MU;27|))))))) + (LETT #18# (CDR #18#) |POLYCAT-;conditionP;MU;27|) + (GO G190) + G191 + (EXIT NIL)) + (COND (#21# #20#) ((QUOTE T) (|spadConstant| $ 21))))))) + (LETT #17# + (PROG1 + (CDR #17#) + (LETT #16# (QSADD1 #16#) |POLYCAT-;conditionP;MU;27|)) + |POLYCAT-;conditionP;MU;27|) + (GO G190) + G191 + (EXIT NIL)) + #15#)))))))))) + #10# + (EXIT #10#))))) + +(DEFUN |POLYCAT-;charthRoot;SU;28| (|p| $) + (PROG (|vars| |ans| |ch|) + (RETURN + (SEQ + (LETT |vars| (SPADCALL |p| (QREFELT $ 31)) |POLYCAT-;charthRoot;SU;28|) + (EXIT + (COND + ((NULL |vars|) + (SEQ + (LETT |ans| + (SPADCALL (SPADCALL |p| (QREFELT $ 143)) (QREFELT $ 151)) + |POLYCAT-;charthRoot;SU;28|) + (EXIT + (COND + ((QEQCAR |ans| 1) (CONS 1 "failed")) + ((QUOTE T) (CONS 0 (SPADCALL (QCDR |ans|) (QREFELT $ 40)))))))) + ((QUOTE T) + (SEQ + (LETT |ch| (SPADCALL (QREFELT $ 138)) |POLYCAT-;charthRoot;SU;28|) + (EXIT (|POLYCAT-;charthRootlv| |p| |vars| |ch| $)))))))))) + +(DEFUN |POLYCAT-;charthRootlv| (|p| |vars| |ch| $) + (PROG (|v| |dd| |cp| |d| #0=#:G1687 |ans| |ansx| #1=#:G1694) + (RETURN + (SEQ + (EXIT + (COND + ((NULL |vars|) + (SEQ + (LETT |ans| + (SPADCALL (SPADCALL |p| (QREFELT $ 143)) (QREFELT $ 151)) + |POLYCAT-;charthRootlv|) + (EXIT + (COND + ((QEQCAR |ans| 1) (CONS 1 "failed")) + ((QUOTE T) (CONS 0 (SPADCALL (QCDR |ans|) (QREFELT $ 40)))))))) + ((QUOTE T) + (SEQ + (LETT |v| (|SPADfirst| |vars|) |POLYCAT-;charthRootlv|) + (LETT |vars| (CDR |vars|) |POLYCAT-;charthRootlv|) + (LETT |d| (SPADCALL |p| |v| (QREFELT $ 36)) |POLYCAT-;charthRootlv|) + (LETT |ans| (|spadConstant| $ 21) |POLYCAT-;charthRootlv|) + (SEQ G190 + (COND ((NULL (< 0 |d|)) (GO G191))) + (SEQ + (LETT |dd| + (SPADCALL |d| |ch| (QREFELT $ 142)) + |POLYCAT-;charthRootlv|) + (EXIT + (COND + ((QEQCAR |dd| 1) + (PROGN + (LETT #1# (CONS 1 "failed") |POLYCAT-;charthRootlv|) + (GO #1#))) + ((QUOTE T) + (SEQ + (LETT |cp| + (SPADCALL |p| |v| |d| (QREFELT $ 154)) + |POLYCAT-;charthRootlv|) + (LETT |p| + (SPADCALL |p| + (SPADCALL |cp| |v| |d| (QREFELT $ 37)) + (QREFELT $ 155)) + |POLYCAT-;charthRootlv|) + (LETT |ansx| + (|POLYCAT-;charthRootlv| |cp| |vars| |ch| $) + |POLYCAT-;charthRootlv|) + (EXIT + (COND + ((QEQCAR |ansx| 1) + (PROGN + (LETT #1# (CONS 1 "failed") |POLYCAT-;charthRootlv|) + (GO #1#))) + ((QUOTE T) + (SEQ + (LETT |d| + (SPADCALL |p| |v| (QREFELT $ 36)) + |POLYCAT-;charthRootlv|) + (EXIT + (LETT |ans| + (SPADCALL |ans| + (SPADCALL (QCDR |ansx|) |v| + (PROG1 + (LETT #0# (QCDR |dd|) |POLYCAT-;charthRootlv|) + (|check-subtype| (>= #0# 0) + (QUOTE (|NonNegativeInteger|)) #0#)) + (QREFELT $ 37)) + (QREFELT $ 149)) + |POLYCAT-;charthRootlv|))))))))))) + NIL + (GO G190) + G191 + (EXIT NIL)) + (LETT |ansx| + (|POLYCAT-;charthRootlv| |p| |vars| |ch| $) + |POLYCAT-;charthRootlv|) + (EXIT + (COND + ((QEQCAR |ansx| 1) + (PROGN + (LETT #1# (CONS 1 "failed") |POLYCAT-;charthRootlv|) + (GO #1#))) + ((QUOTE T) + (PROGN + (LETT #1# + (CONS 0 (SPADCALL |ans| (QCDR |ansx|) (QREFELT $ 149))) + |POLYCAT-;charthRootlv|) + (GO #1#))))))))) + #1# + (EXIT #1#))))) + +(DEFUN |POLYCAT-;monicDivide;2SVarSetR;30| (|p1| |p2| |mvar| $) + (PROG (|result|) + (RETURN + (SEQ + (LETT |result| + (SPADCALL + (SPADCALL |p1| |mvar| (QREFELT $ 47)) + (SPADCALL |p2| |mvar| (QREFELT $ 47)) + (QREFELT $ 157)) + |POLYCAT-;monicDivide;2SVarSetR;30|) + (EXIT + (CONS + (SPADCALL (QCAR |result|) |mvar| (QREFELT $ 132)) + (SPADCALL (QCDR |result|) |mvar| (QREFELT $ 132)))))))) + +(DEFUN |POLYCAT-;squareFree;SF;31| (|p| $) + (SPADCALL |p| (QREFELT $ 160))) + +(DEFUN |POLYCAT-;squareFree;SF;32| (|p| $) + (SPADCALL |p| (QREFELT $ 163))) + +(DEFUN |POLYCAT-;squareFree;SF;33| (|p| $) + (SPADCALL |p| (QREFELT $ 163))) + +(DEFUN |POLYCAT-;squareFreePart;2S;34| (|p| $) + (PROG (|s| |f| #0=#:G1710 #1=#:G1708 #2=#:G1706 #3=#:G1707) + (RETURN + (SEQ + (SPADCALL + (SPADCALL + (LETT |s| (SPADCALL |p| (QREFELT $ 164)) |POLYCAT-;squareFreePart;2S;34|) + (QREFELT $ 165)) + (PROGN + (LETT #3# NIL |POLYCAT-;squareFreePart;2S;34|) + (SEQ + (LETT |f| NIL |POLYCAT-;squareFreePart;2S;34|) + (LETT #0# (SPADCALL |s| (QREFELT $ 168)) |POLYCAT-;squareFreePart;2S;34|) + G190 + (COND + ((OR (ATOM #0#) + (PROGN (LETT |f| (CAR #0#) |POLYCAT-;squareFreePart;2S;34|) NIL)) + (GO G191))) + (SEQ + (EXIT + (PROGN + (LETT #1# (QCAR |f|) |POLYCAT-;squareFreePart;2S;34|) + (COND + (#3# + (LETT #2# + (SPADCALL #2# #1# (QREFELT $ 148)) + |POLYCAT-;squareFreePart;2S;34|)) + ((QUOTE T) + (PROGN + (LETT #2# #1# |POLYCAT-;squareFreePart;2S;34|) + (LETT #3# (QUOTE T) |POLYCAT-;squareFreePart;2S;34|))))))) + (LETT #0# (CDR #0#) |POLYCAT-;squareFreePart;2S;34|) + (GO G190) + G191 + (EXIT NIL)) + (COND (#3# #2#) ((QUOTE T) (|spadConstant| $ 33)))) + (QREFELT $ 148)))))) + +(DEFUN |POLYCAT-;content;SVarSetS;35| (|p| |v| $) + (SPADCALL (SPADCALL |p| |v| (QREFELT $ 47)) (QREFELT $ 170))) + +(DEFUN |POLYCAT-;primitivePart;2S;36| (|p| $) + (PROG (#0=#:G1713) + (RETURN + (COND + ((SPADCALL |p| (QREFELT $ 172)) |p|) + ((QUOTE T) + (QVELT + (SPADCALL + (PROG2 + (LETT #0# + (SPADCALL |p| (SPADCALL |p| (QREFELT $ 173)) (QREFELT $ 174)) + |POLYCAT-;primitivePart;2S;36|) + (QCDR #0#) + (|check-union| (QEQCAR #0# 0) (QREFELT $ 6) #0#)) + (QREFELT $ 176)) + 1)))))) + +(DEFUN |POLYCAT-;primitivePart;SVarSetS;37| (|p| |v| $) + (PROG (#0=#:G1720) + (RETURN + (COND + ((SPADCALL |p| (QREFELT $ 172)) |p|) + ((QUOTE T) + (QVELT + (SPADCALL + (PROG2 + (LETT #0# + (SPADCALL |p| (SPADCALL |p| |v| (QREFELT $ 178)) (QREFELT $ 179)) + |POLYCAT-;primitivePart;SVarSetS;37|) + (QCDR #0#) + (|check-union| (QEQCAR #0# 0) (QREFELT $ 6) #0#)) + (QREFELT $ 176)) + 1)))))) + +(DEFUN |POLYCAT-;<;2SB;38| (|p| |q| $) + (PROG (|dp| |dq|) + (RETURN + (SEQ + (LETT |dp| (SPADCALL |p| (QREFELT $ 59)) |POLYCAT-;<;2SB;38|) + (LETT |dq| (SPADCALL |q| (QREFELT $ 59)) |POLYCAT-;<;2SB;38|) + (EXIT + (COND + ((SPADCALL |dp| |dq| (QREFELT $ 181)) + (SPADCALL + (|spadConstant| $ 22) + (SPADCALL |q| (QREFELT $ 38)) + (QREFELT $ 182))) + ((SPADCALL |dq| |dp| (QREFELT $ 181)) + (SPADCALL + (SPADCALL |p| (QREFELT $ 38)) + (|spadConstant| $ 22) + (QREFELT $ 182))) + ((QUOTE T) + (SPADCALL + (SPADCALL (SPADCALL |p| |q| (QREFELT $ 155)) (QREFELT $ 38)) + (|spadConstant| $ 22) + (QREFELT $ 182))))))))) + +(DEFUN |POLYCAT-;patternMatch;SP2Pmr;39| (|p| |pat| |l| $) + (SPADCALL |p| |pat| |l| (QREFELT $ 187))) + +(DEFUN |POLYCAT-;patternMatch;SP2Pmr;40| (|p| |pat| |l| $) + (SPADCALL |p| |pat| |l| (QREFELT $ 193))) + +(DEFUN |POLYCAT-;convert;SP;41| (|x| $) + (SPADCALL (ELT $ 196) (ELT $ 197) |x| (QREFELT $ 201))) + +(DEFUN |POLYCAT-;convert;SP;42| (|x| $) + (SPADCALL (ELT $ 203) (ELT $ 204) |x| (QREFELT $ 208))) + +(DEFUN |POLYCAT-;convert;SIf;43| (|p| $) + (SPADCALL (ELT $ 211) (ELT $ 212) |p| (QREFELT $ 216))) + +(DEFUN |PolynomialCategory&| (|#1| |#2| |#3| |#4|) + (PROG (DV$1 DV$2 DV$3 DV$4 |dv$| $ |pv$|) + (RETURN + (PROGN + (LETT DV$1 (|devaluate| |#1|) . #0=(|PolynomialCategory&|)) + (LETT DV$2 (|devaluate| |#2|) . #0#) + (LETT DV$3 (|devaluate| |#3|) . #0#) + (LETT DV$4 (|devaluate| |#4|) . #0#) + (LETT |dv$| (LIST (QUOTE |PolynomialCategory&|) DV$1 DV$2 DV$3 DV$4) . #0#) + (LETT $ (GETREFV 226) . #0#) + (QSETREFV $ 0 |dv$|) + (QSETREFV $ 3 + (LETT |pv$| + (|buildPredVector| 0 0 + (LIST + (|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) + (|HasAttribute| |#2| (QUOTE |canonicalUnitNormal|)) + (|HasCategory| |#2| (QUOTE (|GcdDomain|))) + (|HasCategory| |#2| (QUOTE (|CommutativeRing|))) + (|HasCategory| |#4| (QUOTE (|PatternMatchable| (|Float|)))) + (|HasCategory| |#2| (QUOTE (|PatternMatchable| (|Float|)))) + (|HasCategory| |#4| (QUOTE (|PatternMatchable| (|Integer|)))) + (|HasCategory| |#2| (QUOTE (|PatternMatchable| (|Integer|)))) + (|HasCategory| |#4| (QUOTE (|ConvertibleTo| (|Pattern| (|Float|))))) + (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Pattern| (|Float|))))) + (|HasCategory| |#4| (QUOTE (|ConvertibleTo| (|Pattern| (|Integer|))))) + (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Pattern| (|Integer|))))) + (|HasCategory| |#4| (QUOTE (|ConvertibleTo| (|InputForm|)))) + (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|InputForm|)))) + (|HasCategory| |#2| (QUOTE (|OrderedSet|))))) + . #0#)) + (|stuffDomainSlots| $) + (QSETREFV $ 6 |#1|) + (QSETREFV $ 7 |#2|) + (QSETREFV $ 8 |#3|) + (QSETREFV $ 9 |#4|) + (COND + ((|testBitVector| |pv$| 4) + (PROGN + (QSETREFV $ 74 + (CONS (|dispatchFunction| |POLYCAT-;resultant;2SVarSetS;15|) $)) + (QSETREFV $ 76 + (CONS (|dispatchFunction| |POLYCAT-;discriminant;SVarSetS;16|) $))))) + (COND + ((|HasCategory| |#2| (QUOTE (|IntegralDomain|))) + (PROGN + (QSETREFV $ 95 + (CONS (|dispatchFunction| |POLYCAT-;reducedSystem;MM;20|) $)) + (QSETREFV $ 102 + (CONS (|dispatchFunction| |POLYCAT-;reducedSystem;MVR;21|) $))))) + (COND + ((|testBitVector| |pv$| 1) + (PROGN + (QSETREFV $ 105 + (CONS (|dispatchFunction| |POLYCAT-;gcdPolynomial;3Sup;22|) $)) + (QSETREFV $ 112 + (CONS + (|dispatchFunction| + |POLYCAT-;solveLinearPolynomialEquation;LSupU;23|) + $)) + (QSETREFV $ 116 + (CONS (|dispatchFunction| |POLYCAT-;factorPolynomial;SupF;24|) $)) + (QSETREFV $ 118 + (CONS + (|dispatchFunction| |POLYCAT-;factorSquareFreePolynomial;SupF;25|) + $)) + (QSETREFV $ 136 (CONS (|dispatchFunction| |POLYCAT-;factor;SF;26|) $)) + (COND + ((|HasCategory| |#2| (QUOTE (|CharacteristicNonZero|))) + (PROGN + (QSETREFV $ 150 + (CONS (|dispatchFunction| |POLYCAT-;conditionP;MU;27|) $)))))))) + (COND + ((|HasCategory| |#2| (QUOTE (|CharacteristicNonZero|))) + (PROGN + (QSETREFV $ 152 + (CONS (|dispatchFunction| |POLYCAT-;charthRoot;SU;28|) $))))) + (COND + ((|testBitVector| |pv$| 3) + (PROGN + (COND + ((|HasCategory| |#2| (QUOTE (|EuclideanDomain|))) + (COND + ((|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) + (QSETREFV $ 161 + (CONS (|dispatchFunction| |POLYCAT-;squareFree;SF;31|) $))) + ((QUOTE T) + (QSETREFV $ 161 + (CONS (|dispatchFunction| |POLYCAT-;squareFree;SF;32|) $))))) + ((QUOTE T) + (QSETREFV $ 161 + (CONS (|dispatchFunction| |POLYCAT-;squareFree;SF;33|) $)))) + (QSETREFV $ 169 + (CONS (|dispatchFunction| |POLYCAT-;squareFreePart;2S;34|) $)) + (QSETREFV $ 171 + (CONS (|dispatchFunction| |POLYCAT-;content;SVarSetS;35|) $)) + (QSETREFV $ 177 + (CONS (|dispatchFunction| |POLYCAT-;primitivePart;2S;36|) $)) + (QSETREFV $ 180 + (CONS (|dispatchFunction| |POLYCAT-;primitivePart;SVarSetS;37|) $))))) + (COND + ((|testBitVector| |pv$| 15) + (PROGN + (QSETREFV $ 183 (CONS (|dispatchFunction| |POLYCAT-;<;2SB;38|) $)) + (COND + ((|testBitVector| |pv$| 8) + (COND + ((|testBitVector| |pv$| 7) + (QSETREFV $ 189 + (CONS + (|dispatchFunction| |POLYCAT-;patternMatch;SP2Pmr;39|) + $)))))) + (COND + ((|testBitVector| |pv$| 6) + (COND + ((|testBitVector| |pv$| 5) + (QSETREFV $ 195 + (CONS + (|dispatchFunction| |POLYCAT-;patternMatch;SP2Pmr;40|) + $))))))))) + (COND + ((|testBitVector| |pv$| 12) + (COND + ((|testBitVector| |pv$| 11) + (QSETREFV $ 202 + (CONS (|dispatchFunction| |POLYCAT-;convert;SP;41|) $)))))) + (COND + ((|testBitVector| |pv$| 10) + (COND + ((|testBitVector| |pv$| 9) + (QSETREFV $ 209 + (CONS (|dispatchFunction| |POLYCAT-;convert;SP;42|) $)))))) + (COND + ((|testBitVector| |pv$| 14) + (COND + ((|testBitVector| |pv$| 13) + (QSETREFV $ 217 + (CONS (|dispatchFunction| |POLYCAT-;convert;SIf;43|) $)))))) + $)))) + +(MAKEPROP + (QUOTE |PolynomialCategory&|) + (QUOTE |infovec|) + (LIST (QUOTE + #(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|) (|local| |#3|) + (|local| |#4|) (|Equation| 6) (0 . |lhs|) (|Union| 9 (QUOTE "failed")) + (5 . |retractIfCan|) (10 . |retract|) (15 . |rhs|) (|List| 9) (|List| $) + (20 . |eval|) (|List| 221) |POLYCAT-;eval;SLS;1| (27 . |Zero|) + (31 . |Zero|) (|Boolean|) (35 . =) (41 . |leadingMonomial|) + (46 . |reductum|) |POLYCAT-;monomials;SL;2| (51 . |monomials|) + (|Union| 17 (QUOTE "failed")) |POLYCAT-;isPlus;SU;3| (56 . |variables|) + (61 . |monomial?|) (66 . |One|) (70 . |One|) (|NonNegativeInteger|) + (74 . |degree|) (80 . |monomial|) (87 . |leadingCoefficient|) (92 . =) + (98 . |coerce|) |POLYCAT-;isTimes;SU;4| (103 . |mainVariable|) + (|Record| (|:| |var| 9) (|:| |exponent| 35)) + (|Union| 43 (QUOTE "failed")) |POLYCAT-;isExpt;SU;5| + (|SparseUnivariatePolynomial| $) (108 . |univariate|) + (|SparseUnivariatePolynomial| 6) (114 . |coefficient|) + |POLYCAT-;coefficient;SVarSetNniS;6| (|List| 35) (120 . |coefficient|) + |POLYCAT-;coefficient;SLLS;7| (127 . |monomial|) + |POLYCAT-;monomial;SLLS;8| (134 . |coerce|) + |POLYCAT-;retract;SVarSet;9| |POLYCAT-;retractIfCan;SU;10| + (139 . |degree|) (144 . |monomial|) |POLYCAT-;primitiveMonomials;SL;12| + (150 . |ground?|) (155 . |Zero|) (159 . =) (165 . |degree|) + (170 . |leadingCoefficient|) (175 . |totalDegree|) (180 . |reductum|) + |POLYCAT-;totalDegree;SNni;13| (185 . |member?|) (191 . |totalDegree|) + |POLYCAT-;totalDegree;SLNni;14| (197 . |resultant|) (203 . |resultant|) + (210 . |discriminant|) (215 . |discriminant|) (221 . |primitiveMonomials|) + (|List| 6) (226 . |concat|) (231 . |removeDuplicates!|) (|Vector| 7) + (236 . |new|) (|Integer|) (242 . |minIndex|) (247 . |coefficient|) + (253 . |qsetelt!|) (|List| 220) (|Matrix| 7) (260 . |matrix|) + (|List| 78) (|Matrix| 6) (265 . |listOfLists|) (270 . |vertConcat|) + (|Matrix| $) (276 . |reducedSystem|) (|Vector| 6) (281 . |entries|) + (286 . |concat|) (292 . |concat|) + (|Record| (|:| |mat| 88) (|:| |vec| 81)) (|Vector| $) + (298 . |reducedSystem|) (|GeneralPolynomialGcdPackage| 8 9 7 6) + (304 . |gcdPolynomial|) (310 . |gcdPolynomial|) + (|Union| 107 (QUOTE "failed")) (|List| 48) + (|PolynomialFactorizationByRecursion| 7 8 9 6) + (316 . |solveLinearPolynomialEquationByRecursion|) + (|Union| 111 (QUOTE "failed")) (|List| 46) + (322 . |solveLinearPolynomialEquation|) (|Factored| 48) + (328 . |factorByRecursion|) (|Factored| 46) (333 . |factorPolynomial|) + (338 . |factorSquareFreeByRecursion|) + (343 . |factorSquareFreePolynomial|) (|Factored| $) (348 . |factor|) + (|Factored| 7) (353 . |unit|) + (|Union| (QUOTE "nil") (QUOTE "sqfr") (QUOTE "irred") (QUOTE "prime")) + (|Record| (|:| |flg| 123) (|:| |fctr| 7) (|:| |xpnt| 83)) + (|List| 124) (358 . |factorList|) + (|Record| (|:| |flg| 123) (|:| |fctr| 6) (|:| |xpnt| 83)) + (|List| 127) (|Factored| 6) (363 . |makeFR|) (369 . |unit|) + (374 . |multivariate|) + (|Record| (|:| |flg| 123) (|:| |fctr| 48) (|:| |xpnt| 83)) + (|List| 133) (380 . |factorList|) (385 . |factor|) (390 . |transpose|) + (395 . |characteristic|) (399 . |setUnion|) (405 . |degree|) + (|Union| $ (QUOTE "failed")) (411 . |exquo|) (417 . |ground|) + (422 . |transpose|) (|Union| 101 (QUOTE "failed")) (427 . |conditionP|) + (432 . |elt|) (438 . *) (444 . +) (450 . |conditionP|) + (455 . |charthRoot|) (460 . |charthRoot|) (465 . |Zero|) + (469 . |coefficient|) (476 . -) + (|Record| (|:| |quotient| $) (|:| |remainder| $)) + (482 . |monicDivide|) |POLYCAT-;monicDivide;2SVarSetR;30| + (|MultivariateSquareFree| 8 9 7 6) (488 . |squareFree|) + (493 . |squareFree|) (|PolynomialSquareFree| 9 8 7 6) + (498 . |squareFree|) (503 . |squareFree|) (508 . |unit|) + (|Record| (|:| |factor| 6) (|:| |exponent| 83)) (|List| 166) + (513 . |factors|) (518 . |squareFreePart|) (523 . |content|) + (528 . |content|) (534 . |zero?|) (539 . |content|) (544 . |exquo|) + (|Record| (|:| |unit| $) (|:| |canonical| $) (|:| |associate| $)) + (550 . |unitNormal|) (555 . |primitivePart|) (560 . |content|) + (566 . |exquo|) (572 . |primitivePart|) (578 . <) (584 . <) (590 . <) + (|PatternMatchResult| 83 6) (|Pattern| 83) + (|PatternMatchPolynomialCategory| 83 8 9 7 6) (596 . |patternMatch|) + (|PatternMatchResult| 83 $) (603 . |patternMatch|) + (|PatternMatchResult| (|Float|) 6) (|Pattern| (|Float|)) + (|PatternMatchPolynomialCategory| (|Float|) 8 9 7 6) + (610 . |patternMatch|) (|PatternMatchResult| (|Float|) $) + (617 . |patternMatch|) (624 . |convert|) (629 . |convert|) + (|Mapping| 185 9) (|Mapping| 185 7) + (|PolynomialCategoryLifting| 8 9 7 6 185) (634 . |map|) + (641 . |convert|) (646 . |convert|) (651 . |convert|) (|Mapping| 191 9) + (|Mapping| 191 7) (|PolynomialCategoryLifting| 8 9 7 6 191) + (656 . |map|) (663 . |convert|) (|InputForm|) (668 . |convert|) + (673 . |convert|) (|Mapping| 210 9) (|Mapping| 210 7) + (|PolynomialCategoryLifting| 8 9 7 6 210) (678 . |map|) + (685 . |convert|) (|Record| (|:| |mat| 219) (|:| |vec| (|Vector| 83))) + (|Matrix| 83) (|List| 7) (|Equation| $) (|Union| 83 (QUOTE "failed")) + (|Union| 224 (QUOTE "failed")) (|Fraction| 83) + (|Union| 7 (QUOTE "failed")))) + (QUOTE #(|totalDegree| 690 |squareFreePart| 701 |squareFree| 706 + |solveLinearPolynomialEquation| 711 |retractIfCan| 717 |retract| 722 + |resultant| 727 |reducedSystem| 734 |primitivePart| 745 + |primitiveMonomials| 756 |patternMatch| 761 |monomials| 775 + |monomial| 780 |monicDivide| 787 |isTimes| 794 |isPlus| 799 + |isExpt| 804 |gcdPolynomial| 809 |factorSquareFreePolynomial| 815 + |factorPolynomial| 820 |factor| 825 |eval| 830 |discriminant| 836 + |convert| 842 |content| 857 |conditionP| 863 |coefficient| 868 + |charthRoot| 882 < 887)) + (QUOTE NIL) + (CONS (|makeByteWordVec2| 1 (QUOTE NIL)) + (CONS (QUOTE #()) + (CONS (QUOTE #()) + (|makeByteWordVec2| 217 (QUOTE + (1 10 6 0 11 1 6 12 0 13 1 6 9 0 14 1 10 6 0 15 3 6 0 0 16 17 18 0 6 0 + 21 0 7 0 22 2 6 23 0 0 24 1 6 0 0 25 1 6 0 0 26 1 6 17 0 28 1 6 16 0 + 31 1 6 23 0 32 0 6 0 33 0 7 0 34 2 6 35 0 9 36 3 6 0 0 9 35 37 1 6 7 + 0 38 2 7 23 0 0 39 1 6 0 7 40 1 6 12 0 42 2 6 46 0 9 47 2 48 6 0 35 + 49 3 6 0 0 16 51 52 3 6 0 0 16 51 54 1 6 0 9 56 1 6 8 0 59 2 6 0 7 8 + 60 1 6 23 0 62 0 48 0 63 2 48 23 0 0 64 1 48 35 0 65 1 48 6 0 66 1 6 + 35 0 67 1 48 0 0 68 2 16 23 9 0 70 2 6 35 0 16 71 2 48 6 0 0 73 3 0 + 0 0 0 9 74 1 48 6 0 75 2 0 0 0 9 76 1 6 17 0 77 1 78 0 17 79 1 78 0 + 0 80 2 81 0 35 7 82 1 81 83 0 84 2 6 7 0 8 85 3 81 7 0 83 7 86 1 88 + 0 87 89 1 91 90 0 92 2 88 0 0 0 93 1 0 88 94 95 1 96 78 0 97 2 78 0 + 0 0 98 2 81 0 0 0 99 2 0 100 94 101 102 2 103 48 48 48 104 2 0 46 46 + 46 105 2 108 106 107 48 109 2 0 110 111 46 112 1 108 113 48 114 1 0 + 115 46 116 1 108 113 48 117 1 0 115 46 118 1 7 119 0 120 1 121 7 0 + 122 1 121 125 0 126 2 129 0 6 128 130 1 113 48 0 131 2 6 0 46 9 132 + 1 113 134 0 135 1 0 119 0 136 1 91 0 0 137 0 6 35 138 2 78 0 0 0 139 + 2 6 51 0 16 140 2 83 141 0 0 142 1 6 7 0 143 1 88 0 0 144 1 7 145 94 + 146 2 81 7 0 83 147 2 6 0 0 0 148 2 6 0 0 0 149 1 0 145 94 150 1 7 + 141 0 151 1 0 141 0 152 0 8 0 153 3 6 0 0 9 35 154 2 6 0 0 0 155 2 + 48 156 0 0 157 1 159 129 6 160 1 0 119 0 161 1 162 129 6 163 1 6 119 + 0 164 1 129 6 0 165 1 129 167 0 168 1 0 0 0 169 1 48 6 0 170 2 0 0 0 + 9 171 1 6 23 0 172 1 6 7 0 173 2 6 141 0 7 174 1 6 175 0 176 1 0 0 0 + 177 2 6 0 0 9 178 2 6 141 0 0 179 2 0 0 0 9 180 2 8 23 0 0 181 2 7 23 + 0 0 182 2 0 23 0 0 183 3 186 184 6 185 184 187 3 0 188 0 185 188 189 + 3 192 190 6 191 190 193 3 0 194 0 191 194 195 1 9 185 0 196 1 7 185 + 0 197 3 200 185 198 199 6 201 1 0 185 0 202 1 9 191 0 203 1 7 191 0 + 204 3 207 191 205 206 6 208 1 0 191 0 209 1 9 210 0 211 1 7 210 0 + 212 3 215 210 213 214 6 216 1 0 210 0 217 2 0 35 0 16 72 1 0 35 0 69 + 1 0 0 0 169 1 0 119 0 161 2 0 110 111 46 112 1 0 12 0 58 1 0 9 0 57 + 3 0 0 0 0 9 74 1 0 88 94 95 2 0 100 94 101 102 2 0 0 0 9 180 1 0 0 0 + 177 1 0 17 0 61 3 0 188 0 185 188 189 3 0 194 0 191 194 195 1 0 17 0 + 27 3 0 0 0 16 51 55 3 0 156 0 0 9 158 1 0 29 0 41 1 0 29 0 30 1 0 44 + 0 45 2 0 46 46 46 105 1 0 115 46 118 1 0 115 46 116 1 0 119 0 136 2 + 0 0 0 19 20 2 0 0 0 9 76 1 0 210 0 217 1 0 185 0 202 1 0 191 0 209 2 + 0 0 0 9 171 1 0 145 94 150 3 0 0 0 16 51 53 3 0 0 0 9 35 50 1 0 141 + 0 152 2 0 23 0 0 183)))))) + (QUOTE |lookupComplete|))) + +@ \section{RCAGG.lsp BOOTSTRAP} {\bf RCAGG} depends on a chain of files. We need to break this cycle to build the algebra. So we keep a cached copy of the translated {\bf RCAGG} @@ -33070,6 +35714,7 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> @@ -33200,6 +35845,7 @@ digraph dotabb { <> <> <> +<> <> <> <> @@ -33333,6 +35979,7 @@ digraph dotfull { <> <> <> +<> <> <> <> diff --git a/books/ps/v102fullypatternmatchable.ps b/books/ps/v102fullypatternmatchable.ps new file mode 100644 index 0000000..68f2efc --- /dev/null +++ b/books/ps/v102fullypatternmatchable.ps @@ -0,0 +1,335 @@ +%!PS-Adobe-2.0 +%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006) +%%For: (root) root +%%Title: pic +%%Pages: (atend) +%%BoundingBox: 36 36 234 224 +%%EndComments +save +%%BeginProlog +/DotDict 200 dict def +DotDict begin + +/setupLatin1 { +mark +/EncodingVector 256 array def + EncodingVector 0 + +ISOLatin1Encoding 0 255 getinterval putinterval +EncodingVector 45 /hyphen put + +% Set up ISO Latin 1 character encoding +/starnetISO { + dup dup findfont dup length dict begin + { 1 index /FID ne { def }{ pop pop } ifelse + } forall + /Encoding EncodingVector def + currentdict end definefont +} def +/Times-Roman starnetISO def +/Times-Italic starnetISO def +/Times-Bold starnetISO def +/Times-BoldItalic starnetISO def +/Helvetica starnetISO def +/Helvetica-Oblique starnetISO def +/Helvetica-Bold starnetISO def +/Helvetica-BoldOblique starnetISO def +/Courier starnetISO def +/Courier-Oblique starnetISO def +/Courier-Bold starnetISO def +/Courier-BoldOblique starnetISO def +cleartomark +} bind def + +%%BeginResource: procset graphviz 0 0 +/coord-font-family /Times-Roman def +/default-font-family /Times-Roman def +/coordfont coord-font-family findfont 8 scalefont def + +/InvScaleFactor 1.0 def +/set_scale { + dup 1 exch div /InvScaleFactor exch def + dup scale +} bind def + +% styles +/solid { [] 0 setdash } bind def +/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def +/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def +/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def +/bold { 2 setlinewidth } bind def +/filled { } bind def +/unfilled { } bind def +/rounded { } bind def +/diagonals { } bind def + +% hooks for setting color +/nodecolor { sethsbcolor } bind def +/edgecolor { sethsbcolor } bind def +/graphcolor { sethsbcolor } bind def +/nopcolor {pop pop pop} bind def + +/beginpage { % i j npages + /npages exch def + /j exch def + /i exch def + /str 10 string def + npages 1 gt { + gsave + coordfont setfont + 0 0 moveto + (\() show i str cvs show (,) show j str cvs show (\)) show + grestore + } if +} bind def + +/set_font { + findfont exch + scalefont setfont +} def + +% draw aligned label in bounding box aligned to current point +/alignedtext { % width adj text + /text exch def + /adj exch def + /width exch def + gsave + width 0 gt { + text stringwidth pop adj mul 0 rmoveto + } if + [] 0 setdash + text show + grestore +} def + +/boxprim { % xcorner ycorner xsize ysize + 4 2 roll + moveto + 2 copy + exch 0 rlineto + 0 exch rlineto + pop neg 0 rlineto + closepath +} bind def + +/ellipse_path { + /ry exch def + /rx exch def + /y exch def + /x exch def + matrix currentmatrix + newpath + x y translate + rx ry scale + 0 0 1 0 360 arc + setmatrix +} bind def + +/endpage { showpage } bind def +/showpage { } def + +/layercolorseq + [ % layer color sequence - darkest to lightest + [0 0 0] + [.2 .8 .8] + [.4 .8 .8] + [.6 .8 .8] + [.8 .8 .8] + ] +def + +/layerlen layercolorseq length def + +/setlayer {/maxlayer exch def /curlayer exch def + layercolorseq curlayer 1 sub layerlen mod get + aload pop sethsbcolor + /nodecolor {nopcolor} def + /edgecolor {nopcolor} def + /graphcolor {nopcolor} def +} bind def + +/onlayer { curlayer ne {invis} if } def + +/onlayers { + /myupper exch def + /mylower exch def + curlayer mylower lt + curlayer myupper gt + or + {invis} if +} def + +/curlayer 0 def + +%%EndResource +%%EndProlog +%%BeginSetup +14 default-font-family set_font +1 setmiterlimit +% /arrowlength 10 def +% /arrowwidth 5 def + +% make sure pdfmark is harmless for PS-interpreters other than Distiller +/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse +% make '<<' and '>>' safe on PS Level 1 devices +/languagelevel where {pop languagelevel}{1} ifelse +2 lt { + userdict (<<) cvn ([) cvn load put + userdict (>>) cvn ([) cvn load put +} if + +%%EndSetup +%%Page: 1 1 +%%PageBoundingBox: 36 36 234 224 +%%PageOrientation: Portrait +gsave +36 36 198 188 boxprim clip newpath +36 36 translate +0 0 1 beginpage +1.0000 set_scale +4 4 translate 0 rotate +0.167 0.600 1.000 graphcolor +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 186 lineto +196 186 lineto +196 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 186 lineto +196 186 lineto +196 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% FullyPatternMatchable(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 190 180 moveto +0 180 lineto +0 144 lineto +190 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 190 180 moveto +0 180 lineto +0 144 lineto +190 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 157 moveto +(FullyPatternMatchable\(a:Type\)) +[7.44 6.96 3.84 3.6 6.96 7.44 6.24 3.84 3.84 6.24 5.04 6.96 12.48 6.24 3.84 6 6.96 6.24 6.96 3.84 6.24 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% Type() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 122 108 moveto +68 108 lineto +68 72 lineto +122 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 122 108 moveto +68 108 lineto +68 72 lineto +122 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +76 85 moveto +(Type\(\)) +[7.2 6.96 6.96 6.24 4.56 4.56] +xshow +end grestore +end grestore +% FullyPatternMatchable(a:Type)->Type() +newpath 95 144 moveto +95 136 95 127 95 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 99 118 moveto +95 108 lineto +92 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 99 118 moveto +95 108 lineto +92 118 lineto +closepath +stroke +end grestore +% Category +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 129 36 moveto +61 36 lineto +61 0 lineto +129 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 129 36 moveto +61 36 lineto +61 0 lineto +129 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +69 13 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% Type()->Category +newpath 95 72 moveto +95 64 95 55 95 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 99 46 moveto +95 36 lineto +92 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 99 46 moveto +95 36 lineto +92 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102polynomialcategory.ps b/books/ps/v102polynomialcategory.ps new file mode 100644 index 0000000..305de5f --- /dev/null +++ b/books/ps/v102polynomialcategory.ps @@ -0,0 +1,800 @@ +%!PS-Adobe-2.0 +%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006) +%%For: (root) root +%%Title: pic +%%Pages: (atend) +%%BoundingBox: 36 36 1246 152 +%%EndComments +save +%%BeginProlog +/DotDict 200 dict def +DotDict begin + +/setupLatin1 { +mark +/EncodingVector 256 array def + EncodingVector 0 + +ISOLatin1Encoding 0 255 getinterval putinterval +EncodingVector 45 /hyphen put + +% Set up ISO Latin 1 character encoding +/starnetISO { + dup dup findfont dup length dict begin + { 1 index /FID ne { def }{ pop pop } ifelse + } forall + /Encoding EncodingVector def + currentdict end definefont +} def +/Times-Roman starnetISO def +/Times-Italic starnetISO def +/Times-Bold starnetISO def +/Times-BoldItalic starnetISO def +/Helvetica starnetISO def +/Helvetica-Oblique starnetISO def +/Helvetica-Bold starnetISO def +/Helvetica-BoldOblique starnetISO def +/Courier starnetISO def +/Courier-Oblique starnetISO def +/Courier-Bold starnetISO def +/Courier-BoldOblique starnetISO def +cleartomark +} bind def + +%%BeginResource: procset graphviz 0 0 +/coord-font-family /Times-Roman def +/default-font-family /Times-Roman def +/coordfont coord-font-family findfont 8 scalefont def + +/InvScaleFactor 1.0 def +/set_scale { + dup 1 exch div /InvScaleFactor exch def + dup scale +} bind def + +% styles +/solid { [] 0 setdash } bind def +/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def +/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def +/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def +/bold { 2 setlinewidth } bind def +/filled { } bind def +/unfilled { } bind def +/rounded { } bind def +/diagonals { } bind def + +% hooks for setting color +/nodecolor { sethsbcolor } bind def +/edgecolor { sethsbcolor } bind def +/graphcolor { sethsbcolor } bind def +/nopcolor {pop pop pop} bind def + +/beginpage { % i j npages + /npages exch def + /j exch def + /i exch def + /str 10 string def + npages 1 gt { + gsave + coordfont setfont + 0 0 moveto + (\() show i str cvs show (,) show j str cvs show (\)) show + grestore + } if +} bind def + +/set_font { + findfont exch + scalefont setfont +} def + +% draw aligned label in bounding box aligned to current point +/alignedtext { % width adj text + /text exch def + /adj exch def + /width exch def + gsave + width 0 gt { + text stringwidth pop adj mul 0 rmoveto + } if + [] 0 setdash + text show + grestore +} def + +/boxprim { % xcorner ycorner xsize ysize + 4 2 roll + moveto + 2 copy + exch 0 rlineto + 0 exch rlineto + pop neg 0 rlineto + closepath +} bind def + +/ellipse_path { + /ry exch def + /rx exch def + /y exch def + /x exch def + matrix currentmatrix + newpath + x y translate + rx ry scale + 0 0 1 0 360 arc + setmatrix +} bind def + +/endpage { showpage } bind def +/showpage { } def + +/layercolorseq + [ % layer color sequence - darkest to lightest + [0 0 0] + [.2 .8 .8] + [.4 .8 .8] + [.6 .8 .8] + [.8 .8 .8] + ] +def + +/layerlen layercolorseq length def + +/setlayer {/maxlayer exch def /curlayer exch def + layercolorseq curlayer 1 sub layerlen mod get + aload pop sethsbcolor + /nodecolor {nopcolor} def + /edgecolor {nopcolor} def + /graphcolor {nopcolor} def +} bind def + +/onlayer { curlayer ne {invis} if } def + +/onlayers { + /myupper exch def + /mylower exch def + curlayer mylower lt + curlayer myupper gt + or + {invis} if +} def + +/curlayer 0 def + +%%EndResource +%%EndProlog +%%BeginSetup +14 default-font-family set_font +1 setmiterlimit +% /arrowlength 10 def +% /arrowwidth 5 def + +% make sure pdfmark is harmless for PS-interpreters other than Distiller +/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse +% make '<<' and '>>' safe on PS Level 1 devices +/languagelevel where {pop languagelevel}{1} ifelse +2 lt { + userdict (<<) cvn ([) cvn load put + userdict (>>) cvn ([) cvn load put +} if + +%%EndSetup +%%Page: 1 1 +%%PageBoundingBox: 36 36 1246 152 +%%PageOrientation: Portrait +gsave +36 36 1210 116 boxprim clip newpath +36 36 translate +0 0 1 beginpage +1.0000 set_scale +4 4 translate 0 rotate +0.167 0.600 1.000 graphcolor +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 114 lineto +1208 114 lineto +1208 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 114 lineto +1208 114 lineto +1208 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet) +[ /Rect [ 373 72 799 108 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=POLYCAT) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 799 108 moveto +373 108 lineto +373 72 lineto +799 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 799 108 moveto +373 108 lineto +373 72 lineto +799 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +381 85 moveto +(PolynomialCategory\(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet\)) +[7.44 6.96 3.6 6.96 6.96 6.96 10.8 3.84 6.24 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 6.24 3.84 9.36 3.84 6.96 6.96 3.6 6.96 3.84 10.08 4.56 6.96 6.24 4.8 6.24 6.96 9.84 6.96 6.24 3.84 3.84 6.24 6.96 12.48 6.96 6.96 6.96 3.84 6.96 7.68 6.96 6.96 3.6 6.24 3.84 10.08 4.56 6.96 6.24 4.8 6.24 6.96 7.68 6 3.84 4.56] +xshow +end grestore +end grestore +% PDRING... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 80 36 moveto +0 36 lineto +0 0 lineto +80 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 80 36 moveto +0 36 lineto +0 0 lineto +80 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 13 moveto +(PDRING...) +[7.68 10.08 9.36 4.56 9.84 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->PDRING... +newpath 373 78 moveto +287 70 188 58 90 35 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 90 32 moveto +80 33 lineto +89 38 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 90 32 moveto +80 33 lineto +89 38 lineto +closepath +stroke +end grestore +% FAMR... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 164 36 moveto +98 36 lineto +98 0 lineto +164 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 164 36 moveto +98 36 lineto +98 0 lineto +164 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +106 13 moveto +(FAMR...) +[6.72 10.08 12.48 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->FAMR... +newpath 373 73 moveto +311 65 243 54 174 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 175 33 moveto +164 33 lineto +173 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 175 33 moveto +164 33 lineto +173 39 lineto +closepath +stroke +end grestore +% EVALAB... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 264 36 moveto +182 36 lineto +182 0 lineto +264 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 264 36 moveto +182 36 lineto +182 0 lineto +264 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +189 13 moveto +(EVALAB...) +[8.64 8.4 10.08 8.64 10.08 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->EVALAB... +newpath 451 72 moveto +399 63 337 52 274 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 275 33 moveto +264 33 lineto +273 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 275 33 moveto +264 33 lineto +273 39 lineto +closepath +stroke +end grestore +% IEVALAB... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 370 36 moveto +282 36 lineto +282 0 lineto +370 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 370 36 moveto +282 36 lineto +282 0 lineto +370 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +290 13 moveto +(IEVALAB...) +[4.56 8.64 8.4 10.08 8.64 10.08 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->IEVALAB... +newpath 512 72 moveto +475 63 429 51 380 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 381 33 moveto +370 33 lineto +379 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 381 33 moveto +370 33 lineto +379 39 lineto +closepath +stroke +end grestore +% RETRACT... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 478 36 moveto +388 36 lineto +388 0 lineto +478 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 478 36 moveto +388 36 lineto +388 0 lineto +478 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +396 13 moveto +(RETRACT...) +[9.36 8.64 8.64 9.36 9.36 9.36 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->RETRACT... +newpath 547 72 moveto +527 62 502 51 480 40 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 482 37 moveto +471 36 lineto +479 43 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 482 37 moveto +471 36 lineto +479 43 lineto +closepath +stroke +end grestore +% FLINEXP... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 578 36 moveto +496 36 lineto +496 0 lineto +578 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 578 36 moveto +496 36 lineto +496 0 lineto +578 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +503 13 moveto +(FLINEXP...) +[7.68 8.64 4.56 10.08 8.64 10.08 6.24 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->FLINEXP... +newpath 574 72 moveto +568 64 561 54 555 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 558 42 moveto +549 36 lineto +552 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 558 42 moveto +549 36 lineto +552 46 lineto +closepath +stroke +end grestore +% ORDSET... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 676 36 moveto +596 36 lineto +596 0 lineto +676 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 676 36 moveto +596 36 lineto +596 0 lineto +676 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +603 13 moveto +(ORDSET...) +[10.08 9.36 10.08 7.68 8.64 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->ORDSET... +newpath 599 72 moveto +604 64 611 54 617 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 620 46 moveto +623 36 lineto +614 42 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 620 46 moveto +623 36 lineto +614 42 lineto +closepath +stroke +end grestore +% GCDDOM... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 784 36 moveto +694 36 lineto +694 0 lineto +784 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 784 36 moveto +694 36 lineto +694 0 lineto +784 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +702 13 moveto +(GCDDOM...) +[10.08 9.36 10.08 10.08 10.08 12.48 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->GCDDOM... +newpath 625 72 moveto +645 62 670 51 692 40 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 693 43 moveto +701 36 lineto +690 37 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 693 43 moveto +701 36 lineto +690 37 lineto +closepath +stroke +end grestore +% PFECAT... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 880 36 moveto +802 36 lineto +802 0 lineto +880 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 880 36 moveto +802 36 lineto +802 0 lineto +880 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +810 13 moveto +(PFECAT...) +[7.68 7.68 8.64 9.12 9.36 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->PFECAT... +newpath 662 72 moveto +699 63 744 51 792 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 793 39 moveto +802 33 lineto +791 33 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 793 39 moveto +802 33 lineto +791 33 lineto +closepath +stroke +end grestore +% KONVERT... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 990 36 moveto +898 36 lineto +898 0 lineto +990 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 990 36 moveto +898 36 lineto +898 0 lineto +990 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +905 13 moveto +(KONVERT...) +[9.12 10.08 10.08 10.08 8.64 8.88 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->KONVERT... +newpath 709 72 moveto +761 63 824 52 888 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 889 39 moveto +898 33 lineto +887 33 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 889 39 moveto +898 33 lineto +887 33 lineto +closepath +stroke +end grestore +% PATMAB... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 1092 36 moveto +1008 36 lineto +1008 0 lineto +1092 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 1092 36 moveto +1008 36 lineto +1008 0 lineto +1092 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +1015 13 moveto +(PATMAB...) +[6.48 9.36 8.64 12.48 10.08 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->PATMAB... +newpath 789 72 moveto +853 64 925 53 998 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 999 39 moveto +1008 34 lineto +998 33 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 999 39 moveto +1008 34 lineto +998 33 lineto +closepath +stroke +end grestore +% COMRING... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 1202 36 moveto +1110 36 lineto +1110 0 lineto +1202 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 1202 36 moveto +1110 36 lineto +1110 0 lineto +1202 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +1117 13 moveto +(COMRING...) +[9.12 10.08 12.48 9.36 4.56 9.84 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->COMRING... +newpath 799 78 moveto +889 70 996 58 1100 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 1101 39 moveto +1110 34 lineto +1100 33 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 1101 39 moveto +1110 34 lineto +1100 33 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF