subtractIfCan$CancellationAbelianMonoid: return the more principled Maybe %

author: Gabriel Dos Reis <gdr@axiomatics.org> 2016-01-17 22:53:01 -0800
committer: Gabriel Dos Reis <gdr@axiomatics.org> 2016-01-17 22:53:01 -0800
commit: d07fc9735f40e545edda456e15dbab783c500f6a (patch)
tree: 4d9fab82a7085b73a4b00d23389935503fdfc90d /src/share/algebra/browse.daase
parent: 5437d438937eb25eb320fef6e4fd6ebc91ca6dc9 (diff)
download: open-axiom-d07fc9735f40e545edda456e15dbab783c500f6a.tar.gz
1 files changed, 313 insertions, 313 deletions
diff --git a/src/share/algebra/browse.daase b/src/share/algebra/browse.daase
index f4e6e265..c5762f0e 100644
--- a/src/share/algebra/browse.daase
+++ b/src/share/algebra/browse.daase
@@ -1,5 +1,5 @@
 
-(1915153 . 3581079092)       
+(1891991 . 3662084402)       
 (|OneDimensionalArrayAggregate&| A S) 
 ((|constructor| (NIL "One-dimensional-array aggregates serves as models for one-dimensional arrays. Categorically,{} these aggregates are finite linear aggregates with the shallowly mutable property,{} that is,{} any component of the array may be changed without affecting the identity of the overall array. Array data structures are typically represented by a fixed area in storage and therefore cannot efficiently grow or shrink on demand as can list structures (see however \\spadtype{FlexibleArray} for a data structure which is a cross between a list and an array). Iteration over,{} and access to,{} elements of arrays is extremely fast (and often can be optimized to open-code). Insertion and deletion however is generally slow since an entirely new data structure must be created for the result."))) 
 NIL 
@@ -38,7 +38,7 @@ NIL
 NIL 
 (|AlgebraicallyClosedField|) 
 ((|constructor| (NIL "Model for algebraically closed fields.")) (|zerosOf| (((|List| $) (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\spad{zerosOf(p, y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}. The \\spad{yi}'s are expressed in radicals if possible,{} and otherwise as implicit algebraic quantities which display as \\spad{'yi}. The returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values.") (((|List| $) (|SparseUnivariatePolynomial| $)) "\\spad{zerosOf(p)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}. The \\spad{yi}'s are expressed in radicals if possible,{} and otherwise as implicit algebraic quantities. The returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values.") (((|List| $) (|Polynomial| $)) "\\spad{zerosOf(p)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}. The \\spad{yi}'s are expressed in radicals if possible. Otherwise they are implicit algebraic quantities. The returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable \\spad{y}.")) (|zeroOf| (($ (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\spad{zeroOf(p, y)} returns \\spad{y} such that \\spad{p(y) = 0}; if possible,{} \\spad{y} is expressed in terms of radicals. Otherwise it is an implicit algebraic quantity which displays as \\spad{'y}.") (($ (|SparseUnivariatePolynomial| $)) "\\spad{zeroOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}; if possible,{} \\spad{y} is expressed in terms of radicals. Otherwise it is an implicit algebraic quantity.") (($ (|Polynomial| $)) "\\spad{zeroOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. If possible,{} \\spad{y} is expressed in terms of radicals. Otherwise it is an implicit algebraic quantity. Error: if \\spad{p} has more than one variable \\spad{y}.")) (|rootsOf| (((|List| $) (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\spad{rootsOf(p, y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}; The returned roots display as \\spad{'y1},{}...,{}\\spad{'yn}. Note: the returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values.") (((|List| $) (|SparseUnivariatePolynomial| $)) "\\spad{rootsOf(p)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}. Note: the returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values.") (((|List| $) (|Polynomial| $)) "\\spad{rootsOf(p)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}. Note: the returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable \\spad{y}.")) (|rootOf| (($ (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\spad{rootOf(p, y)} returns \\spad{y} such that \\spad{p(y) = 0}. The object returned displays as \\spad{'y}.") (($ (|SparseUnivariatePolynomial| $)) "\\spad{rootOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}.") (($ (|Polynomial| $)) "\\spad{rootOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. Error: if \\spad{p} has more than one variable \\spad{y}."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|AlgebraicallyClosedFunctionSpace&| S R) 
 ((|constructor| (NIL "Model for algebraically closed function spaces.")) (|zerosOf| (((|List| $) $ (|Symbol|)) "\\spad{zerosOf(p, y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}. The \\spad{yi}'s are expressed in radicals if possible,{} and otherwise as implicit algebraic quantities which display as \\spad{'yi}. The returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values.") (((|List| $) $) "\\spad{zerosOf(p)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}. The \\spad{yi}'s are expressed in radicals if possible. The returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable.")) (|zeroOf| (($ $ (|Symbol|)) "\\spad{zeroOf(p, y)} returns \\spad{y} such that \\spad{p(y) = 0}. The value \\spad{y} is expressed in terms of radicals if possible,{}and otherwise as an implicit algebraic quantity which displays as \\spad{'y}.") (($ $) "\\spad{zeroOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. The value \\spad{y} is expressed in terms of radicals if possible,{}and otherwise as an implicit algebraic quantity. Error: if \\spad{p} has more than one variable.")) (|rootsOf| (((|List| $) $ (|Symbol|)) "\\spad{rootsOf(p, y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}; The returned roots display as \\spad{'y1},{}...,{}\\spad{'yn}. Note: the returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values.") (((|List| $) $) "\\spad{rootsOf(p, y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}; Note: the returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable \\spad{y}.")) (|rootOf| (($ $ (|Symbol|)) "\\spad{rootOf(p,y)} returns \\spad{y} such that \\spad{p(y) = 0}. The object returned displays as \\spad{'y}.") (($ $) "\\spad{rootOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. Error: if \\spad{p} has more than one variable \\spad{y}."))) 
@@ -46,7 +46,7 @@ NIL
 NIL 
 (|AlgebraicallyClosedFunctionSpace| R) 
 ((|constructor| (NIL "Model for algebraically closed function spaces.")) (|zerosOf| (((|List| $) $ (|Symbol|)) "\\spad{zerosOf(p, y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}. The \\spad{yi}'s are expressed in radicals if possible,{} and otherwise as implicit algebraic quantities which display as \\spad{'yi}. The returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values.") (((|List| $) $) "\\spad{zerosOf(p)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}. The \\spad{yi}'s are expressed in radicals if possible. The returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable.")) (|zeroOf| (($ $ (|Symbol|)) "\\spad{zeroOf(p, y)} returns \\spad{y} such that \\spad{p(y) = 0}. The value \\spad{y} is expressed in terms of radicals if possible,{}and otherwise as an implicit algebraic quantity which displays as \\spad{'y}.") (($ $) "\\spad{zeroOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. The value \\spad{y} is expressed in terms of radicals if possible,{}and otherwise as an implicit algebraic quantity. Error: if \\spad{p} has more than one variable.")) (|rootsOf| (((|List| $) $ (|Symbol|)) "\\spad{rootsOf(p, y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}; The returned roots display as \\spad{'y1},{}...,{}\\spad{'yn}. Note: the returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values.") (((|List| $) $) "\\spad{rootsOf(p, y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}; Note: the returned symbols \\spad{y1},{}...,{}yn are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable \\spad{y}.")) (|rootOf| (($ $ (|Symbol|)) "\\spad{rootOf(p,y)} returns \\spad{y} such that \\spad{p(y) = 0}. The object returned displays as \\spad{'y}.") (($ $) "\\spad{rootOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. Error: if \\spad{p} has more than one variable \\spad{y}."))) 
-((|unitsKnown| . T) (|leftUnitary| . T) (|rightUnitary| . T) ((|commutative| "*") . T) (|noZeroDivisors| . T) (|canonicalUnitNormal| . T) (|canonicalsClosed| . T)) 
+(((|commutative| "*") . T) (|noZeroDivisors| . T) (|canonicalUnitNormal| . T)) 
 NIL 
 (|PlaneAlgebraicCurvePlot|) 
 ((|refine| (($ $ (|DoubleFloat|)) "\\spad{refine(p,x)} \\undocumented{}")) (|makeSketch| (($ (|Polynomial| (|Integer|)) (|Symbol|) (|Symbol|) (|Segment| (|Fraction| (|Integer|))) (|Segment| (|Fraction| (|Integer|)))) "\\spad{makeSketch(p,x,y,a..b,c..d)} creates an ACPLOT of the curve \\spad{p = 0} in the region {\\em a <= x <= b, c <= y <= d}. More specifically,{} 'makeSketch' plots a non-singular algebraic curve \\spad{p = 0} in an rectangular region {\\em xMin <= x <= xMax},{} {\\em yMin <= y <= yMax}. The user inputs \\spad{makeSketch(p,x,y,xMin..xMax,yMin..yMax)}. Here \\spad{p} is a polynomial in the variables \\spad{x} and \\spad{y} with integer coefficients (\\spad{p} belongs to the domain \\spad{Polynomial Integer}). The case where \\spad{p} is a polynomial in only one of the variables is allowed. The variables \\spad{x} and \\spad{y} are input to specify the the coordinate axes. The horizontal axis is the \\spad{x}-axis and the vertical axis is the \\spad{y}-axis. The rational numbers xMin,{}...,{}yMax specify the boundaries of the region in which the curve is to be plotted."))) 
@@ -82,7 +82,7 @@ NIL
 NIL 
 (|Algebra| R) 
 ((|constructor| (NIL "The category of associative algebras (modules which are themselves rings). \\blankline"))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 NIL 
 (|AlgFactor| UP) 
 ((|constructor| (NIL "Factorization of univariate polynomials with coefficients in \\spadtype{AlgebraicNumber}.")) (|doublyTransitive?| (((|Boolean|) |#1|) "\\spad{doublyTransitive?(p)} is \\spad{true} if \\spad{p} is irreducible over over the field \\spad{K} generated by its coefficients,{} and if \\spad{p(X) / (X - a)} is irreducible over \\spad{K(a)} where \\spad{p(a) = 0}.")) (|split| (((|Factored| |#1|) |#1|) "\\spad{split(p)} returns a prime factorisation of \\spad{p} over its splitting field.")) (|factor| (((|Factored| |#1|) |#1|) "\\spad{factor(p)} returns a prime factorisation of \\spad{p} over the field generated by its coefficients.") (((|Factored| |#1|) |#1| (|List| (|AlgebraicNumber|))) "\\spad{factor(p, [a1,...,an])} returns a prime factorisation of \\spad{p} over the field generated by its coefficients and \\spad{a1},{}...,{}an."))) 
@@ -90,8 +90,8 @@ NIL
 NIL 
 (|AlgebraicFunctionField| F UP UPUP |modulus|) 
 ((|constructor| (NIL "Function field defined by \\spad{f}(\\spad{x},{} \\spad{y}) = 0.")) (|knownInfBasis| (((|Void|) (|NonNegativeInteger|)) "\\spad{knownInfBasis(n)} \\undocumented{}"))) 
-((|noZeroDivisors| |has| #1=(|Fraction| |#2|) . #2=((|Field|))) (|canonicalUnitNormal| |has| #1# . #2#) (|canonicalsClosed| |has| #1# . #2#) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-((|HasCategory| #1=(|Fraction| |#2|) (QUOTE (|CharacteristicNonZero|))) (|HasCategory| #1# (QUOTE (|CharacteristicZero|))) #2=(|HasCategory| #1# (QUOTE (|FiniteFieldCategory|))) (OR #3=(|HasCategory| #1# #4=(QUOTE (|Field|))) #2#) #3# (|HasCategory| #1# #5=(QUOTE (|Finite|))) (OR #6=(AND (|HasCategory| #1# (QUOTE (|DifferentialRing|))) #3#) #2#) (OR #6# #7=(AND (|HasCategory| #1# (QUOTE (|DifferentialSpace|))) #3#) #2#) (OR #8=(AND #3# #9=(|HasCategory| #1# (QUOTE (|PartialDifferentialRing| #10=(|Symbol|))))) (AND #2# #9#)) (OR #8# #11=(AND #3# (|HasCategory| #1# (QUOTE (|PartialDifferentialSpace| #10#))))) (|HasCategory| #1# (QUOTE (|LinearlyExplicitRingOver| #12=(|Integer|)))) (OR #3# #13=(|HasCategory| #1# (QUOTE (|RetractableTo| (|Fraction| #12#))))) #13# (|HasCategory| #1# (QUOTE (|RetractableTo| #12#))) (|HasCategory| |#1| #4#) (|HasCategory| |#1| #5#) #7# #11# #6# #8#) 
+((|noZeroDivisors| |has| #1=(|Fraction| |#2|) . #2=((|Field|))) (|canonicalUnitNormal| |has| #1# . #2#) ((|commutative| "*") . T)) 
+((|HasCategory| #1=(|Fraction| |#2|) (QUOTE (|CharacteristicNonZero|))) (|HasCategory| #1# (QUOTE (|CharacteristicZero|))) #2=(|HasCategory| #1# (QUOTE (|FiniteFieldCategory|))) (OR #3=(|HasCategory| #1# #4=(QUOTE (|Field|))) #2#) #3# (|HasCategory| #1# #5=(QUOTE (|Finite|))) (OR #6=(AND (|HasCategory| #1# (QUOTE (|DifferentialRing|))) #3#) #2#) (OR #6# #7=(AND (|HasCategory| #1# (QUOTE (|DifferentialSpace|))) #3#) #2#) (OR #8=(AND #3# #9=(|HasCategory| #1# (QUOTE (|PartialDifferentialRing| #10=(|Symbol|))))) (AND #2# #9#)) (OR #8# #11=(AND #3# (|HasCategory| #1# (QUOTE (|PartialDifferentialSpace| #10#))))) (|HasCategory| #1# (QUOTE (|LinearlyExplicitRingOver| #12=(|Integer|)))) (OR #3# #13=(|HasCategory| #1# (QUOTE (|RetractableTo| (|Fraction| #12#))))) #13# (|HasCategory| #1# (QUOTE (|RetractableTo| #12#))) (|HasCategory| |#1| #4#) (|HasCategory| |#1| #5#) #11# #7# #6# #8#) 
 (|AlgebraicManipulations| R F) 
 ((|constructor| (NIL "AlgebraicManipulations provides functions to simplify and expand expressions involving algebraic operators.")) (|rootKerSimp| ((|#2| (|BasicOperator|) |#2| (|NonNegativeInteger|)) "\\spad{rootKerSimp(op,f,n)} should be local but conditional.")) (|rootSimp| ((|#2| |#2|) "\\spad{rootSimp(f)} transforms every radical of the form \\spad{(a * b**(q*n+r))**(1/n)} appearing in \\spad{f} into \\spad{b**q * (a * b**r)**(1/n)}. This transformation is not in general valid for all complex numbers \\spad{b}.")) (|rootProduct| ((|#2| |#2|) "\\spad{rootProduct(f)} combines every product of the form \\spad{(a**(1/n))**m * (a**(1/s))**t} into a single power of a root of \\spad{a},{} and transforms every radical power of the form \\spad{(a**(1/n))**m} into a simpler form.")) (|rootPower| ((|#2| |#2|) "\\spad{rootPower(f)} transforms every radical power of the form \\spad{(a**(1/n))**m} into a simpler form if \\spad{m} and \\spad{n} have a common factor.")) (|ratPoly| (((|SparseUnivariatePolynomial| |#2|) |#2|) "\\spad{ratPoly(f)} returns a polynomial \\spad{p} such that \\spad{p} has no algebraic coefficients,{} and \\spad{p(f) = 0}.")) (|ratDenom| ((|#2| |#2| (|List| (|Kernel| |#2|))) "\\spad{ratDenom(f, [a1,...,an])} removes the \\spad{ai}'s which are algebraic from the denominators in \\spad{f}.") ((|#2| |#2| (|List| |#2|)) "\\spad{ratDenom(f, [a1,...,an])} removes the \\spad{ai}'s which are algebraic kernels from the denominators in \\spad{f}.") ((|#2| |#2| |#2|) "\\spad{ratDenom(f, a)} removes \\spad{a} from the denominators in \\spad{f} if \\spad{a} is an algebraic kernel.") ((|#2| |#2|) "\\spad{ratDenom(f)} rationalizes the denominators appearing in \\spad{f} by moving all the algebraic quantities into the numerators.")) (|rootSplit| ((|#2| |#2|) "\\spad{rootSplit(f)} transforms every radical of the form \\spad{(a/b)**(1/n)} appearing in \\spad{f} into \\spad{a**(1/n) / b**(1/n)}. This transformation is not in general valid for all complex numbers \\spad{a} and \\spad{b}.")) (|coerce| (($ (|SparseMultivariatePolynomial| |#1| (|Kernel| $))) "\\spad{coerce(x)} \\undocumented")) (|denom| (((|SparseMultivariatePolynomial| |#1| (|Kernel| $)) $) "\\spad{denom(x)} \\undocumented")) (|numer| (((|SparseMultivariatePolynomial| |#1| (|Kernel| $)) $) "\\spad{numer(x)} \\undocumented"))) 
 NIL 
@@ -106,8 +106,8 @@ NIL
 ((|HasCategory| |#1| (QUOTE (|EuclideanDomain|)))) 
 (|AlgebraGivenByStructuralConstants| R |n| |ls| |gamma|) 
 ((|constructor| (NIL "AlgebraGivenByStructuralConstants implements finite rank algebras over a commutative ring,{} given by the structural constants \\spad{gamma} with respect to a fixed basis \\spad{[a1,..,an]},{} where \\spad{gamma} is an \\spad{n}-vector of \\spad{n} by \\spad{n} matrices \\spad{[(gammaijk) for k in 1..rank()]} defined by \\spad{ai * aj = gammaij1 * a1 + ... + gammaijn * an}. The symbols for the fixed basis have to be given as a list of symbols.")) (|coerce| (($ (|Vector| |#1|)) "\\spad{coerce(v)} converts a vector to a member of the algebra by forming a linear combination with the basis element. Note: the vector is assumed to have length equal to the dimension of the algebra."))) 
-((|unitsKnown| |has| |#1| (|IntegralDomain|)) (|leftUnitary| . T) (|rightUnitary| . T)) 
-((|HasCategory| |#1| (QUOTE (|Field|))) (|HasCategory| |#1| (QUOTE (|IntegralDomain|)))) 
+NIL 
+((|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (|HasCategory| |#1| (QUOTE (|Field|)))) 
 (|AssociationList| |Key| |Entry|) 
 ((|constructor| (NIL "\\spadtype{AssociationList} implements association lists. These may be viewed as lists of pairs where the first part is a key and the second is the stored value. For example,{} the key might be a string with a persons employee identification number and the value might be a record with personnel data."))) 
 NIL 
@@ -118,11 +118,11 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|Algebra| (|Fraction| (|Integer|))))) (|HasCategory| |#2| (QUOTE (|IntegralDomain|))) (|HasCategory| |#2| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|CommutativeRing|))) (|HasCategory| |#2| (QUOTE (|Field|)))) 
 (|AbelianMonoidRing| R E) 
 ((|constructor| (NIL "Abelian monoid ring elements (not necessarily of finite support) of this ring are of the form formal SUM (r_i * e_i) where the r_i are coefficents and the e_i,{} elements of the ordered abelian monoid,{} are thought of as exponents or monomials. The monomials commute with each other,{} and with the coefficients (which themselves may or may not be commutative). See \\spadtype{FiniteAbelianMonoidRing} for the case of finite support a useful common model for polynomials and power series. Conceptually at least,{} only the non-zero terms are ever operated on.")) (/ (($ $ |#1|) "\\spad{p/c} divides \\spad{p} by the coefficient \\spad{c}.")) (|coefficient| ((|#1| $ |#2|) "\\spad{coefficient(p,e)} extracts the coefficient of the monomial with exponent \\spad{e} from polynomial \\spad{p},{} or returns zero if exponent is not present.")) (|reductum| (($ $) "\\spad{reductum(u)} returns \\spad{u} minus its leading monomial returns zero if handed the zero element.")) (|monomial| (($ |#1| |#2|) "\\spad{monomial(r,e)} makes a term from a coefficient \\spad{r} and an exponent \\spad{e}.")) (|monomial?| (((|Boolean|) $) "\\spad{monomial?(p)} tests if \\spad{p} is a single monomial.")) (|degree| ((|#2| $) "\\spad{degree(p)} returns the maximum of the exponents of the terms of \\spad{p}.")) (|leadingMonomial| (($ $) "\\spad{leadingMonomial(p)} returns the monomial of \\spad{p} with the highest degree.")) (|leadingCoefficient| ((|#1| $) "\\spad{leadingCoefficient(p)} returns the coefficient highest degree term of \\spad{p}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|))) 
 NIL 
 (|AlgebraicNumber|) 
 ((|constructor| (NIL "Algebraic closure of the rational numbers,{} with mathematical =")) (|norm| (($ $ (|List| (|Kernel| $))) "\\spad{norm(f,l)} computes the norm of the algebraic number \\spad{f} with respect to the extension generated by kernels \\spad{l}") (($ $ (|Kernel| $)) "\\spad{norm(f,k)} computes the norm of the algebraic number \\spad{f} with respect to the extension generated by kernel \\spad{k}") (((|SparseUnivariatePolynomial| $) (|SparseUnivariatePolynomial| $) (|List| (|Kernel| $))) "\\spad{norm(p,l)} computes the norm of the polynomial \\spad{p} with respect to the extension generated by kernels \\spad{l}") (((|SparseUnivariatePolynomial| $) (|SparseUnivariatePolynomial| $) (|Kernel| $)) "\\spad{norm(p,k)} computes the norm of the polynomial \\spad{p} with respect to the extension generated by kernel \\spad{k}")) (|reduce| (($ $) "\\spad{reduce(f)} simplifies all the unreduced algebraic numbers present in \\spad{f} by applying their defining relations.")) (|denom| (((|SparseMultivariatePolynomial| (|Integer|) (|Kernel| $)) $) "\\spad{denom(f)} returns the denominator of \\spad{f} viewed as a polynomial in the kernels over \\spad{Z}.")) (|numer| (((|SparseMultivariatePolynomial| (|Integer|) (|Kernel| $)) $) "\\spad{numer(f)} returns the numerator of \\spad{f} viewed as a polynomial in the kernels over \\spad{Z}."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((|HasCategory| $ (QUOTE (|Ring|))) (|HasCategory| $ (QUOTE (|RetractableTo| (|Integer|))))) 
 (|AnonymousFunction|) 
 ((|constructor| (NIL "This domain implements anonymous functions")) (|body| (((|Syntax|) $) "\\spad{body(f)} returns the body of the unnamed function `f'.")) (|parameters| (((|List| (|Identifier|)) $) "\\spad{parameters(f)} returns the list of parameters bound by `f'."))) 
@@ -130,7 +130,7 @@ NIL
 NIL 
 (|AntiSymm| R |lVar|) 
 ((|constructor| (NIL "The domain of antisymmetric polynomials.")) (|degree| (((|NonNegativeInteger|) $) "\\spad{degree(p)} returns the homogeneous degree of \\spad{p}.")) (|retractable?| (((|Boolean|) $) "\\spad{retractable?(p)} tests if \\spad{p} is a 0-form,{} \\spadignore{i.e.} if degree(\\spad{p}) = 0.")) (|homogeneous?| (((|Boolean|) $) "\\spad{homogeneous?(p)} tests if all of the terms of \\spad{p} have the same degree.")) (|exp| (($ (|List| (|Integer|))) "\\spad{exp([i1,...in])} returns \\spad{u_1\\^{i_1} ... u_n\\^{i_n}}")) (|generator| (($ (|NonNegativeInteger|)) "\\spad{generator(n)} returns the \\spad{n}th multiplicative generator,{} a basis term.")) (|coefficient| ((|#1| $ $) "\\spad{coefficient(p,u)} returns the coefficient of the term in \\spad{p} containing the basis term \\spad{u} if such a term exists,{} and 0 otherwise. Error: if the second argument \\spad{u} is not a basis element.")) (|reductum| (($ $) "\\spad{reductum(p)},{} where \\spad{p} is an antisymmetric polynomial,{} returns \\spad{p} minus the leading term of \\spad{p} if \\spad{p} has at least two terms,{} and 0 otherwise.")) (|leadingBasisTerm| (($ $) "\\spad{leadingBasisTerm(p)} returns the leading basis term of antisymmetric polynomial \\spad{p}.")) (|leadingCoefficient| ((|#1| $) "\\spad{leadingCoefficient(p)} returns the leading coefficient of antisymmetric polynomial \\spad{p}."))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|Any|) 
 ((|constructor| (NIL "\\spadtype{Any} implements a type that packages up objects and their types in objects of \\spadtype{Any}. Roughly speaking that means that if \\spad{s : S} then when converted to \\spadtype{Any},{} the new object will include both the original object and its type. This is a way of converting arbitrary objects into a single type without losing any of the original information. Any object can be converted to one of \\spadtype{Any}. The original object can be recovered by `is-case' pattern matching as exemplified here and \\spad{AnyFunctions1}.")) (|obj| (((|None|) $) "\\spad{obj(a)} essentially returns the original object that was converted to \\spadtype{Any} except that the type is forced to be \\spadtype{None}.")) (|dom| (((|SExpression|) $) "\\spad{dom(a)} returns a \\spadgloss{LISP} form of the type of the original object that was converted to \\spadtype{Any}.")) (|any| (($ (|SExpression|) (|None|)) "\\spad{any(type,object)} is a technical function for creating an \\spad{object} of \\spadtype{Any}. Arugment \\spad{type} is a \\spadgloss{LISP} form for the \\spad{type} of \\spad{object}."))) 
@@ -201,12 +201,12 @@ NIL
 NIL 
 NIL 
 (|AttributeRegistry|) 
-((|constructor| (NIL "This category exports the attributes in the AXIOM Library")) (|canonical| ((|attribute|) "\\spad{canonical} is \\spad{true} if and only if distinct elements have distinct data structures. For example,{} a domain of mathematical objects which has the \\spad{canonical} attribute means that two objects are mathematically equal if and only if their data structures are equal.")) (|multiplicativeValuation| ((|attribute|) "\\spad{multiplicativeValuation} implies \\spad{euclideanSize(a*b)=euclideanSize(a)*euclideanSize(b)}.")) (|additiveValuation| ((|attribute|) "\\spad{additiveValuation} implies \\spad{euclideanSize(a*b)=euclideanSize(a)+euclideanSize(b)}.")) (|noetherian| ((|attribute|) "\\spad{noetherian} is \\spad{true} if all of its ideals are finitely generated.")) (|central| ((|attribute|) "\\spad{central} is \\spad{true} if,{} given an algebra over a ring \\spad{R},{} the image of \\spad{R} is the center of the algebra,{} \\spadignore{i.e.} the set of members of the algebra which commute with all others is precisely the image of \\spad{R} in the algebra.")) (|partiallyOrderedSet| ((|attribute|) "\\spad{partiallyOrderedSet} is \\spad{true} if a set with \\spadop{<} which is transitive,{} but \\spad{not(a < b or a = b)} does not necessarily imply \\spad{b<a}.")) (|arbitraryPrecision| ((|attribute|) "\\spad{arbitraryPrecision} means the user can set the precision for subsequent calculations.")) (|canonicalsClosed| ((|attribute|) "\\spad{canonicalsClosed} is \\spad{true} if \\spad{unitCanonical(a)*unitCanonical(b) = unitCanonical(a*b)}.")) (|canonicalUnitNormal| ((|attribute|) "\\spad{canonicalUnitNormal} is \\spad{true} if we can choose a canonical representative for each class of associate elements,{} that is \\spad{associates?(a,b)} returns \\spad{true} if and only if \\spad{unitCanonical(a) = unitCanonical(b)}.")) (|noZeroDivisors| ((|attribute|) "\\spad{noZeroDivisors} is \\spad{true} if \\spad{x * y \\~~= 0} implies both \\spad{x} and \\spad{y} are non-zero.")) (|rightUnitary| ((|attribute|) "\\spad{rightUnitary} is \\spad{true} if \\spad{x * 1 = x} for all \\spad{x}.")) (|leftUnitary| ((|attribute|) "\\spad{leftUnitary} is \\spad{true} if \\spad{1 * x = x} for all \\spad{x}.")) (|unitsKnown| ((|attribute|) "\\spad{unitsKnown} is \\spad{true} if a monoid (a multiplicative semigroup with a 1) has \\spad{unitsKnown} means that the operation \\spadfun{recip} can only return \"failed\" if its argument is not a unit.")) (|commutative| ((|attribute| "*") "\\spad{commutative(\"*\")} is \\spad{true} if it has an operation \\spad{\"*\": (D,D) -> D} which is commutative."))) 
-(((|commutative| "*") . T) (|unitsKnown| . T) (|leftUnitary| . T) (|rightUnitary| . T) (|noZeroDivisors| . T) (|canonicalUnitNormal| . T) (|canonicalsClosed| . T) (|arbitraryPrecision| . T) (|partiallyOrderedSet| . T) (|central| . T) (|noetherian| . T) (|additiveValuation| . T) (|multiplicativeValuation| . T) (|NullSquare| . T) (|JacobiIdentity| . T) (|canonical| . T)) 
+((|constructor| (NIL "This category exports the attributes in the AXIOM Library")) (|canonical| ((|attribute|) "\\spad{canonical} is \\spad{true} if and only if distinct elements have distinct data structures. For example,{} a domain of mathematical objects which has the \\spad{canonical} attribute means that two objects are mathematically equal if and only if their data structures are equal.")) (|multiplicativeValuation| ((|attribute|) "\\spad{multiplicativeValuation} implies \\spad{euclideanSize(a*b)=euclideanSize(a)*euclideanSize(b)}.")) (|additiveValuation| ((|attribute|) "\\spad{additiveValuation} implies \\spad{euclideanSize(a*b)=euclideanSize(a)+euclideanSize(b)}.")) (|partiallyOrderedSet| ((|attribute|) "\\spad{partiallyOrderedSet} is \\spad{true} if a set with \\spadop{<} which is transitive,{} but \\spad{not(a < b or a = b)} does not necessarily imply \\spad{b<a}.")) (|canonicalUnitNormal| ((|attribute|) "\\spad{canonicalUnitNormal} is \\spad{true} if we can choose a canonical representative for each class of associate elements,{} that is \\spad{associates?(a,b)} returns \\spad{true} if and only if \\spad{unitCanonical(a) = unitCanonical(b)}.")) (|noZeroDivisors| ((|attribute|) "\\spad{noZeroDivisors} is \\spad{true} if \\spad{x * y \\~~= 0} implies both \\spad{x} and \\spad{y} are non-zero.")) (|commutative| ((|attribute| "*") "\\spad{commutative(\"*\")} is \\spad{true} if it has an operation \\spad{\"*\": (D,D) -> D} which is commutative."))) 
+(((|commutative| "*") . T) (|noZeroDivisors| . T) (|canonicalUnitNormal| . T) (|partiallyOrderedSet| . T) (|additiveValuation| . T) (|multiplicativeValuation| . T) (|canonical| . T)) 
 NIL 
 (|Automorphism| R) 
 ((|constructor| (NIL "Automorphism \\spad{R} is the multiplicative group of automorphisms of \\spad{R}.")) (|morphism| (($ (|Mapping| |#1| |#1| (|Integer|))) "\\spad{morphism(f)} returns the morphism given by \\spad{f^n(x) = f(x,n)}.") (($ (|Mapping| |#1| |#1|) (|Mapping| |#1| |#1|)) "\\spad{morphism(f, g)} returns the invertible morphism given by \\spad{f},{} where \\spad{g} is the inverse of \\spad{f}..") (($ (|Mapping| |#1| |#1|)) "\\spad{morphism(f)} returns the non-invertible morphism given by \\spad{f}."))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|BalancedFactorisation| R UP) 
 ((|constructor| (NIL "This package provides balanced factorisations of polynomials.")) (|balancedFactorisation| (((|Factored| |#2|) |#2| (|List| |#2|)) "\\spad{balancedFactorisation(a, [b1,...,bn])} returns a factorisation \\spad{a = p1^e1 ... pm^em} such that each \\spad{pi} is balanced with respect to \\spad{[b1,...,bm]}.") (((|Factored| |#2|) |#2| |#2|) "\\spad{balancedFactorisation(a, b)} returns a factorisation \\spad{a = p1^e1 ... pm^em} such that each \\spad{pi} is balanced with respect to \\spad{b}."))) 
@@ -238,8 +238,8 @@ NIL
 NIL 
 (|BinaryExpansion|) 
 ((|constructor| (NIL "This domain allows rational numbers to be presented as repeating binary expansions.")) (|binary| (($ (|Fraction| (|Integer|))) "\\spad{binary(r)} converts a rational number to a binary expansion.")) (|fractionPart| (((|Fraction| (|Integer|)) $) "\\spad{fractionPart(b)} returns the fractional part of a binary expansion."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| #2=(|Integer|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #2#))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #2#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #2#)))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (QUOTE (|InnerEvalable| #3# #2#))) (|HasCategory| #2# (QUOTE (|Evalable| #2#))) (|HasCategory| #2# (QUOTE (|Eltable| #2# #2#))) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #2#))) #9=(AND (|HasCategory| $ #5#) #1#) (OR #9# #4#)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
+(#1=(|HasCategory| #2=(|Integer|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #2#))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #2#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #2#)))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (QUOTE (|InnerEvalable| #3# #2#))) (|HasCategory| #2# (QUOTE (|Evalable| #2#))) (|HasCategory| #2# (QUOTE (|Eltable| #2# #2#))) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #2#))) #9=(AND (|HasCategory| $ #5#) #1#) (OR #9# #4#)) 
 (|Binding|) 
 ((|constructor| (NIL "\\indented{1}{Author: Gabriel Dos Reis} Date Created: October 24,{} 2007 Date Last Modified: January 18,{} 2008. A `Binding' is a name asosciated with a collection of properties.")) (|binding| (($ (|Identifier|) (|List| (|Property|))) "\\spad{binding(n,props)} constructs a binding with name `n' and property list `props'.")) (|properties| (((|List| (|Property|)) $) "\\spad{properties(b)} returns the properties associated with binding \\spad{b}.")) (|name| (((|Identifier|) $) "\\spad{name(b)} returns the name of binding \\spad{b}"))) 
 NIL 
@@ -257,8 +257,8 @@ NIL
 NIL 
 ((AND (|HasCategory| #1=(|Boolean|) (QUOTE (|Evalable| #1#))) #2=(|HasCategory| #1# (QUOTE (|SetCategory|)))) (|HasCategory| #1# (QUOTE (|ConvertibleTo| (|InputForm|)))) #3=(|HasCategory| #1# #4=(QUOTE (|OrderedSet|))) (|HasCategory| (|Integer|) #4#) #5=(|HasCategory| #1# (QUOTE (|BasicType|))) (|HasCategory| #1# (QUOTE (|CoercibleTo| (|OutputForm|)))) #2# (AND #6=(|HasCategory| $ (QUOTE (|ShallowlyMutableAggregate| #1#))) #3#) #7=(|HasCategory| $ (QUOTE (|FiniteAggregate| #1#))) (AND #7# #5#) #6#) 
 (|BiModule| R S) 
-((|constructor| (NIL "A \\spadtype{BiModule} is both a left and right module with respect to potentially different rings. \\blankline")) (|rightUnitary| ((|attribute|) "\\spad{x * 1 = x}")) (|leftUnitary| ((|attribute|) "\\spad{1 * x = x}"))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+((|constructor| (NIL "A \\spadtype{BiModule} is both a left and right module with respect to potentially different rings. \\blankline"))) 
+NIL 
 NIL 
 (|BooleanLogic&| S) 
 ((|constructor| (NIL "This is the category of Boolean logic structures.")) (|or| (($ $ $) "\\spad{x or y} returns the disjunction of \\spad{x} and \\spad{y}.")) (|and| (($ $ $) "\\spad{x and y} returns the conjunction of \\spad{x} and \\spad{y}.")) (|not| (($ $) "\\spad{not x} returns the complement or negation of \\spad{x}."))) 
@@ -286,12 +286,12 @@ NIL
 NIL 
 (|BalancedPAdicInteger| |p|) 
 ((|constructor| (NIL "Stream-based implementation of Zp: \\spad{p}-adic numbers are represented as sum(\\spad{i} = 0..,{} a[\\spad{i}] * p^i),{} where the a[\\spad{i}] lie in -(\\spad{p} - 1)\\spad{/2},{}...,{}(\\spad{p} - 1)\\spad{/2}."))) 
-((|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|BalancedPAdicRational| |p|) 
 ((|constructor| (NIL "Stream-based implementation of Qp: numbers are represented as sum(\\spad{i} = \\spad{k}..,{} a[\\spad{i}] * p^i),{} where the a[\\spad{i}] lie in -(\\spad{p} - 1)\\spad{/2},{}...,{}(\\spad{p} - 1)\\spad{/2}."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| #2=(|BalancedPAdicInteger| |#1|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #8=(|Integer|)))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #9=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #8#))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (|%list| (QUOTE |InnerEvalable|) (QUOTE #3#) #10=(|%list| (QUOTE |BalancedPAdicInteger|) (|devaluate| |#1|)))) (|HasCategory| #2# (|%list| (QUOTE |Evalable|) #10#)) (|HasCategory| #2# (|%list| (QUOTE |Eltable|) #10# #10#)) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) #11=(AND (|HasCategory| $ #5#) #1#) (OR #11# #4#)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
+(#1=(|HasCategory| #2=(|BalancedPAdicInteger| |#1|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #8=(|Integer|)))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #9=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #8#))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (|%list| (QUOTE |InnerEvalable|) (QUOTE #3#) #10=(|%list| (QUOTE |BalancedPAdicInteger|) (|devaluate| |#1|)))) (|HasCategory| #2# (|%list| (QUOTE |Evalable|) #10#)) (|HasCategory| #2# (|%list| (QUOTE |Eltable|) #10# #10#)) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) #11=(AND (|HasCategory| $ #5#) #1#) (OR #11# #4#)) 
 (|BinaryRecursiveAggregate&| A S) 
 ((|constructor| (NIL "A binary-recursive aggregate has 0,{} 1 or 2 children and serves as a model for a binary tree or a doubly-linked aggregate structure")) (|setright!| (($ $ $) "\\spad{setright!(a,x)} sets the right child of \\spad{t} to be \\spad{x}.")) (|setleft!| (($ $ $) "\\spad{setleft!(a,b)} sets the left child of \\axiom{a} to be \\spad{b}.")) (|setelt| (($ $ "right" $) "\\spad{setelt(a,\"right\",b)} (also written \\axiom{\\spad{b} . right := \\spad{b}}) is equivalent to \\axiom{setright!(a,{}\\spad{b})}.") (($ $ "left" $) "\\spad{setelt(a,\"left\",b)} (also written \\axiom{a . left := \\spad{b}}) is equivalent to \\axiom{setleft!(a,{}\\spad{b})}.")) (|right| (($ $) "\\spad{right(a)} returns the right child.")) (|elt| (($ $ "right") "\\spad{elt(a,\"right\")} (also written: \\axiom{a . right}) is equivalent to \\axiom{right(a)}.") (($ $ "left") "\\spad{elt(u,\"left\")} (also written: \\axiom{a . left}) is equivalent to \\axiom{left(a)}.")) (|left| (($ $) "\\spad{left(u)} returns the left child."))) 
 NIL 
@@ -345,7 +345,7 @@ NIL
 NIL 
 NIL 
 (|CancellationAbelianMonoid|) 
-((|constructor| (NIL "This is an \\spadtype{AbelianMonoid} with the cancellation property,{} \\spadignore{i.e.} \\spad{ a+b = a+c => b=c }. This is formalised by the partial subtraction operator,{} which satisfies the axioms listed below: \\blankline")) (|subtractIfCan| (((|Union| $ "failed") $ $) "\\spad{subtractIfCan(x, y)} returns an element \\spad{z} such that \\spad{z+y=x} or \"failed\" if no such element exists."))) 
+((|constructor| (NIL "This is an \\spadtype{AbelianMonoid} with the cancellation property,{} \\spadignore{i.e.} \\spad{ a+b = a+c => b=c }. This is formalised by the partial subtraction operator,{} which satisfies the axioms listed below: \\blankline")) (|subtractIfCan| (((|Maybe| $) $ $) "\\spad{subtractIfCan(x, y)} returns an element \\spad{z} such that \\spad{z+y=x} or \\spad{nothing} if no such element exists."))) 
 NIL 
 NIL 
 (|CachableSet|) 
@@ -402,7 +402,7 @@ NIL
 NIL 
 (|CharacteristicNonZero|) 
 ((|constructor| (NIL "Rings of Characteristic Non Zero")) (|charthRoot| (((|Maybe| $) $) "\\spad{charthRoot(x)} returns the \\spad{p}th root of \\spad{x} where \\spad{p} is the characteristic of the ring."))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|CharacteristicPolynomialPackage| R) 
 ((|constructor| (NIL "This package provides a characteristicPolynomial function for any matrix over a commutative ring.")) (|characteristicPolynomial| ((|#1| (|Matrix| |#1|) |#1|) "\\spad{characteristicPolynomial(m,r)} computes the characteristic polynomial of the matrix \\spad{m} evaluated at the point \\spad{r}. In particular,{} if \\spad{r} is the polynomial 'x,{} then it returns the characteristic polynomial expressed as a polynomial in 'x."))) 
@@ -410,7 +410,7 @@ NIL
 NIL 
 (|CharacteristicZero|) 
 ((|constructor| (NIL "Rings of Characteristic Zero."))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|ChangeOfVariable| F UP UPUP) 
 ((|constructor| (NIL "Tools to send a point to infinity on an algebraic curve.")) (|chvar| (((|Record| (|:| |func| |#3|) (|:| |poly| |#3|) (|:| |c1| (|Fraction| |#2|)) (|:| |c2| (|Fraction| |#2|)) (|:| |deg| (|NonNegativeInteger|))) |#3| |#3|) "\\spad{chvar(f(x,y), p(x,y))} returns \\spad{[g(z,t), q(z,t), c1(z), c2(z), n]} such that under the change of variable \\spad{x = c1(z)},{} \\spad{y = t * c2(z)},{} one gets \\spad{f(x,y) = g(z,t)}. The algebraic relation between \\spad{x} and \\spad{y} is \\spad{p(x, y) = 0}. The algebraic relation between \\spad{z} and \\spad{t} is \\spad{q(z, t) = 0}.")) (|eval| ((|#3| |#3| (|Fraction| |#2|) (|Fraction| |#2|)) "\\spad{eval(p(x,y), f(x), g(x))} returns \\spad{p(f(x), y * g(x))}.")) (|goodPoint| ((|#1| |#3| |#3|) "\\spad{goodPoint(p, q)} returns an integer a such that a is neither a pole of \\spad{p(x,y)} nor a branch point of \\spad{q(x,y) = 0}.")) (|rootPoly| (((|Record| (|:| |exponent| (|NonNegativeInteger|)) (|:| |coef| (|Fraction| |#2|)) (|:| |radicand| |#2|)) (|Fraction| |#2|) (|NonNegativeInteger|)) "\\spad{rootPoly(g, n)} returns \\spad{[m, c, P]} such that \\spad{c * g ** (1/n) = P ** (1/m)} thus if \\spad{y**n = g},{} then \\spad{z**m = P} where \\spad{z = c * y}.")) (|radPoly| (((|Union| (|Record| (|:| |radicand| (|Fraction| |#2|)) (|:| |deg| (|NonNegativeInteger|))) "failed") |#3|) "\\spad{radPoly(p(x, y))} returns \\spad{[c(x), n]} if \\spad{p} is of the form \\spad{y**n - c(x)},{} \"failed\" otherwise.")) (|mkIntegral| (((|Record| (|:| |coef| (|Fraction| |#2|)) (|:| |poly| |#3|)) |#3|) "\\spad{mkIntegral(p(x,y))} returns \\spad{[c(x), q(x,z)]} such that \\spad{z = c * y} is integral. The algebraic relation between \\spad{x} and \\spad{y} is \\spad{p(x, y) = 0}. The algebraic relation between \\spad{x} and \\spad{z} is \\spad{q(x, z) = 0}."))) 
@@ -429,8 +429,8 @@ NIL
 NIL 
 NIL 
 (|CliffordAlgebra| |n| K Q) 
-((|constructor| (NIL "CliffordAlgebra(\\spad{n},{} \\spad{K},{} \\spad{Q}) defines a vector space of dimension \\spad{2**n} over \\spad{K},{} given a quadratic form \\spad{Q} on \\spad{K**n}. \\blankline If \\spad{e[i]},{} \\spad{1<=i<=n} is a basis for \\spad{K**n} then \\indented{3}{1,{} \\spad{e[i]} (\\spad{1<=i<=n}),{} \\spad{e[i1]*e[i2]}} (\\spad{1<=i1<i2<=n}),{}...,{}\\spad{e[1]*e[2]*..*e[n]} is a basis for the Clifford Algebra. \\blankline The algebra is defined by the relations \\indented{3}{\\spad{e[i]*e[j] = -e[j]*e[i]}\\space{2}(\\spad{i \\~~= j}),{}} \\indented{3}{\\spad{e[i]*e[i] = Q(e[i])}} \\blankline Examples of Clifford Algebras are: gaussians,{} quaternions,{} exterior algebras and spin algebras.")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(x)} computes the multiplicative inverse of \\spad{x} or \"failed\" if \\spad{x} is not invertible.")) (|coefficient| ((|#2| $ (|List| (|PositiveInteger|))) "\\spad{coefficient(x,[i1,i2,...,iN])} extracts the coefficient of \\spad{e(i1)*e(i2)*...*e(iN)} in \\spad{x}.")) (|monomial| (($ |#2| (|List| (|PositiveInteger|))) "\\spad{monomial(c,[i1,i2,...,iN])} produces the value given by \\spad{c*e(i1)*e(i2)*...*e(iN)}.")) (|e| (($ (|PositiveInteger|)) "\\spad{e(n)} produces the appropriate unit element."))) 
-((|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
+((|constructor| (NIL "CliffordAlgebra(\\spad{n},{} \\spad{K},{} \\spad{Q}) defines a vector space of dimension \\spad{2**n} over \\spad{K},{} given a quadratic form \\spad{Q} on \\spad{K**n}. \\blankline If \\spad{e[i]},{} \\spad{1<=i<=n} is a basis for \\spad{K**n} then \\indented{3}{1,{} \\spad{e[i]} (\\spad{1<=i<=n}),{} \\spad{e[i1]*e[i2]}} (\\spad{1<=i1<i2<=n}),{}...,{}\\spad{e[1]*e[2]*..*e[n]} is a basis for the Clifford Algebra. \\blankline The algebra is defined by the relations \\indented{3}{\\spad{e[i]*e[j] = -e[j]*e[i]}\\space{2}(\\spad{i \\~~= j}),{}} \\indented{3}{\\spad{e[i]*e[i] = Q(e[i])}} \\blankline Examples of Clifford Algebras are: gaussians,{} quaternions,{} exterior algebras and spin algebras.")) (|coefficient| ((|#2| $ (|List| (|PositiveInteger|))) "\\spad{coefficient(x,[i1,i2,...,iN])} extracts the coefficient of \\spad{e(i1)*e(i2)*...*e(iN)} in \\spad{x}.")) (|monomial| (($ |#2| (|List| (|PositiveInteger|))) "\\spad{monomial(c,[i1,i2,...,iN])} produces the value given by \\spad{c*e(i1)*e(i2)*...*e(iN)}.")) (|e| (($ (|PositiveInteger|)) "\\spad{e(n)} produces the appropriate unit element."))) 
+NIL 
 NIL 
 (|TwoDimensionalPlotClipping|) 
 ((|constructor| (NIL "\\indented{1}{The purpose of this package is to provide reasonable plots of} functions with singularities.")) (|clipWithRanges| (((|Record| (|:| |brans| (|List| (|List| (|Point| (|DoubleFloat|))))) (|:| |xValues| (|Segment| (|DoubleFloat|))) (|:| |yValues| (|Segment| (|DoubleFloat|)))) (|List| (|List| (|Point| (|DoubleFloat|)))) (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{clipWithRanges(pointLists,xMin,xMax,yMin,yMax)} performs clipping on a list of lists of points,{} \\spad{pointLists}. Clipping is done within the specified ranges of \\spad{xMin},{} \\spad{xMax} and \\spad{yMin},{} \\spad{yMax}. This function is used internally by the \\fakeAxiomFun{iClipParametric} subroutine in this package.")) (|clipParametric| (((|Record| (|:| |brans| (|List| (|List| (|Point| (|DoubleFloat|))))) (|:| |xValues| (|Segment| (|DoubleFloat|))) (|:| |yValues| (|Segment| (|DoubleFloat|)))) (|Plot|) (|Fraction| (|Integer|)) (|Fraction| (|Integer|))) "\\spad{clipParametric(p,frac,sc)} performs two-dimensional clipping on a plot,{} \\spad{p},{} from the domain \\spadtype{Plot} for the parametric curve \\spad{x = f(t)},{} \\spad{y = g(t)}; the fraction parameter is specified by \\spad{frac} and the scale parameter is specified by \\spad{sc} for use in the \\fakeAxiomFun{iClipParametric} subroutine,{} which is called by this function.") (((|Record| (|:| |brans| (|List| (|List| (|Point| (|DoubleFloat|))))) (|:| |xValues| (|Segment| (|DoubleFloat|))) (|:| |yValues| (|Segment| (|DoubleFloat|)))) (|Plot|)) "\\spad{clipParametric(p)} performs two-dimensional clipping on a plot,{} \\spad{p},{} from the domain \\spadtype{Plot} for the parametric curve \\spad{x = f(t)},{} \\spad{y = g(t)}; the default parameters \\spad{1/2} for the fraction and \\spad{5/1} for the scale are used in the \\fakeAxiomFun{iClipParametric} subroutine,{} which is called by this function.")) (|clip| (((|Record| (|:| |brans| (|List| (|List| (|Point| (|DoubleFloat|))))) (|:| |xValues| (|Segment| (|DoubleFloat|))) (|:| |yValues| (|Segment| (|DoubleFloat|)))) (|List| (|List| (|Point| (|DoubleFloat|))))) "\\spad{clip(ll)} performs two-dimensional clipping on a list of lists of points,{} \\spad{ll}; the default parameters \\spad{1/2} for the fraction and \\spad{5/1} for the scale are used in the \\fakeAxiomFun{iClipParametric} subroutine,{} which is called by this function.") (((|Record| (|:| |brans| (|List| (|List| (|Point| (|DoubleFloat|))))) (|:| |xValues| (|Segment| (|DoubleFloat|))) (|:| |yValues| (|Segment| (|DoubleFloat|)))) (|List| (|Point| (|DoubleFloat|)))) "\\spad{clip(l)} performs two-dimensional clipping on a curve \\spad{l},{} which is a list of points; the default parameters \\spad{1/2} for the fraction and \\spad{5/1} for the scale are used in the \\fakeAxiomFun{iClipParametric} subroutine,{} which is called by this function.") (((|Record| (|:| |brans| (|List| (|List| (|Point| (|DoubleFloat|))))) (|:| |xValues| (|Segment| (|DoubleFloat|))) (|:| |yValues| (|Segment| (|DoubleFloat|)))) (|Plot|) (|Fraction| (|Integer|)) (|Fraction| (|Integer|))) "\\spad{clip(p,frac,sc)} performs two-dimensional clipping on a plot,{} \\spad{p},{} from the domain \\spadtype{Plot} for the graph of one variable \\spad{y = f(x)}; the fraction parameter is specified by \\spad{frac} and the scale parameter is specified by \\spad{sc} for use in the \\spadfun{clip} function.") (((|Record| (|:| |brans| (|List| (|List| (|Point| (|DoubleFloat|))))) (|:| |xValues| (|Segment| (|DoubleFloat|))) (|:| |yValues| (|Segment| (|DoubleFloat|)))) (|Plot|)) "\\spad{clip(p)} performs two-dimensional clipping on a plot,{} \\spad{p},{} from the domain \\spadtype{Plot} for the graph of one variable,{} \\spad{y = f(x)}; the default parameters \\spad{1/4} for the fraction and \\spad{5/1} for the scale are used in the \\spadfun{clip} function."))) 
@@ -494,7 +494,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| |#2| (QUOTE (|IntegerNumberSystem|))) (|HasCategory| |#2| (QUOTE (|RadicalCategory|))) (|HasCategory| |#2| (QUOTE (|TranscendentalFunctionCategory|))) (|HasCategory| |#2| (QUOTE (|RealNumberSystem|))) (|HasCategory| |#2| (QUOTE (|RealConstant|))) (|HasCategory| |#2| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#2| (QUOTE (|Field|))) (|HasAttribute| |#2| (QUOTE |additiveValuation|)) (|HasAttribute| |#2| (QUOTE |multiplicativeValuation|)) (|HasCategory| |#2| (QUOTE (|EuclideanDomain|))) (|HasCategory| |#2| (QUOTE (|IntegralDomain|)))) 
 (|ComplexCategory| R) 
 ((|constructor| (NIL "This category represents the extension of a ring by a square root of \\spad{-1}.")) (|rationalIfCan| (((|Union| (|Fraction| (|Integer|)) "failed") $) "\\spad{rationalIfCan(x)} returns \\spad{x} as a rational number,{} or \"failed\" if \\spad{x} is not a rational number.")) (|rational| (((|Fraction| (|Integer|)) $) "\\spad{rational(x)} returns \\spad{x} as a rational number. Error: if \\spad{x} is not a rational number.")) (|rational?| (((|Boolean|) $) "\\spad{rational?(x)} tests if \\spad{x} is a rational number.")) (|polarCoordinates| (((|Record| (|:| |r| |#1|) (|:| |phi| |#1|)) $) "\\spad{polarCoordinates(x)} returns (\\spad{r},{} phi) such that \\spad{x} = \\spad{r} * exp(\\%\\spad{i} * phi).")) (|argument| ((|#1| $) "\\spad{argument(x)} returns the angle made by (0,{}1) and (0,{}\\spad{x}).")) (|abs| (($ $) "\\spad{abs(x)} returns the absolute value of \\spad{x} = sqrt(norm(\\spad{x})).")) (|exquo| (((|Union| $ "failed") $ |#1|) "\\spad{exquo(x, r)} returns the exact quotient of \\spad{x} by \\spad{r},{} or \"failed\" if \\spad{r} does not divide \\spad{x} exactly.")) (|norm| ((|#1| $) "\\spad{norm(x)} returns \\spad{x} * conjugate(\\spad{x})")) (|real| ((|#1| $) "\\spad{real(x)} returns real part of \\spad{x}.")) (|imag| ((|#1| $) "\\spad{imag(x)} returns imaginary part of \\spad{x}.")) (|conjugate| (($ $) "\\spad{conjugate(x + \\%i y)} returns \\spad{x} - \\%\\spad{i} \\spad{y}.")) (|imaginary| (($) "\\spad{imaginary()} = sqrt(\\spad{-1}) = \\%\\spad{i}.")) (|complex| (($ |#1| |#1|) "\\spad{complex(x,y)} constructs \\spad{x} + \\%i*y.") ((|attribute|) "indicates that \\% has sqrt(\\spad{-1})"))) 
-((|noZeroDivisors| OR (|has| |#1| (|IntegralDomain|)) (AND (|has| |#1| (|EuclideanDomain|)) (|has| |#1| (|PolynomialFactorizationExplicit|)))) (|canonicalUnitNormal| |has| |#1| . #1=((|Field|))) (|canonicalsClosed| |has| |#1| . #1#) (|additiveValuation| |has| |#1| (ATTRIBUTE |additiveValuation|)) (|multiplicativeValuation| |has| |#1| (ATTRIBUTE |multiplicativeValuation|)) (|complex| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| OR (|has| |#1| (|IntegralDomain|)) (AND (|has| |#1| (|EuclideanDomain|)) (|has| |#1| (|PolynomialFactorizationExplicit|)))) (|canonicalUnitNormal| |has| |#1| (|Field|)) (|additiveValuation| |has| |#1| (ATTRIBUTE |additiveValuation|)) (|multiplicativeValuation| |has| |#1| (ATTRIBUTE |multiplicativeValuation|)) (|complex| . T) ((|commutative| "*") . T)) 
 NIL 
 (|ComplexFactorization| RR PR) 
 ((|constructor| (NIL "\\indented{1}{Author:} Date Created: Date Last Updated: Basic Functions: Related Constructors: Complex,{} UnivariatePolynomial Also See: AMS Classifications: Keywords: complex,{} polynomial factorization,{} factor References:")) (|factor| (((|Factored| |#2|) |#2|) "\\spad{factor(p)} factorizes the polynomial \\spad{p} with complex coefficients."))) 
@@ -506,8 +506,8 @@ NIL
 NIL 
 (|Complex| R) 
 ((|constructor| (NIL "\\spadtype {Complex(R)} creates the domain of elements of the form \\spad{a + b * i} where \\spad{a} and \\spad{b} come from the ring \\spad{R},{} and \\spad{i} is a new element such that \\spad{i**2 = -1}."))) 
-((|noZeroDivisors| OR (|has| |#1| (|IntegralDomain|)) (AND (|has| |#1| (|EuclideanDomain|)) (|has| |#1| (|PolynomialFactorizationExplicit|)))) (|canonicalUnitNormal| |has| |#1| . #1=((|Field|))) (|canonicalsClosed| |has| |#1| . #1#) (|additiveValuation| |has| |#1| (ATTRIBUTE |additiveValuation|)) (|multiplicativeValuation| |has| |#1| (ATTRIBUTE |multiplicativeValuation|)) (|complex| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| #2=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #3=(|HasCategory| |#1| (QUOTE (|FiniteFieldCategory|))) (OR #4=(|HasCategory| |#1| (QUOTE (|Field|))) #3#) #5=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #4# (|HasCategory| |#1| (QUOTE (|Finite|))) (OR #6=(|HasCategory| |#1| (QUOTE (|DifferentialRing|))) #3#) (OR #7=(AND #6# #4#) #8=(|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) #3#) #9=(|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #10=(|Symbol|)))) (OR #11=(AND #4# #9#) #12=(|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #10#)))) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #13=(|Integer|)))) (OR #4# #14=(|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #13#))))) #14# (|HasCategory| |#1| (QUOTE (|RetractableTo| #13#))) (OR #15=(AND #16=(|HasCategory| |#1| (QUOTE (|EuclideanDomain|))) #17=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|)))) #18=(AND #3# #17#) #4#) (OR #15# (AND #4# #17#) #18#) (OR #4# #5#) (AND (|HasCategory| |#1| (QUOTE (|RadicalCategory|))) #19=(|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) #19# (|HasCategory| |#1| (QUOTE (|RealConstant|))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|)))) (OR #16# #4# #3# #5#) (OR #16# #4# #3#) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|Pattern| #20=(|Float|))))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|Pattern| #13#)))) (|HasCategory| |#1| (QUOTE (|PatternMatchable| #20#))) (|HasCategory| |#1| (QUOTE (|PatternMatchable| #13#))) (|HasCategory| |#1| (|%list| (QUOTE |InnerEvalable|) (QUOTE #10#) #21=(|devaluate| |#1|))) (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) #21#)) (|HasCategory| |#1| (|%list| (QUOTE |Eltable|) #21# #21#)) #22=(|HasCategory| |#1| (QUOTE (|RealNumberSystem|))) (AND #22# #19#) (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|))) #16# #17# (OR #15# #4#) (OR #15# #5#) (OR #7# #8#) #8# #12# #6# #15# (|HasAttribute| |#1| (QUOTE |additiveValuation|)) (|HasAttribute| |#1| (QUOTE |multiplicativeValuation|)) (AND #8# #4#) (AND #4# #12#) #7# #11# (OR #23=(AND #16# #17# (|HasCategory| $ #2#)) #3#) (OR #23# #1#)) 
+((|noZeroDivisors| OR (|has| |#1| (|IntegralDomain|)) (AND (|has| |#1| (|EuclideanDomain|)) (|has| |#1| (|PolynomialFactorizationExplicit|)))) (|canonicalUnitNormal| |has| |#1| (|Field|)) (|additiveValuation| |has| |#1| (ATTRIBUTE |additiveValuation|)) (|multiplicativeValuation| |has| |#1| (ATTRIBUTE |multiplicativeValuation|)) (|complex| . T) ((|commutative| "*") . T)) 
+(#1=(|HasCategory| |#1| #2=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #3=(|HasCategory| |#1| (QUOTE (|FiniteFieldCategory|))) (OR #4=(|HasCategory| |#1| (QUOTE (|Field|))) #3#) #5=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #4# (|HasCategory| |#1| (QUOTE (|Finite|))) (OR #6=(|HasCategory| |#1| (QUOTE (|DifferentialRing|))) #3#) (OR #7=(AND #6# #4#) #8=(|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) #3#) #9=(|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #10=(|Symbol|)))) (OR #11=(AND #4# #9#) #12=(|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #10#)))) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #13=(|Integer|)))) (OR #4# #14=(|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #13#))))) #14# (|HasCategory| |#1| (QUOTE (|RetractableTo| #13#))) (OR #15=(AND #16=(|HasCategory| |#1| (QUOTE (|EuclideanDomain|))) #17=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|)))) #18=(AND #3# #17#) #4#) (OR #15# (AND #4# #17#) #18#) (OR #4# #5#) (AND (|HasCategory| |#1| (QUOTE (|RadicalCategory|))) #19=(|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) #19# (|HasCategory| |#1| (QUOTE (|RealConstant|))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|)))) (OR #16# #4# #3# #5#) (OR #16# #4# #3#) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|Pattern| #20=(|Float|))))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|Pattern| #13#)))) (|HasCategory| |#1| (QUOTE (|PatternMatchable| #20#))) (|HasCategory| |#1| (QUOTE (|PatternMatchable| #13#))) (|HasCategory| |#1| (|%list| (QUOTE |InnerEvalable|) (QUOTE #10#) #21=(|devaluate| |#1|))) (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) #21#)) (|HasCategory| |#1| (|%list| (QUOTE |Eltable|) #21# #21#)) #22=(|HasCategory| |#1| (QUOTE (|RealNumberSystem|))) (AND #22# #19#) (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|))) #16# #17# (OR #15# #4#) (OR #15# #5#) (OR #7# #8#) #12# #8# #6# #15# (|HasAttribute| |#1| (QUOTE |additiveValuation|)) (|HasAttribute| |#1| (QUOTE |multiplicativeValuation|)) (AND #4# #12#) (AND #8# #4#) #7# #11# (OR #23=(AND #16# #17# (|HasCategory| $ #2#)) #3#) (OR #23# #1#)) 
 (|ComplexFunctions2| R S) 
 ((|constructor| (NIL "This package extends maps from underlying rings to maps between complex over those rings.")) (|map| (((|Complex| |#2|) (|Mapping| |#2| |#1|) (|Complex| |#1|)) "\\spad{map(f,u)} maps \\spad{f} onto real and imaginary parts of \\spad{u}."))) 
 NIL 
@@ -522,7 +522,7 @@ NIL
 NIL 
 (|CommutativeRing|) 
 ((|constructor| (NIL "The category of commutative rings with unity,{} \\spadignore{i.e.} rings where \\spadop{*} is commutative,{} and which have a multiplicative identity. element.")) (|commutative| ((|attribute| "*") "multiplication is commutative."))) 
-(((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") . T)) 
 NIL 
 (|Conduit|) 
 ((|constructor| (NIL "This category is the root of the I/O conduits.")) (|close!| (($ $) "\\spad{close!(c)} closes the conduit \\spad{c},{} changing its state to one that is invalid for future read or write operations."))) 
@@ -530,7 +530,7 @@ NIL
 NIL 
 (|ContinuedFraction| R) 
 ((|constructor| (NIL "\\spadtype{ContinuedFraction} implements general \\indented{1}{continued fractions.\\space{2}This version is not restricted to simple,{}} \\indented{1}{finite fractions and uses the \\spadtype{Stream} as a} \\indented{1}{representation.\\space{2}The arithmetic functions assume that the} \\indented{1}{approximants alternate below/above the convergence point.} \\indented{1}{This is enforced by ensuring the partial numerators and partial} \\indented{1}{denominators are greater than 0 in the Euclidean domain view of \\spad{R}} \\indented{1}{(\\spadignore{i.e.} \\spad{sizeLess?(0, x)}).}")) (|complete| (($ $) "\\spad{complete(x)} causes all entries in \\spadvar{\\spad{x}} to be computed. Normally entries are only computed as needed. If \\spadvar{\\spad{x}} is an infinite continued fraction,{} a user-initiated interrupt is necessary to stop the computation.")) (|extend| (($ $ (|Integer|)) "\\spad{extend(x,n)} causes the first \\spadvar{\\spad{n}} entries in the continued fraction \\spadvar{\\spad{x}} to be computed. Normally entries are only computed as needed.")) (|denominators| (((|Stream| |#1|) $) "\\spad{denominators(x)} returns the stream of denominators of the approximants of the continued fraction \\spadvar{\\spad{x}}. If the continued fraction is finite,{} then the stream will be finite.")) (|numerators| (((|Stream| |#1|) $) "\\spad{numerators(x)} returns the stream of numerators of the approximants of the continued fraction \\spadvar{\\spad{x}}. If the continued fraction is finite,{} then the stream will be finite.")) (|convergents| (((|Stream| (|Fraction| |#1|)) $) "\\spad{convergents(x)} returns the stream of the convergents of the continued fraction \\spadvar{\\spad{x}}. If the continued fraction is finite,{} then the stream will be finite.")) (|approximants| (((|Stream| (|Fraction| |#1|)) $) "\\spad{approximants(x)} returns the stream of approximants of the continued fraction \\spadvar{\\spad{x}}. If the continued fraction is finite,{} then the stream will be infinite and periodic with period 1.")) (|reducedForm| (($ $) "\\spad{reducedForm(x)} puts the continued fraction \\spadvar{\\spad{x}} in reduced form,{} \\spadignore{i.e.} the function returns an equivalent continued fraction of the form \\spad{continuedFraction(b0,[1,1,1,...],[b1,b2,b3,...])}.")) (|wholePart| ((|#1| $) "\\spad{wholePart(x)} extracts the whole part of \\spadvar{\\spad{x}}. That is,{} if \\spad{x = continuedFraction(b0, [a1,a2,a3,...], [b1,b2,b3,...])},{} then \\spad{wholePart(x) = b0}.")) (|partialQuotients| (((|Stream| |#1|) $) "\\spad{partialQuotients(x)} extracts the partial quotients in \\spadvar{\\spad{x}}. That is,{} if \\spad{x = continuedFraction(b0, [a1,a2,a3,...], [b1,b2,b3,...])},{} then \\spad{partialQuotients(x) = [b0,b1,b2,b3,...]}.")) (|partialDenominators| (((|Stream| |#1|) $) "\\spad{partialDenominators(x)} extracts the denominators in \\spadvar{\\spad{x}}. That is,{} if \\spad{x = continuedFraction(b0, [a1,a2,a3,...], [b1,b2,b3,...])},{} then \\spad{partialDenominators(x) = [b1,b2,b3,...]}.")) (|partialNumerators| (((|Stream| |#1|) $) "\\spad{partialNumerators(x)} extracts the numerators in \\spadvar{\\spad{x}}. That is,{} if \\spad{x = continuedFraction(b0, [a1,a2,a3,...], [b1,b2,b3,...])},{} then \\spad{partialNumerators(x) = [a1,a2,a3,...]}.")) (|reducedContinuedFraction| (($ |#1| (|Stream| |#1|)) "\\spad{reducedContinuedFraction(b0,b)} constructs a continued fraction in the following way: if \\spad{b = [b1,b2,...]} then the result is the continued fraction \\spad{b0 + 1/(b1 + 1/(b2 + ...))}. That is,{} the result is the same as \\spad{continuedFraction(b0,[1,1,1,...],[b1,b2,b3,...])}.")) (|continuedFraction| (($ |#1| (|Stream| |#1|) (|Stream| |#1|)) "\\spad{continuedFraction(b0,a,b)} constructs a continued fraction in the following way: if \\spad{a = [a1,a2,...]} and \\spad{b = [b1,b2,...]} then the result is the continued fraction \\spad{b0 + a1/(b1 + a2/(b2 + ...))}.") (($ (|Fraction| |#1|)) "\\spad{continuedFraction(r)} converts the fraction \\spadvar{\\spad{r}} with components of type \\spad{R} to a continued fraction over \\spad{R}."))) 
-(((|commutative| "*") . T) (|noZeroDivisors| . T) (|canonicalUnitNormal| . T) (|canonicalsClosed| . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|Contour|) 
 ((|constructor| (NIL "\\indented{1}{Author: Gabriel Dos Reis} Date Created: October 24,{} 2007 Date Last Modified: January 18,{} 2008. A `Contour' a list of bindings making up a `virtual scope'.")) (|findBinding| (((|Maybe| (|Binding|)) (|Identifier|) $) "\\spad{findBinding(c,n)} returns the first binding associated with `n'. Otherwise `nothing.")) (|push| (($ (|Binding|) $) "\\spad{push(c,b)} augments the contour with binding `b'.")) (|bindings| (((|List| (|Binding|)) $) "\\spad{bindings(c)} returns the list of bindings in countour \\spad{c}."))) 
@@ -622,8 +622,8 @@ NIL
 NIL 
 (|DecimalExpansion|) 
 ((|constructor| (NIL "This domain allows rational numbers to be presented as repeating decimal expansions.")) (|decimal| (($ (|Fraction| (|Integer|))) "\\spad{decimal(r)} converts a rational number to a decimal expansion.")) (|fractionPart| (((|Fraction| (|Integer|)) $) "\\spad{fractionPart(d)} returns the fractional part of a decimal expansion."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| #2=(|Integer|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #2#))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #2#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #2#)))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (QUOTE (|InnerEvalable| #3# #2#))) (|HasCategory| #2# (QUOTE (|Evalable| #2#))) (|HasCategory| #2# (QUOTE (|Eltable| #2# #2#))) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #2#))) #9=(AND (|HasCategory| $ #5#) #1#) (OR #9# #4#)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
+(#1=(|HasCategory| #2=(|Integer|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #2#))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #2#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #2#)))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (QUOTE (|InnerEvalable| #3# #2#))) (|HasCategory| #2# (QUOTE (|Evalable| #2#))) (|HasCategory| #2# (QUOTE (|Eltable| #2# #2#))) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #2#))) #9=(AND (|HasCategory| $ #5#) #1#) (OR #9# #4#)) 
 (|DefinitionAst|) 
 ((|constructor| (NIL "This domain represents the syntax of a definition.")) (|body| (((|SpadAst|) $) "\\spad{body(d)} returns the right hand side of the definition `d'.")) (|signature| (((|Signature|) $) "\\spad{signature(d)} returns the signature of the operation being defined. Note that this list may be partial in that it contains only the types actually specified in the definition.")) (|head| (((|HeadAst|) $) "\\spad{head(d)} returns the head of the definition `d'. This is a list of identifiers starting with the name of the operation followed by the name of the parameters,{} if any."))) 
 NIL 
@@ -646,7 +646,7 @@ NIL
 ((AND #1=(|HasCategory| |#1| (QUOTE (|SetCategory|))) (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) (|devaluate| |#1|)))) #1# (OR #2=(|HasCategory| |#1| (QUOTE (|BasicType|))) #1#) (|HasCategory| |#1| (QUOTE (|CoercibleTo| (|OutputForm|)))) #2#) 
 (|DeRhamComplex| |CoefRing| |listIndVar|) 
 ((|constructor| (NIL "The deRham complex of Euclidean space,{} that is,{} the class of differential forms of arbitary degree over a coefficient ring. See Flanders,{} Harley,{} Differential Forms,{} With Applications to the Physical Sciences,{} New York,{} Academic Press,{} 1963.")) (|exteriorDifferential| (($ $) "\\spad{exteriorDifferential(df)} returns the exterior derivative (gradient,{} curl,{} divergence,{} ...) of the differential form \\spad{df}.")) (|totalDifferential| (($ (|Expression| |#1|)) "\\spad{totalDifferential(x)} returns the total differential (gradient) form for element \\spad{x}.")) (|degree| (((|Integer|) $) "\\spad{degree(df)} returns the homogeneous degree of differential form \\spad{df}.")) (|retractable?| (((|Boolean|) $) "\\spad{retractable?(df)} tests if differential form \\spad{df} is a 0-form,{} \\spadignore{i.e.} if degree(\\spad{df}) = 0.")) (|homogeneous?| (((|Boolean|) $) "\\spad{homogeneous?(df)} tests if all of the terms of differential form \\spad{df} have the same degree.")) (|generator| (($ (|NonNegativeInteger|)) "\\spad{generator(n)} returns the \\spad{n}th basis term for a differential form.")) (|coefficient| (((|Expression| |#1|) $ $) "\\spad{coefficient(df,u)},{} where \\spad{df} is a differential form,{} returns the coefficient of \\spad{df} containing the basis term \\spad{u} if such a term exists,{} and 0 otherwise.")) (|reductum| (($ $) "\\spad{reductum(df)},{} where \\spad{df} is a differential form,{} returns \\spad{df} minus the leading term of \\spad{df} if \\spad{df} has two or more terms,{} and 0 otherwise.")) (|leadingBasisTerm| (($ $) "\\spad{leadingBasisTerm(df)} returns the leading basis term of differential form \\spad{df}.")) (|leadingCoefficient| (((|Expression| |#1|) $) "\\spad{leadingCoefficient(df)} returns the leading coefficient of differential form \\spad{df}."))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|DefiniteIntegrationTools| R F) 
 ((|constructor| (NIL "\\spadtype{DefiniteIntegrationTools} provides common tools used by the definite integration of both rational and elementary functions.")) (|checkForZero| (((|Union| (|Boolean|) "failed") (|SparseUnivariatePolynomial| |#2|) (|OrderedCompletion| |#2|) (|OrderedCompletion| |#2|) (|Boolean|)) "\\spad{checkForZero(p, a, b, incl?)} is \\spad{true} if \\spad{p} has a zero between a and \\spad{b},{} \\spad{false} otherwise,{} \"failed\" if this cannot be determined. Check for a and \\spad{b} inclusive if incl? is \\spad{true},{} exclusive otherwise.") (((|Union| (|Boolean|) "failed") (|Polynomial| |#1|) (|Symbol|) (|OrderedCompletion| |#2|) (|OrderedCompletion| |#2|) (|Boolean|)) "\\spad{checkForZero(p, x, a, b, incl?)} is \\spad{true} if \\spad{p} has a zero for \\spad{x} between a and \\spad{b},{} \\spad{false} otherwise,{} \"failed\" if this cannot be determined. Check for a and \\spad{b} inclusive if incl? is \\spad{true},{} exclusive otherwise.")) (|computeInt| (((|Union| (|OrderedCompletion| |#2|) "failed") (|Kernel| |#2|) |#2| (|OrderedCompletion| |#2|) (|OrderedCompletion| |#2|) (|Boolean|)) "\\spad{computeInt(x, g, a, b, eval?)} returns the integral of \\spad{f} for \\spad{x} between a and \\spad{b},{} assuming that \\spad{g} is an indefinite integral of \\spad{f} and \\spad{f} has no pole between a and \\spad{b}. If \\spad{eval?} is \\spad{true},{} then \\spad{g} can be evaluated safely at \\spad{a} and \\spad{b},{} provided that they are finite values. Otherwise,{} limits must be computed.")) (|ignore?| (((|Boolean|) (|String|)) "\\spad{ignore?(s)} is \\spad{true} if \\spad{s} is the string that tells the integrator to assume that the function has no pole in the integration interval."))) 
@@ -654,7 +654,7 @@ NIL
 NIL 
 (|DoubleFloat|) 
 ((|constructor| (NIL "\\indented{1}{\\spadtype{DoubleFloat} is intended to make accessible} hardware floating point arithmetic in \\Language{},{} either native double precision,{} or IEEE. On most machines,{} there will be hardware support for the arithmetic operations: \\spadfunFrom{+}{DoubleFloat},{} \\spadfunFrom{*}{DoubleFloat},{} \\spadfunFrom{/}{DoubleFloat} and possibly also the \\spadfunFrom{sqrt}{DoubleFloat} operation. The operations \\spadfunFrom{exp}{DoubleFloat},{} \\spadfunFrom{log}{DoubleFloat},{} \\spadfunFrom{sin}{DoubleFloat},{} \\spadfunFrom{cos}{DoubleFloat},{} \\spadfunFrom{atan}{DoubleFloat} are normally coded in software based on minimax polynomial/rational approximations. Note that under Lisp/VM,{} \\spadfunFrom{atan}{DoubleFloat} is not available at this time. Some general comments about the accuracy of the operations: the operations \\spadfunFrom{+}{DoubleFloat},{} \\spadfunFrom{*}{DoubleFloat},{} \\spadfunFrom{/}{DoubleFloat} and \\spadfunFrom{sqrt}{DoubleFloat} are expected to be fully accurate. The operations \\spadfunFrom{exp}{DoubleFloat},{} \\spadfunFrom{log}{DoubleFloat},{} \\spadfunFrom{sin}{DoubleFloat},{} \\spadfunFrom{cos}{DoubleFloat} and \\spadfunFrom{atan}{DoubleFloat} are not expected to be fully accurate. In particular,{} \\spadfunFrom{sin}{DoubleFloat} and \\spadfunFrom{cos}{DoubleFloat} will lose all precision for large arguments. \\blankline The \\spadtype{Float} domain provides an alternative to the \\spad{DoubleFloat} domain. It provides an arbitrary precision model of floating point arithmetic. This means that accuracy problems like those above are eliminated by increasing the working precision where necessary. \\spadtype{Float} provides some special functions such as \\spadfunFrom{erf}{DoubleFloat},{} the error function in addition to the elementary functions. The disadvantage of \\spadtype{Float} is that it is much more expensive than small floats when the latter can be used.")) (|nan?| (((|Boolean|) $) "\\spad{nan? x} holds if \\spad{x} is a Not a Number floating point data in the IEEE 754 sense.")) (|rationalApproximation| (((|Fraction| (|Integer|)) $ (|NonNegativeInteger|) (|NonNegativeInteger|)) "\\spad{rationalApproximation(f, n, b)} computes a rational approximation \\spad{r} to \\spad{f} with relative error \\spad{< b**(-n)} (that is,{} \\spad{|(r-f)/f| < b**(-n)}).") (((|Fraction| (|Integer|)) $ (|NonNegativeInteger|)) "\\spad{rationalApproximation(f, n)} computes a rational approximation \\spad{r} to \\spad{f} with relative error \\spad{< 10**(-n)}.")) (|Beta| (($ $ $) "\\spad{Beta(x,y)} is \\spad{Gamma(x) * Gamma(y)/Gamma(x+y)}.")) (|Gamma| (($ $) "\\spad{Gamma(x)} is the Euler Gamma function.")) (|atan| (($ $ $) "\\spad{atan(x,y)} computes the arc tangent from \\spad{x} with phase \\spad{y}.")) (|log10| (($ $) "\\spad{log10(x)} computes the logarithm with base 10 for \\spad{x}.")) (|log2| (($ $) "\\spad{log2(x)} computes the logarithm with base 2 for \\spad{x}.")) (|exp1| (($) "\\spad{exp1()} returns the natural log base \\spad{2.718281828...}.")) (** (($ $ $) "\\spad{x ** y} returns the \\spad{y}th power of \\spad{x} (equal to \\spad{exp(y log x)}).")) (/ (($ $ (|Integer|)) "\\spad{x / i} computes the division from \\spad{x} by an integer \\spad{i}."))) 
-((|approximate| . T) (|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|approximate| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|DoubleFloatSpecialFunctions|) 
 ((|constructor| (NIL "This package provides special functions for double precision real and complex floating point.")) (|hypergeometric0F1| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{hypergeometric0F1(c,z)} is the hypergeometric function \\spad{0F1(; c; z)}.") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{hypergeometric0F1(c,z)} is the hypergeometric function \\spad{0F1(; c; z)}.")) (|airyBi| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{airyBi(x)} is the Airy function \\spad{Bi(x)}. This function satisfies the differential equation: \\indented{2}{\\spad{Bi''(x) - x * Bi(x) = 0}.}") (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{airyBi(x)} is the Airy function \\spad{Bi(x)}. This function satisfies the differential equation: \\indented{2}{\\spad{Bi''(x) - x * Bi(x) = 0}.}")) (|airyAi| (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{airyAi(x)} is the Airy function \\spad{Ai(x)}. This function satisfies the differential equation: \\indented{2}{\\spad{Ai''(x) - x * Ai(x) = 0}.}") (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{airyAi(x)} is the Airy function \\spad{Ai(x)}. This function satisfies the differential equation: \\indented{2}{\\spad{Ai''(x) - x * Ai(x) = 0}.}")) (|besselK| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{besselK(v,x)} is the modified Bessel function of the first kind,{} \\spad{K(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) - (x^2+v^2)w(x) = 0}.} Note: The default implmentation uses the relation \\indented{2}{\\spad{K(v,x) = \\%pi/2*(I(-v,x) - I(v,x))/sin(v*\\%pi)}} so is not valid for integer values of \\spad{v}.") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{besselK(v,x)} is the modified Bessel function of the first kind,{} \\spad{K(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) - (x^2+v^2)w(x) = 0}.} Note: The default implmentation uses the relation \\indented{2}{\\spad{K(v,x) = \\%pi/2*(I(-v,x) - I(v,x))/sin(v*\\%pi)}.} so is not valid for integer values of \\spad{v}.")) (|besselI| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{besselI(v,x)} is the modified Bessel function of the first kind,{} \\spad{I(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) - (x^2+v^2)w(x) = 0}.}") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{besselI(v,x)} is the modified Bessel function of the first kind,{} \\spad{I(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) - (x^2+v^2)w(x) = 0}.}")) (|besselY| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{besselY(v,x)} is the Bessel function of the second kind,{} \\spad{Y(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) + (x^2-v^2)w(x) = 0}.} Note: The default implmentation uses the relation \\indented{2}{\\spad{Y(v,x) = (J(v,x) cos(v*\\%pi) - J(-v,x))/sin(v*\\%pi)}} so is not valid for integer values of \\spad{v}.") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{besselY(v,x)} is the Bessel function of the second kind,{} \\spad{Y(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) + (x^2-v^2)w(x) = 0}.} Note: The default implmentation uses the relation \\indented{2}{\\spad{Y(v,x) = (J(v,x) cos(v*\\%pi) - J(-v,x))/sin(v*\\%pi)}} so is not valid for integer values of \\spad{v}.")) (|besselJ| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{besselJ(v,x)} is the Bessel function of the first kind,{} \\spad{J(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) + (x^2-v^2)w(x) = 0}.}") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{besselJ(v,x)} is the Bessel function of the first kind,{} \\spad{J(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) + (x^2-v^2)w(x) = 0}.}")) (|polygamma| (((|Complex| (|DoubleFloat|)) (|NonNegativeInteger|) (|Complex| (|DoubleFloat|))) "\\spad{polygamma(n, x)} is the \\spad{n}-th derivative of \\spad{digamma(x)}.") (((|DoubleFloat|) (|NonNegativeInteger|) (|DoubleFloat|)) "\\spad{polygamma(n, x)} is the \\spad{n}-th derivative of \\spad{digamma(x)}.")) (|digamma| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{digamma(x)} is the function,{} \\spad{psi(x)},{} defined by \\indented{2}{\\spad{psi(x) = Gamma'(x)/Gamma(x)}.}") (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{digamma(x)} is the function,{} \\spad{psi(x)},{} defined by \\indented{2}{\\spad{psi(x) = Gamma'(x)/Gamma(x)}.}")) (|logGamma| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{logGamma(x)} is the natural log of \\spad{Gamma(x)}. This can often be computed even if \\spad{Gamma(x)} cannot.") (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{logGamma(x)} is the natural log of \\spad{Gamma(x)}. This can often be computed even if \\spad{Gamma(x)} cannot.")) (|Beta| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{Beta(x, y)} is the Euler beta function,{} \\spad{B(x,y)},{} defined by \\indented{2}{\\spad{Beta(x,y) = integrate(t^(x-1)*(1-t)^(y-1), t=0..1)}.} This is related to \\spad{Gamma(x)} by \\indented{2}{\\spad{Beta(x,y) = Gamma(x)*Gamma(y) / Gamma(x + y)}.}") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{Beta(x, y)} is the Euler beta function,{} \\spad{B(x,y)},{} defined by \\indented{2}{\\spad{Beta(x,y) = integrate(t^(x-1)*(1-t)^(y-1), t=0..1)}.} This is related to \\spad{Gamma(x)} by \\indented{2}{\\spad{Beta(x,y) = Gamma(x)*Gamma(y) / Gamma(x + y)}.}")) (|Gamma| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{Gamma(x)} is the Euler gamma function,{} \\spad{Gamma(x)},{} defined by \\indented{2}{\\spad{Gamma(x) = integrate(t^(x-1)*exp(-t), t=0..\\%infinity)}.}") (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{Gamma(x)} is the Euler gamma function,{} \\spad{Gamma(x)},{} defined by \\indented{2}{\\spad{Gamma(x) = integrate(t^(x-1)*exp(-t), t=0..\\%infinity)}.}"))) 
@@ -674,7 +674,7 @@ NIL
 NIL 
 (|DifferentialExtension| R) 
 ((|constructor| (NIL "Differential extensions of a ring \\spad{R}. Given a differentiation on \\spad{R},{} extend it to a differentiation on \\%."))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|DifferentialDomain&| S T$) 
 ((|constructor| (NIL "This category captures the interface of domains with a distinguished operation named \\spad{differentiate}. Usually,{} additional properties are wanted. For example,{} that it obeys the usual Leibniz identity of differentiation of product,{} in case of differential rings. One could also want \\spad{differentiate} to obey the chain rule when considering differential manifolds. The lack of specific requirement in this category is an implicit admission that currently \\Language{} is not expressive enough to express the most general notion of differentiation in an adequate manner,{} suitable for computational purposes.")) (D ((|#2| $) "\\spad{D x} is a shorthand for \\spad{differentiate x}")) (|differentiate| ((|#2| $) "\\spad{differentiate x} compute the derivative of \\spad{x}."))) 
@@ -686,7 +686,7 @@ NIL
 NIL 
 (|DifferentialModule| R) 
 ((|constructor| (NIL "An \\spad{R}-module equipped with a distinguised differential operator. If \\spad{R} is a differential ring,{} then differentiation on the module should extend differentiation on the differential ring \\spad{R}. The latter can be the null operator. In that case,{} the differentiation operator on the module is just an \\spad{R}-linear operator. For that reason,{} we do not require that the ring \\spad{R} be a DifferentialRing; \\blankline"))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 NIL 
 (|DifferentialSpace&| S) 
 ((|constructor| (NIL "This category is like \\spadtype{DifferentialDomain} where the target of the differentiation operator is the same as its source.")) (D (($ $ (|NonNegativeInteger|)) "\\spad{D(x, n)} returns the \\spad{n}\\spad{-}th derivative of \\spad{x}.")) (|differentiate| (($ $ (|NonNegativeInteger|)) "\\spad{differentiate(x,n)} returns the \\spad{n}\\spad{-}th derivative of \\spad{x}."))) 
@@ -698,7 +698,7 @@ NIL
 NIL 
 (|DifferentialRing|) 
 ((|constructor| (NIL "An ordinary differential ring,{} that is,{} a ring with an operation \\spadfun{differentiate}. \\blankline"))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|Dioid|) 
 ((|constructor| (NIL "Dioid is the class of semirings where the addition operation induces a canonical order relation."))) 
@@ -719,15 +719,15 @@ NIL
 (|DirectProductCategory&| S |dim| R) 
 ((|constructor| (NIL "\\indented{2}{This category represents a finite cartesian product of a given type.} Many categorical properties are preserved under this construction.")) (|dot| ((|#3| $ $) "\\spad{dot(x,y)} computes the inner product of the vectors \\spad{x} and \\spad{y}.")) (|unitVector| (($ (|PositiveInteger|)) "\\spad{unitVector(n)} produces a vector with 1 in position \\spad{n} and zero elsewhere.")) (|directProduct| (($ (|Vector| |#3|)) "\\spad{directProduct(v)} converts the vector \\spad{v} to become a direct product. Error: if the length of \\spad{v} is different from dim."))) 
 NIL 
-((|HasCategory| |#3| (QUOTE (|Field|))) (|HasCategory| |#3| (QUOTE (|OrderedAbelianMonoidSup|))) (|HasCategory| |#3| (QUOTE (|OrderedSet|))) (|HasAttribute| |#3| (QUOTE |unitsKnown|)) (|HasCategory| |#3| (QUOTE (|CommutativeRing|))) (|HasCategory| |#3| (QUOTE (|Finite|))) (|HasCategory| |#3| (QUOTE (|Monoid|))) (|HasCategory| |#3| (QUOTE (|AbelianGroup|))) (|HasCategory| |#3| (QUOTE (|AbelianMonoid|))) (|HasCategory| |#3| (QUOTE (|CancellationAbelianMonoid|))) (|HasCategory| |#3| (QUOTE (|AbelianSemiGroup|))) (|HasCategory| |#3| (QUOTE (|Ring|))) (|HasCategory| |#3| (QUOTE (|SetCategory|)))) 
+((|HasCategory| |#3| (QUOTE (|Field|))) (|HasCategory| |#3| (QUOTE (|OrderedAbelianMonoidSup|))) (|HasCategory| |#3| (QUOTE (|OrderedSet|))) (|HasCategory| |#3| (QUOTE (|CommutativeRing|))) (|HasCategory| |#3| (QUOTE (|Finite|))) (|HasCategory| |#3| (QUOTE (|Monoid|))) (|HasCategory| |#3| (QUOTE (|AbelianGroup|))) (|HasCategory| |#3| (QUOTE (|AbelianMonoid|))) (|HasCategory| |#3| (QUOTE (|CancellationAbelianMonoid|))) (|HasCategory| |#3| (QUOTE (|AbelianSemiGroup|))) (|HasCategory| |#3| (QUOTE (|Ring|))) (|HasCategory| |#3| (QUOTE (|SetCategory|)))) 
 (|DirectProductCategory| |dim| R) 
 ((|constructor| (NIL "\\indented{2}{This category represents a finite cartesian product of a given type.} Many categorical properties are preserved under this construction.")) (|dot| ((|#2| $ $) "\\spad{dot(x,y)} computes the inner product of the vectors \\spad{x} and \\spad{y}.")) (|unitVector| (($ (|PositiveInteger|)) "\\spad{unitVector(n)} produces a vector with 1 in position \\spad{n} and zero elsewhere.")) (|directProduct| (($ (|Vector| |#2|)) "\\spad{directProduct(v)} converts the vector \\spad{v} to become a direct product. Error: if the length of \\spad{v} is different from dim."))) 
-((|rightUnitary| |has| |#2| . #1=((|Ring|))) (|leftUnitary| |has| |#2| . #1#) (|unitsKnown| |has| |#2| (ATTRIBUTE |unitsKnown|))) 
+NIL 
 NIL 
 (|DirectProduct| |dim| R) 
 ((|constructor| (NIL "\\indented{2}{This type represents the finite direct or cartesian product of an} underlying component type. This contrasts with simple vectors in that the members can be viewed as having constant length. Thus many categorical properties can by lifted from the underlying component type. Component extraction operations are provided but no updating operations. Thus new direct product elements can either be created by converting vector elements using the \\spadfun{directProduct} function or by taking appropriate linear combinations of basis vectors provided by the \\spad{unitVector} operation."))) 
-((|rightUnitary| |has| |#2| . #1=((|Ring|))) (|leftUnitary| |has| |#2| . #1#) (|unitsKnown| |has| |#2| (ATTRIBUTE |unitsKnown|))) 
-((OR (AND #1=(|HasCategory| |#2| (QUOTE (|AbelianGroup|))) #2=(|HasCategory| |#2| (|%list| (QUOTE |Evalable|) #3=(|devaluate| |#2|)))) (AND #4=(|HasCategory| |#2| (QUOTE (|AbelianMonoid|))) #2#) (AND #5=(|HasCategory| |#2| (QUOTE (|AbelianSemiGroup|))) #2#) (AND #6=(|HasCategory| |#2| (QUOTE (|CancellationAbelianMonoid|))) #2#) (AND #7=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #2#) (AND #8=(|HasCategory| |#2| (QUOTE (|DifferentialRing|))) #2#) (AND #9=(|HasCategory| |#2| (QUOTE (|Field|))) #2#) (AND #10=(|HasCategory| |#2| (QUOTE (|Finite|))) #2#) (AND #11=(|HasCategory| |#2| (QUOTE (|Monoid|))) #2#) (AND #12=(|HasCategory| |#2| (QUOTE (|OrderedAbelianMonoidSup|))) #2#) (AND #13=(|HasCategory| |#2| #14=(QUOTE (|OrderedSet|))) #2#) (AND #15=(|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #16=(|Symbol|)))) #2#) (AND #17=(|HasCategory| |#2| (QUOTE (|Ring|))) #2#) #18=(AND #19=(|HasCategory| |#2| (QUOTE (|SetCategory|))) #2#)) (|HasCategory| |#2| (QUOTE (|CoercibleTo| (|OutputForm|)))) #9# (OR #7# #9# #17#) (OR #7# #9#) #1# #17# #11# #12# (OR #12# #13#) #13# #10# (OR (AND #7# #20=(|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #21=(|Integer|))))) (AND #8# #20#) (AND #9# #20#) (AND #20# #15#) #22=(AND #20# #17#)) #15# (OR #1# #4# #5# #23=(|HasCategory| |#2| (QUOTE (|BasicType|))) #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #15# #17#) (OR #1# #4# #6# #7# #8# #9# #15# #17#) (OR #1# #6# #7# #8# #9# #15# #17#) (OR #1# #7# #8# #9# #15# #17#) (OR #8# #15# #17#) #8# (OR #8# #24=(AND (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) #17#)) (OR #25=(AND (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #16#))) #17#) #15#) #19# (OR (AND #1# #26=(|HasCategory| |#2| (QUOTE (|RetractableTo| (|Fraction| #21#))))) (AND #4# #26#) (AND #5# #26#) (AND #6# #26#) (AND #7# #26#) (AND #8# #26#) (AND #9# #26#) (AND #10# #26#) (AND #11# #26#) (AND #12# #26#) (AND #13# #26#) (AND #15# #26#) (AND #26# #17#) #27=(AND #26# #19#)) (OR #28=(AND #1# #29=(|HasCategory| |#2| (QUOTE (|RetractableTo| #21#)))) #30=(AND #4# #29#) #31=(AND #5# #29#) #32=(AND #6# #29#) #33=(AND #7# #29#) #34=(AND #8# #29#) #35=(AND #12# #29#) #36=(AND #13# #29#) #37=(AND #15# #29#) #38=(AND #29# #19#) #39=(AND #9# #29#) #40=(AND #10# #29#) #41=(AND #11# #29#) #17#) (OR #28# #30# #31# #32# #33# #34# #35# #36# #37# #38# #39# #40# #41# (AND #29# #17#)) #23# (|HasCategory| #21# #14#) #22# #24# #25# (OR #38# #17#) #38# #27# (|HasAttribute| |#2| (QUOTE |unitsKnown|)) (AND #8# #17#) (AND #15# #17#) #7# #4# #6# #5# #18# (AND #23# (|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #3#))) (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #3#))) 
+NIL 
+((OR (AND #1=(|HasCategory| |#2| (QUOTE (|AbelianGroup|))) #2=(|HasCategory| |#2| (|%list| (QUOTE |Evalable|) #3=(|devaluate| |#2|)))) (AND #4=(|HasCategory| |#2| (QUOTE (|AbelianMonoid|))) #2#) (AND #5=(|HasCategory| |#2| (QUOTE (|AbelianSemiGroup|))) #2#) (AND #6=(|HasCategory| |#2| (QUOTE (|CancellationAbelianMonoid|))) #2#) (AND #7=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #2#) (AND #8=(|HasCategory| |#2| (QUOTE (|DifferentialRing|))) #2#) (AND #9=(|HasCategory| |#2| (QUOTE (|Field|))) #2#) (AND #10=(|HasCategory| |#2| (QUOTE (|Finite|))) #2#) (AND #11=(|HasCategory| |#2| (QUOTE (|Monoid|))) #2#) (AND #12=(|HasCategory| |#2| (QUOTE (|OrderedAbelianMonoidSup|))) #2#) (AND #13=(|HasCategory| |#2| #14=(QUOTE (|OrderedSet|))) #2#) (AND #15=(|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #16=(|Symbol|)))) #2#) (AND #17=(|HasCategory| |#2| (QUOTE (|Ring|))) #2#) #18=(AND #19=(|HasCategory| |#2| (QUOTE (|SetCategory|))) #2#)) (|HasCategory| |#2| (QUOTE (|CoercibleTo| (|OutputForm|)))) #9# (OR #7# #9# #17#) (OR #7# #9#) #1# #17# #11# #12# (OR #12# #13#) #13# #10# (OR (AND #7# #20=(|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #21=(|Integer|))))) (AND #8# #20#) (AND #9# #20#) (AND #20# #15#) #22=(AND #20# #17#)) #15# (OR #1# #4# #5# #23=(|HasCategory| |#2| (QUOTE (|BasicType|))) #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #15# #17#) (OR #1# #4# #6# #7# #8# #9# #15# #17#) (OR #1# #6# #7# #8# #9# #15# #17#) (OR #1# #7# #8# #9# #15# #17#) (OR #8# #15# #17#) #8# (OR #8# #24=(AND (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) #17#)) (OR #25=(AND (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #16#))) #17#) #15#) #19# (OR (AND #1# #26=(|HasCategory| |#2| (QUOTE (|RetractableTo| (|Fraction| #21#))))) (AND #4# #26#) (AND #5# #26#) (AND #6# #26#) (AND #7# #26#) (AND #8# #26#) (AND #9# #26#) (AND #10# #26#) (AND #11# #26#) (AND #12# #26#) (AND #13# #26#) (AND #15# #26#) (AND #26# #17#) #27=(AND #26# #19#)) (OR #28=(AND #1# #29=(|HasCategory| |#2| (QUOTE (|RetractableTo| #21#)))) #30=(AND #4# #29#) #31=(AND #5# #29#) #32=(AND #6# #29#) #33=(AND #7# #29#) #34=(AND #8# #29#) #35=(AND #12# #29#) #36=(AND #13# #29#) #37=(AND #15# #29#) #38=(AND #29# #19#) #39=(AND #9# #29#) #40=(AND #10# #29#) #41=(AND #11# #29#) #17#) (OR #28# #30# #31# #32# #33# #34# #35# #36# #37# #38# #39# #40# #41# (AND #29# #17#)) #23# (|HasCategory| #21# #14#) #22# #24# #25# (OR #38# #17#) #38# #27# (AND #8# #17#) (AND #15# #17#) #7# #4# #6# #5# #18# (AND #23# (|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #3#))) (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #3#))) 
 (|DirectProductFunctions2| |dim| A B) 
 ((|constructor| (NIL "\\indented{2}{This package provides operations which all take as arguments} direct products of elements of some type \\spad{A} and functions from \\spad{A} to another type \\spad{B}. The operations all iterate over their vector argument and either return a value of type \\spad{B} or a direct product over \\spad{B}.")) (|map| (((|DirectProduct| |#1| |#3|) (|Mapping| |#3| |#2|) (|DirectProduct| |#1| |#2|)) "\\spad{map(f, v)} applies the function \\spad{f} to every element of the vector \\spad{v} producing a new vector containing the values.")) (|reduce| ((|#3| (|Mapping| |#3| |#2| |#3|) (|DirectProduct| |#1| |#2|) |#3|) "\\spad{reduce(func,vec,ident)} combines the elements in \\spad{vec} using the binary function \\spad{func}. Argument \\spad{ident} is returned if the vector is empty.")) (|scan| (((|DirectProduct| |#1| |#3|) (|Mapping| |#3| |#2| |#3|) (|DirectProduct| |#1| |#2|) |#3|) "\\spad{scan(func,vec,ident)} creates a new vector whose elements are the result of applying reduce to the binary function \\spad{func},{} increasing initial subsequences of the vector \\spad{vec},{} and the element \\spad{ident}."))) 
 NIL 
@@ -742,7 +742,7 @@ NIL
 NIL 
 (|DivisionRing|) 
 ((|constructor| (NIL "A division ring (sometimes called a skew field),{} \\spadignore{i.e.} a not necessarily commutative ring where all non-zero elements have multiplicative inverses.")) (|inv| (($ $) "\\spad{inv x} returns the multiplicative inverse of \\spad{x}. Error: if \\spad{x} is 0.")) (** (($ $ (|Integer|)) "\\spad{x**n} returns \\spad{x} raised to the integer power \\spad{n}."))) 
-((|noZeroDivisors| . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T)) 
 NIL 
 (|DoublyLinkedAggregate| S) 
 ((|constructor| (NIL "A doubly-linked aggregate serves as a model for a doubly-linked list,{} that is,{} a list which can has links to both next and previous nodes and thus can be efficiently traversed in both directions.")) (|setnext!| (($ $ $) "\\spad{setnext!(u,v)} destructively sets the next node of doubly-linked aggregate \\spad{u} to \\spad{v},{} returning \\spad{v}.")) (|setprevious!| (($ $ $) "\\spad{setprevious!(u,v)} destructively sets the previous node of doubly-linked aggregate \\spad{u} to \\spad{v},{} returning \\spad{v}.")) (|concat!| (($ $ $) "\\spad{concat!(u,v)} destructively concatenates doubly-linked aggregate \\spad{v} to the end of doubly-linked aggregate \\spad{u}.")) (|next| (($ $) "\\spad{next(l)} returns the doubly-linked aggregate beginning with its next element. Error: if \\spad{l} has no next element. Note: \\axiom{next(\\spad{l}) = rest(\\spad{l})} and \\axiom{previous(next(\\spad{l})) = \\spad{l}}.")) (|previous| (($ $) "\\spad{previous(l)} returns the doubly-link list beginning with its previous element. Error: if \\spad{l} has no previous element. Note: \\axiom{next(previous(\\spad{l})) = \\spad{l}}.")) (|tail| (($ $) "\\spad{tail(l)} returns the doubly-linked aggregate \\spad{l} starting at its second element. Error: if \\spad{l} is empty.")) (|head| (($ $) "\\spad{head(l)} returns the first element of a doubly-linked aggregate \\spad{l}. Error: if \\spad{l} is empty.")) (|last| ((|#1| $) "\\spad{last(l)} returns the last element of a doubly-linked aggregate \\spad{l}. Error: if \\spad{l} is empty."))) 
@@ -758,12 +758,12 @@ NIL
 NIL 
 (|DifferentialModuleExtension| R) 
 ((|constructor| (NIL "Category of modules that extend differential rings. \\blankline"))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 NIL 
 (|DistributedMultivariatePolynomial| |vl| R) 
 ((|constructor| (NIL "\\indented{2}{This type supports distributed multivariate polynomials} whose variables are from a user specified list of symbols. The coefficient ring may be non commutative,{} but the variables are assumed to commute. The term ordering is lexicographic specified by the variable list parameter with the most significant variable first in the list.")) (|reorder| (($ $ (|List| (|Integer|))) "\\spad{reorder(p, perm)} applies the permutation perm to the variables in a polynomial and returns the new correctly ordered polynomial"))) 
-(((|commutative| "*") |has| |#2| (|CommutativeRing|)) (|noZeroDivisors| |has| |#2| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#2| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#2| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#2| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#2| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|OrderedVariableList| |#1|) #5#)) (AND (|HasCategory| |#2| #8=(QUOTE (|PatternMatchable| #9=(|Integer|)))) (|HasCategory| #7# #8#)) (AND (|HasCategory| |#2| #10=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #10#)) (AND (|HasCategory| |#2| #11=(QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#2| #12=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #12#)) (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #9#))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) #13=(|HasCategory| |#2| #14=(QUOTE (|CharacteristicNonZero|))) #15=(|HasCategory| |#2| (QUOTE (|Algebra| #16=(|Fraction| #9#)))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #9#))) (OR #15# #17=(|HasCategory| |#2| (QUOTE (|RetractableTo| #16#)))) #17# (|HasCategory| |#2| (QUOTE (|Field|))) (|HasAttribute| |#2| (QUOTE |canonicalUnitNormal|)) #3# #18=(AND #1# (|HasCategory| $ #14#)) (OR #18# #13#)) 
+(((|commutative| "*") |has| |#2| (|CommutativeRing|)) (|noZeroDivisors| |has| |#2| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#2| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#2| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#2| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#2| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|OrderedVariableList| |#1|) #5#)) (AND (|HasCategory| |#2| #8=(QUOTE (|PatternMatchable| #9=(|Integer|)))) (|HasCategory| #7# #8#)) (AND (|HasCategory| |#2| #10=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #10#)) (AND (|HasCategory| |#2| #11=(QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#2| #12=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #12#)) (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #9#))) #13=(|HasCategory| |#2| (QUOTE (|Algebra| #14=(|Fraction| #9#)))) #15=(|HasCategory| |#2| #16=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #9#))) (OR #13# #17=(|HasCategory| |#2| (QUOTE (|RetractableTo| #14#)))) #17# (|HasCategory| |#2| (QUOTE (|Field|))) (|HasAttribute| |#2| (QUOTE |canonicalUnitNormal|)) #3# #18=(AND #1# (|HasCategory| $ #16#)) (OR #18# #15#)) 
 (|Domain|) 
 ((|showSummary| (((|Void|) $) "\\spad{showSummary(d)} prints out implementation detail information of domain `d'.")) (|reflect| (($ (|ConstructorCall| (|DomainConstructor|))) "\\spad{reflect cc} returns the domain object designated by the ConstructorCall syntax `cc'. The constructor implied by `cc' must be known to the system since it is instantiated.")) (|reify| (((|ConstructorCall| (|DomainConstructor|)) $) "\\spad{reify(d)} returns the abstract syntax for the domain `x'.")) (|constructor| (NIL "\\indented{1}{Author: Gabriel Dos Reis} Date Create: October 18,{} 2007. Date Last Updated: December 20,{} 2008. Basic Operations: coerce,{} reify Related Constructors: Type,{} Syntax,{} OutputForm Also See: Type,{} ConstructorCall") (((|DomainConstructor|) $) "\\spad{constructor(d)} returns the domain constructor that is instantiated to the domain object `d'."))) 
 NIL 
@@ -778,19 +778,19 @@ NIL
 NIL 
 (|DirectProductMatrixModule| |n| R M S) 
 ((|constructor| (NIL "This constructor provides a direct product type with a left matrix-module view."))) 
-((|unitsKnown| OR (|and| #1=(|has| |#4| #2=(|Ring|)) (|has| |#4| (|DifferentialRing|))) (|has| |#4| (ATTRIBUTE |unitsKnown|)) (|and| #1# (|has| |#4| (|PartialDifferentialRing| (|Symbol|))))) (|rightUnitary| |has| |#4| . #3=(#2#)) (|leftUnitary| |has| |#4| . #3#)) 
-((OR (AND #1=(|HasCategory| |#4| (QUOTE (|AbelianGroup|))) #2=(|HasCategory| |#4| (|%list| (QUOTE |Evalable|) #3=(|devaluate| |#4|)))) (AND #4=(|HasCategory| |#4| (QUOTE (|CommutativeRing|))) #2#) (AND #5=(|HasCategory| |#4| (QUOTE (|DifferentialRing|))) #2#) (AND #6=(|HasCategory| |#4| (QUOTE (|Field|))) #2#) (AND #7=(|HasCategory| |#4| (QUOTE (|Finite|))) #2#) (AND #8=(|HasCategory| |#4| (QUOTE (|Monoid|))) #2#) (AND #9=(|HasCategory| |#4| (QUOTE (|OrderedAbelianMonoidSup|))) #2#) (AND #10=(|HasCategory| |#4| #11=(QUOTE (|OrderedSet|))) #2#) (AND #12=(|HasCategory| |#4| (QUOTE (|PartialDifferentialRing| #13=(|Symbol|)))) #2#) (AND #14=(|HasCategory| |#4| (QUOTE (|Ring|))) #2#) #15=(AND #16=(|HasCategory| |#4| (QUOTE (|SetCategory|))) #2#)) #6# (OR #4# #6# #14#) (OR #4# #6#) #14# #8# #9# (OR #9# #10#) #10# #7# (OR (AND #4# #17=(|HasCategory| |#4| (QUOTE (|LinearlyExplicitRingOver| #18=(|Integer|))))) (AND #5# #17#) (AND #6# #17#) (AND #17# #12#) #19=(AND #17# #14#)) #12# (OR #5# #12# #14#) #5# (OR #5# #20=(AND (|HasCategory| |#4| (QUOTE (|DifferentialSpace|))) #14#)) (OR #21=(AND (|HasCategory| |#4| (QUOTE (|PartialDifferentialSpace| #13#))) #14#) #12#) #16# (OR (AND #1# #22=(|HasCategory| |#4| (QUOTE (|RetractableTo| (|Fraction| #18#))))) (AND #4# #22#) (AND #5# #22#) (AND #6# #22#) (AND #7# #22#) (AND #8# #22#) (AND #9# #22#) (AND #10# #22#) (AND #12# #22#) (AND #22# #14#) #23=(AND #22# #16#)) (OR #24=(AND #1# #25=(|HasCategory| |#4| (QUOTE (|RetractableTo| #18#)))) #26=(AND #4# #25#) #27=(AND #5# #25#) #28=(AND #9# #25#) #29=(AND #10# #25#) #30=(AND #12# #25#) #31=(AND #25# #16#) #32=(AND #6# #25#) #33=(AND #7# #25#) #34=(AND #8# #25#) #14#) (OR #24# #26# #27# #28# #29# #30# #31# #32# #33# #34# (AND #25# #14#)) #35=(|HasCategory| |#4| (QUOTE (|BasicType|))) (|HasCategory| #18# #11#) #19# (OR #36=(AND #12# #14#) #21#) (OR #37=(AND #5# #14#) #20#) #31# (OR #31# #14#) #23# (OR #36# (|HasAttribute| |#4| (QUOTE |unitsKnown|)) #37#) #20# #21# #4# #1# (|HasCategory| |#4| (QUOTE (|AbelianMonoid|))) (|HasCategory| |#4| (QUOTE (|CancellationAbelianMonoid|))) (|HasCategory| |#4| (QUOTE (|AbelianSemiGroup|))) (|HasCategory| |#4| (QUOTE (|CoercibleTo| (|OutputForm|)))) #15# (AND #35# (|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #3#))) (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #3#))) 
+NIL 
+((OR (AND #1=(|HasCategory| |#4| (QUOTE (|AbelianGroup|))) #2=(|HasCategory| |#4| (|%list| (QUOTE |Evalable|) #3=(|devaluate| |#4|)))) (AND #4=(|HasCategory| |#4| (QUOTE (|CommutativeRing|))) #2#) (AND #5=(|HasCategory| |#4| (QUOTE (|DifferentialRing|))) #2#) (AND #6=(|HasCategory| |#4| (QUOTE (|Field|))) #2#) (AND #7=(|HasCategory| |#4| (QUOTE (|Finite|))) #2#) (AND #8=(|HasCategory| |#4| (QUOTE (|Monoid|))) #2#) (AND #9=(|HasCategory| |#4| (QUOTE (|OrderedAbelianMonoidSup|))) #2#) (AND #10=(|HasCategory| |#4| #11=(QUOTE (|OrderedSet|))) #2#) (AND #12=(|HasCategory| |#4| (QUOTE (|PartialDifferentialRing| #13=(|Symbol|)))) #2#) (AND #14=(|HasCategory| |#4| (QUOTE (|Ring|))) #2#) #15=(AND #16=(|HasCategory| |#4| (QUOTE (|SetCategory|))) #2#)) #6# (OR #4# #6# #14#) (OR #4# #6#) #14# #8# #9# (OR #9# #10#) #10# #7# (OR (AND #4# #17=(|HasCategory| |#4| (QUOTE (|LinearlyExplicitRingOver| #18=(|Integer|))))) (AND #5# #17#) (AND #6# #17#) (AND #17# #12#) #19=(AND #17# #14#)) #12# (OR #5# #12# #14#) #5# (OR #5# #20=(AND (|HasCategory| |#4| (QUOTE (|DifferentialSpace|))) #14#)) (OR #21=(AND (|HasCategory| |#4| (QUOTE (|PartialDifferentialSpace| #13#))) #14#) #12#) #16# (OR (AND #1# #22=(|HasCategory| |#4| (QUOTE (|RetractableTo| (|Fraction| #18#))))) (AND #4# #22#) (AND #5# #22#) (AND #6# #22#) (AND #7# #22#) (AND #8# #22#) (AND #9# #22#) (AND #10# #22#) (AND #12# #22#) (AND #22# #14#) #23=(AND #22# #16#)) (OR #24=(AND #1# #25=(|HasCategory| |#4| (QUOTE (|RetractableTo| #18#)))) #26=(AND #4# #25#) #27=(AND #5# #25#) #28=(AND #9# #25#) #29=(AND #10# #25#) #30=(AND #12# #25#) #31=(AND #25# #16#) #32=(AND #6# #25#) #33=(AND #7# #25#) #34=(AND #8# #25#) #14#) (OR #24# #26# #27# #28# #29# #30# #31# #32# #33# #34# (AND #25# #14#)) #35=(|HasCategory| |#4| (QUOTE (|BasicType|))) (|HasCategory| #18# #11#) #19# (OR (AND #5# #14#) #20#) (OR (AND #12# #14#) #21#) #31# (OR #31# #14#) #23# #21# #20# #4# #1# (|HasCategory| |#4| (QUOTE (|AbelianMonoid|))) (|HasCategory| |#4| (QUOTE (|CancellationAbelianMonoid|))) (|HasCategory| |#4| (QUOTE (|AbelianSemiGroup|))) (|HasCategory| |#4| (QUOTE (|CoercibleTo| (|OutputForm|)))) #15# (AND #35# (|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #3#))) (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #3#))) 
 (|DirectProductModule| |n| R S) 
 ((|constructor| (NIL "This constructor provides a direct product of \\spad{R}-modules with an \\spad{R}-module view."))) 
-((|unitsKnown| OR (|and| #1=(|has| |#3| #2=(|Ring|)) (|has| |#3| (|DifferentialRing|))) (|has| |#3| (ATTRIBUTE |unitsKnown|)) (|and| #1# (|has| |#3| (|PartialDifferentialRing| (|Symbol|))))) (|rightUnitary| |has| |#3| . #3=(#2#)) (|leftUnitary| |has| |#3| . #3#)) 
-((OR (AND #1=(|HasCategory| |#3| (QUOTE (|AbelianGroup|))) #2=(|HasCategory| |#3| (|%list| (QUOTE |Evalable|) #3=(|devaluate| |#3|)))) (AND #4=(|HasCategory| |#3| (QUOTE (|CommutativeRing|))) #2#) (AND #5=(|HasCategory| |#3| (QUOTE (|DifferentialRing|))) #2#) (AND #6=(|HasCategory| |#3| (QUOTE (|Field|))) #2#) (AND #7=(|HasCategory| |#3| (QUOTE (|Finite|))) #2#) (AND #8=(|HasCategory| |#3| (QUOTE (|Monoid|))) #2#) (AND #9=(|HasCategory| |#3| (QUOTE (|OrderedAbelianMonoidSup|))) #2#) (AND #10=(|HasCategory| |#3| #11=(QUOTE (|OrderedSet|))) #2#) (AND #12=(|HasCategory| |#3| (QUOTE (|PartialDifferentialRing| #13=(|Symbol|)))) #2#) (AND #14=(|HasCategory| |#3| (QUOTE (|Ring|))) #2#) #15=(AND #16=(|HasCategory| |#3| (QUOTE (|SetCategory|))) #2#)) #6# (OR #4# #6# #14#) (OR #4# #6#) #14# #8# #9# (OR #9# #10#) #10# #7# (OR (AND #4# #17=(|HasCategory| |#3| (QUOTE (|LinearlyExplicitRingOver| #18=(|Integer|))))) (AND #5# #17#) (AND #6# #17#) (AND #17# #12#) #19=(AND #17# #14#)) #12# (OR #5# #12# #14#) #5# (OR #5# #20=(AND (|HasCategory| |#3| (QUOTE (|DifferentialSpace|))) #14#)) (OR #21=(AND (|HasCategory| |#3| (QUOTE (|PartialDifferentialSpace| #13#))) #14#) #12#) #16# (OR (AND #1# #22=(|HasCategory| |#3| (QUOTE (|RetractableTo| (|Fraction| #18#))))) (AND #4# #22#) (AND #5# #22#) (AND #6# #22#) (AND #7# #22#) (AND #8# #22#) (AND #9# #22#) (AND #10# #22#) (AND #12# #22#) (AND #22# #14#) #23=(AND #22# #16#)) (OR #24=(AND #1# #25=(|HasCategory| |#3| (QUOTE (|RetractableTo| #18#)))) #26=(AND #4# #25#) #27=(AND #5# #25#) #28=(AND #9# #25#) #29=(AND #10# #25#) #30=(AND #12# #25#) #31=(AND #25# #16#) #32=(AND #6# #25#) #33=(AND #7# #25#) #34=(AND #8# #25#) #14#) (OR #24# #26# #27# #28# #29# #30# #31# #32# #33# #34# (AND #25# #14#)) #35=(|HasCategory| |#3| (QUOTE (|BasicType|))) (|HasCategory| #18# #11#) #19# (OR #36=(AND #12# #14#) #21#) (OR #37=(AND #5# #14#) #20#) #31# (OR #31# #14#) #23# (OR #36# (|HasAttribute| |#3| (QUOTE |unitsKnown|)) #37#) #20# #21# #4# #1# (|HasCategory| |#3| (QUOTE (|AbelianMonoid|))) (|HasCategory| |#3| (QUOTE (|CancellationAbelianMonoid|))) (|HasCategory| |#3| (QUOTE (|AbelianSemiGroup|))) (|HasCategory| |#3| (QUOTE (|CoercibleTo| (|OutputForm|)))) #15# (AND #35# (|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #3#))) (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #3#))) 
+NIL 
+((OR (AND #1=(|HasCategory| |#3| (QUOTE (|AbelianGroup|))) #2=(|HasCategory| |#3| (|%list| (QUOTE |Evalable|) #3=(|devaluate| |#3|)))) (AND #4=(|HasCategory| |#3| (QUOTE (|CommutativeRing|))) #2#) (AND #5=(|HasCategory| |#3| (QUOTE (|DifferentialRing|))) #2#) (AND #6=(|HasCategory| |#3| (QUOTE (|Field|))) #2#) (AND #7=(|HasCategory| |#3| (QUOTE (|Finite|))) #2#) (AND #8=(|HasCategory| |#3| (QUOTE (|Monoid|))) #2#) (AND #9=(|HasCategory| |#3| (QUOTE (|OrderedAbelianMonoidSup|))) #2#) (AND #10=(|HasCategory| |#3| #11=(QUOTE (|OrderedSet|))) #2#) (AND #12=(|HasCategory| |#3| (QUOTE (|PartialDifferentialRing| #13=(|Symbol|)))) #2#) (AND #14=(|HasCategory| |#3| (QUOTE (|Ring|))) #2#) #15=(AND #16=(|HasCategory| |#3| (QUOTE (|SetCategory|))) #2#)) #6# (OR #4# #6# #14#) (OR #4# #6#) #14# #8# #9# (OR #9# #10#) #10# #7# (OR (AND #4# #17=(|HasCategory| |#3| (QUOTE (|LinearlyExplicitRingOver| #18=(|Integer|))))) (AND #5# #17#) (AND #6# #17#) (AND #17# #12#) #19=(AND #17# #14#)) #12# (OR #5# #12# #14#) #5# (OR #5# #20=(AND (|HasCategory| |#3| (QUOTE (|DifferentialSpace|))) #14#)) (OR #21=(AND (|HasCategory| |#3| (QUOTE (|PartialDifferentialSpace| #13#))) #14#) #12#) #16# (OR (AND #1# #22=(|HasCategory| |#3| (QUOTE (|RetractableTo| (|Fraction| #18#))))) (AND #4# #22#) (AND #5# #22#) (AND #6# #22#) (AND #7# #22#) (AND #8# #22#) (AND #9# #22#) (AND #10# #22#) (AND #12# #22#) (AND #22# #14#) #23=(AND #22# #16#)) (OR #24=(AND #1# #25=(|HasCategory| |#3| (QUOTE (|RetractableTo| #18#)))) #26=(AND #4# #25#) #27=(AND #5# #25#) #28=(AND #9# #25#) #29=(AND #10# #25#) #30=(AND #12# #25#) #31=(AND #25# #16#) #32=(AND #6# #25#) #33=(AND #7# #25#) #34=(AND #8# #25#) #14#) (OR #24# #26# #27# #28# #29# #30# #31# #32# #33# #34# (AND #25# #14#)) #35=(|HasCategory| |#3| (QUOTE (|BasicType|))) (|HasCategory| #18# #11#) #19# (OR (AND #5# #14#) #20#) (OR (AND #12# #14#) #21#) #31# (OR #31# #14#) #23# #21# #20# #4# #1# (|HasCategory| |#3| (QUOTE (|AbelianMonoid|))) (|HasCategory| |#3| (QUOTE (|CancellationAbelianMonoid|))) (|HasCategory| |#3| (QUOTE (|AbelianSemiGroup|))) (|HasCategory| |#3| (QUOTE (|CoercibleTo| (|OutputForm|)))) #15# (AND #35# (|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #3#))) (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #3#))) 
 (|DifferentialPolynomialCategory&| A R S V E) 
 ((|constructor| (NIL "\\spadtype{DifferentialPolynomialCategory} is a category constructor specifying basic functions in an ordinary differential polynomial ring with a given ordered set of differential indeterminates. In addition,{} it implements defaults for the basic functions. The functions \\spadfun{order} and \\spadfun{weight} are extended from the set of derivatives of differential indeterminates to the set of differential polynomials. Other operations provided on differential polynomials are \\spadfun{leader},{} \\spadfun{initial},{} \\spadfun{separant},{} \\spadfun{differentialVariables},{} and \\spadfun{isobaric?}. Furthermore,{} if the ground ring is a differential ring,{} then evaluation (substitution of differential indeterminates by elements of the ground ring or by differential polynomials) is provided by \\spadfun{eval}. A convenient way of referencing derivatives is provided by the functions \\spadfun{makeVariable}. \\blankline To construct a domain using this constructor,{} one needs to provide a ground ring \\spad{R},{} an ordered set \\spad{S} of differential indeterminates,{} a ranking \\spad{V} on the set of derivatives of the differential indeterminates,{} and a set \\spad{E} of exponents in bijection with the set of differential monomials in the given differential indeterminates. \\blankline")) (|separant| (($ $) "\\spad{separant(p)} returns the partial derivative of the differential polynomial \\spad{p} with respect to its leader.")) (|initial| (($ $) "\\spad{initial(p)} returns the leading coefficient when the differential polynomial \\spad{p} is written as a univariate polynomial in its leader.")) (|leader| ((|#4| $) "\\spad{leader(p)} returns the derivative of the highest rank appearing in the differential polynomial \\spad{p} Note: an error occurs if \\spad{p} is in the ground ring.")) (|isobaric?| (((|Boolean|) $) "\\spad{isobaric?(p)} returns \\spad{true} if every differential monomial appearing in the differential polynomial \\spad{p} has same weight,{} and returns \\spad{false} otherwise.")) (|weight| (((|NonNegativeInteger|) $ |#3|) "\\spad{weight(p, s)} returns the maximum weight of all differential monomials appearing in the differential polynomial \\spad{p} when \\spad{p} is viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.") (((|NonNegativeInteger|) $) "\\spad{weight(p)} returns the maximum weight of all differential monomials appearing in the differential polynomial \\spad{p}.")) (|weights| (((|List| (|NonNegativeInteger|)) $ |#3|) "\\spad{weights(p, s)} returns a list of weights of differential monomials appearing in the differential polynomial \\spad{p} when \\spad{p} is viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.") (((|List| (|NonNegativeInteger|)) $) "\\spad{weights(p)} returns a list of weights of differential monomials appearing in differential polynomial \\spad{p}.")) (|degree| (((|NonNegativeInteger|) $ |#3|) "\\spad{degree(p, s)} returns the maximum degree of the differential polynomial \\spad{p} viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(p)} returns the order of the differential polynomial \\spad{p},{} which is the maximum number of differentiations of a differential indeterminate,{} among all those appearing in \\spad{p}.") (((|NonNegativeInteger|) $ |#3|) "\\spad{order(p,s)} returns the order of the differential polynomial \\spad{p} in differential indeterminate \\spad{s}.")) (|differentialVariables| (((|List| |#3|) $) "\\spad{differentialVariables(p)} returns a list of differential indeterminates occurring in a differential polynomial \\spad{p}.")) (|makeVariable| (((|Mapping| $ (|NonNegativeInteger|)) $) "\\spad{makeVariable(p)} views \\spad{p} as an element of a differential ring,{} in such a way that the \\spad{n}-th derivative of \\spad{p} may be simply referenced as \\spad{z}.\\spad{n} where \\spad{z} := makeVariable(\\spad{p}). Note: In the interpreter,{} \\spad{z} is given as an internal map,{} which may be ignored.") (((|Mapping| $ (|NonNegativeInteger|)) |#3|) "\\spad{makeVariable(s)} views \\spad{s} as a differential indeterminate,{} in such a way that the \\spad{n}-th derivative of \\spad{s} may be simply referenced as \\spad{z}.\\spad{n} where \\spad{z} :=makeVariable(\\spad{s}). Note: In the interpreter,{} \\spad{z} is given as an internal map,{} which may be ignored."))) 
 NIL 
 ((|HasCategory| |#2| (QUOTE (|DifferentialRing|)))) 
 (|DifferentialPolynomialCategory| R S V E) 
 ((|constructor| (NIL "\\spadtype{DifferentialPolynomialCategory} is a category constructor specifying basic functions in an ordinary differential polynomial ring with a given ordered set of differential indeterminates. In addition,{} it implements defaults for the basic functions. The functions \\spadfun{order} and \\spadfun{weight} are extended from the set of derivatives of differential indeterminates to the set of differential polynomials. Other operations provided on differential polynomials are \\spadfun{leader},{} \\spadfun{initial},{} \\spadfun{separant},{} \\spadfun{differentialVariables},{} and \\spadfun{isobaric?}. Furthermore,{} if the ground ring is a differential ring,{} then evaluation (substitution of differential indeterminates by elements of the ground ring or by differential polynomials) is provided by \\spadfun{eval}. A convenient way of referencing derivatives is provided by the functions \\spadfun{makeVariable}. \\blankline To construct a domain using this constructor,{} one needs to provide a ground ring \\spad{R},{} an ordered set \\spad{S} of differential indeterminates,{} a ranking \\spad{V} on the set of derivatives of the differential indeterminates,{} and a set \\spad{E} of exponents in bijection with the set of differential monomials in the given differential indeterminates. \\blankline")) (|separant| (($ $) "\\spad{separant(p)} returns the partial derivative of the differential polynomial \\spad{p} with respect to its leader.")) (|initial| (($ $) "\\spad{initial(p)} returns the leading coefficient when the differential polynomial \\spad{p} is written as a univariate polynomial in its leader.")) (|leader| ((|#3| $) "\\spad{leader(p)} returns the derivative of the highest rank appearing in the differential polynomial \\spad{p} Note: an error occurs if \\spad{p} is in the ground ring.")) (|isobaric?| (((|Boolean|) $) "\\spad{isobaric?(p)} returns \\spad{true} if every differential monomial appearing in the differential polynomial \\spad{p} has same weight,{} and returns \\spad{false} otherwise.")) (|weight| (((|NonNegativeInteger|) $ |#2|) "\\spad{weight(p, s)} returns the maximum weight of all differential monomials appearing in the differential polynomial \\spad{p} when \\spad{p} is viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.") (((|NonNegativeInteger|) $) "\\spad{weight(p)} returns the maximum weight of all differential monomials appearing in the differential polynomial \\spad{p}.")) (|weights| (((|List| (|NonNegativeInteger|)) $ |#2|) "\\spad{weights(p, s)} returns a list of weights of differential monomials appearing in the differential polynomial \\spad{p} when \\spad{p} is viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.") (((|List| (|NonNegativeInteger|)) $) "\\spad{weights(p)} returns a list of weights of differential monomials appearing in differential polynomial \\spad{p}.")) (|degree| (((|NonNegativeInteger|) $ |#2|) "\\spad{degree(p, s)} returns the maximum degree of the differential polynomial \\spad{p} viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(p)} returns the order of the differential polynomial \\spad{p},{} which is the maximum number of differentiations of a differential indeterminate,{} among all those appearing in \\spad{p}.") (((|NonNegativeInteger|) $ |#2|) "\\spad{order(p,s)} returns the order of the differential polynomial \\spad{p} in differential indeterminate \\spad{s}.")) (|differentialVariables| (((|List| |#2|) $) "\\spad{differentialVariables(p)} returns a list of differential indeterminates occurring in a differential polynomial \\spad{p}.")) (|makeVariable| (((|Mapping| $ (|NonNegativeInteger|)) $) "\\spad{makeVariable(p)} views \\spad{p} as an element of a differential ring,{} in such a way that the \\spad{n}-th derivative of \\spad{p} may be simply referenced as \\spad{z}.\\spad{n} where \\spad{z} := makeVariable(\\spad{p}). Note: In the interpreter,{} \\spad{z} is given as an internal map,{} which may be ignored.") (((|Mapping| $ (|NonNegativeInteger|)) |#2|) "\\spad{makeVariable(s)} views \\spad{s} as a differential indeterminate,{} in such a way that the \\spad{n}-th derivative of \\spad{s} may be simply referenced as \\spad{z}.\\spad{n} where \\spad{z} :=makeVariable(\\spad{s}). Note: In the interpreter,{} \\spad{z} is given as an internal map,{} which may be ignored."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
 NIL 
 (|DequeueAggregate| S) 
 ((|constructor| (NIL "A dequeue is a doubly ended stack,{} that is,{} a bag where first items inserted are the first items extracted,{} at either the front or the back end of the data structure.")) (|reverse!| (($ $) "\\spad{reverse!(d)} destructively replaces \\spad{d} by its reverse dequeue,{} \\spadignore{i.e.} the top (front) element is now the bottom (back) element,{} and so on.")) (|extractBottom!| ((|#1| $) "\\spad{extractBottom!(d)} destructively extracts the bottom (back) element from the dequeue \\spad{d}. Error: if \\spad{d} is empty.")) (|extractTop!| ((|#1| $) "\\spad{extractTop!(d)} destructively extracts the top (front) element from the dequeue \\spad{d}. Error: if \\spad{d} is empty.")) (|insertBottom!| ((|#1| |#1| $) "\\spad{insertBottom!(x,d)} destructively inserts \\spad{x} into the dequeue \\spad{d} at the bottom (back) of the dequeue.")) (|insertTop!| ((|#1| |#1| $) "\\spad{insertTop!(x,d)} destructively inserts \\spad{x} into the dequeue \\spad{d},{} that is,{} at the top (front) of the dequeue. The element previously at the top of the dequeue becomes the second in the dequeue,{} and so on.")) (|bottom!| ((|#1| $) "\\spad{bottom!(d)} returns the element at the bottom (back) of the dequeue.")) (|top!| ((|#1| $) "\\spad{top!(d)} returns the element at the top (front) of the dequeue.")) (|height| (((|NonNegativeInteger|) $) "\\spad{height(d)} returns the number of elements in dequeue \\spad{d}. Note: \\axiom{height(\\spad{d}) = \\# \\spad{d}}.")) (|dequeue| (($ (|List| |#1|)) "\\spad{dequeue([x,y,...,z])} creates a dequeue with first (top or front) element \\spad{x},{} second element \\spad{y},{}...,{}and last (bottom or back) element \\spad{z}.") (($) "\\spad{dequeue()}\\$\\spad{D} creates an empty dequeue of type \\spad{D}."))) 
@@ -842,8 +842,8 @@ NIL
 NIL 
 (|DifferentialSparseMultivariatePolynomial| R S V) 
 ((|constructor| (NIL "\\spadtype{DifferentialSparseMultivariatePolynomial} implements an ordinary differential polynomial ring by combining a domain belonging to the category \\spadtype{DifferentialVariableCategory} with the domain \\spadtype{SparseMultivariatePolynomial}. \\blankline"))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#1| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| |#3| #5#)) (AND (|HasCategory| |#1| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| |#3| #7#)) (AND (|HasCategory| |#1| #9=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| |#3| #9#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| |#3| #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#3| #11#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #8#))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #12=(|HasCategory| |#1| #13=(QUOTE (|CharacteristicNonZero|))) #14=(|HasCategory| |#1| (QUOTE (|Algebra| #15=(|Fraction| #8#)))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #8#))) (OR #14# #16=(|HasCategory| |#1| (QUOTE (|RetractableTo| #15#)))) #16# (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #17=(|Symbol|)))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #17#))) (|HasCategory| |#1| (QUOTE (|Field|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #3# #18=(AND #1# (|HasCategory| $ #13#)) (OR #18# #12#)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#1| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| |#3| #5#)) (AND (|HasCategory| |#1| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| |#3| #7#)) (AND (|HasCategory| |#1| #9=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| |#3| #9#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| |#3| #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#3| #11#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #8#))) #12=(|HasCategory| |#1| (QUOTE (|Algebra| #13=(|Fraction| #8#)))) #14=(|HasCategory| |#1| #15=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #8#))) (OR #12# #16=(|HasCategory| |#1| (QUOTE (|RetractableTo| #13#)))) #16# (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #17=(|Symbol|)))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #17#))) (|HasCategory| |#1| (QUOTE (|Field|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #3# #18=(AND #1# (|HasCategory| $ #15#)) (OR #18# #14#)) 
 (|DifferentialVariableCategory&| A S) 
 ((|constructor| (NIL "\\spadtype{DifferentialVariableCategory} constructs the set of derivatives of a given set of (ordinary) differential indeterminates. If \\spad{x},{}...,{}\\spad{y} is an ordered set of differential indeterminates,{} and the prime notation is used for differentiation,{} then the set of derivatives (including zero-th order) of the differential indeterminates is \\spad{x},{}\\spad{x'},{}\\spad{x''},{}...,{} \\spad{y},{}\\spad{y'},{}\\spad{y''},{}... (Note: in the interpreter,{} the \\spad{n}-th derivative of \\spad{y} is displayed as \\spad{y} with a subscript \\spad{n}.) This set is viewed as a set of algebraic indeterminates,{} totally ordered in a way compatible with differentiation and the given order on the differential indeterminates. Such a total order is called a ranking of the differential indeterminates. \\blankline A domain in this category is needed to construct a differential polynomial domain. Differential polynomials are ordered by a ranking on the derivatives,{} and by an order (extending the ranking) on on the set of differential monomials. One may thus associate a domain in this category with a ranking of the differential indeterminates,{} just as one associates a domain in the category \\spadtype{OrderedAbelianMonoidSup} with an ordering of the set of monomials in a set of algebraic indeterminates. The ranking is specified through the binary relation \\spadfun{<}. For example,{} one may define one derivative to be less than another by lexicographically comparing first the \\spadfun{order},{} then the given order of the differential indeterminates appearing in the derivatives. This is the default implementation. \\blankline The notion of weight generalizes that of degree. A polynomial domain may be made into a graded ring if a weight function is given on the set of indeterminates,{} Very often,{} a grading is the first step in ordering the set of monomials. For differential polynomial domains,{} this constructor provides a function \\spadfun{weight},{} which allows the assignment of a non-negative number to each derivative of a differential indeterminate. For example,{} one may define the weight of a derivative to be simply its \\spadfun{order} (this is the default assignment). This weight function can then be extended to the set of all differential polynomials,{} providing a graded ring structure.")) (|weight| (((|NonNegativeInteger|) $) "\\spad{weight(v)} returns the weight of the derivative \\spad{v}.")) (|variable| ((|#2| $) "\\spad{variable(v)} returns \\spad{s} if \\spad{v} is any derivative of the differential indeterminate \\spad{s}.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(v)} returns \\spad{n} if \\spad{v} is the \\spad{n}-th derivative of any differential indeterminate.")) (|makeVariable| (($ |#2| (|NonNegativeInteger|)) "\\spad{makeVariable(s, n)} returns the \\spad{n}-th derivative of a differential indeterminate \\spad{s} as an algebraic indeterminate."))) 
 NIL 
@@ -913,8 +913,8 @@ NIL
 NIL 
 NIL 
 (|EuclideanModularRing| S R |Mod| |reduction| |merge| |exactQuo|) 
-((|constructor| (NIL "These domains are used for the factorization and gcds of univariate polynomials over the integers in order to work modulo different primes. See \\spadtype{ModularRing},{} \\spadtype{ModularField}")) (|inv| (($ $) "\\spad{inv(x)} \\undocumented")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(x)} \\undocumented")) (|exQuo| (((|Union| $ "failed") $ $) "\\spad{exQuo(x,y)} \\undocumented")) (|reduce| (($ |#2| |#3|) "\\spad{reduce(r,m)} \\undocumented")) (|coerce| ((|#2| $) "\\spad{coerce(x)} \\undocumented")) (|modulus| ((|#3| $) "\\spad{modulus(x)} \\undocumented"))) 
-((|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|constructor| (NIL "These domains are used for the factorization and gcds of univariate polynomials over the integers in order to work modulo different primes. See \\spadtype{ModularRing},{} \\spadtype{ModularField}")) (|inv| (($ $) "\\spad{inv(x)} \\undocumented")) (|exQuo| (((|Union| $ "failed") $ $) "\\spad{exQuo(x,y)} \\undocumented")) (|reduce| (($ |#2| |#3|) "\\spad{reduce(r,m)} \\undocumented")) (|modulus| ((|#3| $) "\\spad{modulus(x)} \\undocumented"))) 
+((|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|EntireRing&| S) 
 ((|constructor| (NIL "Entire Rings (non-commutative Integral Domains),{} \\spadignore{i.e.} a ring not necessarily commutative which has no zero divisors. \\blankline")) (|noZeroDivisors| ((|attribute|) "if a product is zero then one of the factors must be zero."))) 
@@ -922,7 +922,7 @@ NIL
 NIL 
 (|EntireRing|) 
 ((|constructor| (NIL "Entire Rings (non-commutative Integral Domains),{} \\spadignore{i.e.} a ring not necessarily commutative which has no zero divisors. \\blankline")) (|noZeroDivisors| ((|attribute|) "if a product is zero then one of the factors must be zero."))) 
-((|noZeroDivisors| . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T)) 
 NIL 
 (|Environment|) 
 ((|constructor| (NIL "\\indented{1}{Author: Gabriel Dos Reis} Date Created: October 24,{} 2007 Date Last Modified: March 18,{} 2010. An `Environment' is a stack of scope.")) (|categoryFrame| (($) "the current category environment in the interpreter.")) (|interactiveEnv| (($) "the current interactive environment in effect.")) (|currentEnv| (($) "the current normal environment in effect.")) (|putProperties| (($ (|Identifier|) (|List| (|Property|)) $) "\\spad{putProperties(n,props,e)} set the list of properties of \\spad{n} to \\spad{props} in \\spad{e}.")) (|getProperties| (((|List| (|Property|)) (|Identifier|) $) "\\spad{getBinding(n,e)} returns the list of properties of \\spad{n} in \\spad{e}.")) (|putProperty| (($ (|Identifier|) (|Identifier|) (|SExpression|) $) "\\spad{putProperty(n,p,v,e)} binds the property \\spad{(p,v)} to \\spad{n} in the topmost scope of \\spad{e}.")) (|getProperty| (((|Maybe| (|SExpression|)) (|Identifier|) (|Identifier|) $) "\\spad{getProperty(n,p,e)} returns the value of property with name \\spad{p} for the symbol \\spad{n} in environment \\spad{e}. Otherwise,{} \\spad{nothing}.")) (|scopes| (((|List| (|Scope|)) $) "\\spad{scopes(e)} returns the stack of scopes in environment \\spad{e}.")) (|empty| (($) "\\spad{empty()} constructs an empty environment"))) 
@@ -934,8 +934,8 @@ NIL
 NIL 
 (|Equation| S) 
 ((|constructor| (NIL "Equations as mathematical objects. All properties of the basis domain,{} \\spadignore{e.g.} being an abelian group are carried over the equation domain,{} by performing the structural operations on the left and on the right hand side.")) (|subst| (($ $ $) "\\spad{subst(eq1,eq2)} substitutes \\spad{eq2} into both sides of \\spad{eq1} the lhs of \\spad{eq2} should be a kernel")) (|inv| (($ $) "\\spad{inv(x)} returns the multiplicative inverse of \\spad{x}.")) (/ (($ $ $) "\\spad{e1/e2} produces a new equation by dividing the left and right hand sides of equations \\spad{e1} and \\spad{e2}.")) (|factorAndSplit| (((|List| $) $) "\\spad{factorAndSplit(eq)} make the right hand side 0 and factors the new left hand side. Each factor is equated to 0 and put into the resulting list without repetitions.")) (|rightOne| (((|Union| $ "failed") $) "\\spad{rightOne(eq)} divides by the right hand side.") (((|Union| $ "failed") $) "\\spad{rightOne(eq)} divides by the right hand side,{} if possible.")) (|leftOne| (((|Union| $ "failed") $) "\\spad{leftOne(eq)} divides by the left hand side.") (((|Union| $ "failed") $) "\\spad{leftOne(eq)} divides by the left hand side,{} if possible.")) (* (($ $ |#1|) "\\spad{eqn*x} produces a new equation by multiplying both sides of equation eqn by \\spad{x}.") (($ |#1| $) "\\spad{x*eqn} produces a new equation by multiplying both sides of equation eqn by \\spad{x}.")) (- (($ $ |#1|) "\\spad{eqn-x} produces a new equation by subtracting \\spad{x} from both sides of equation eqn.") (($ |#1| $) "\\spad{x-eqn} produces a new equation by subtracting both sides of equation eqn from \\spad{x}.")) (|rightZero| (($ $) "\\spad{rightZero(eq)} subtracts the right hand side.")) (|leftZero| (($ $) "\\spad{leftZero(eq)} subtracts the left hand side.")) (+ (($ $ |#1|) "\\spad{eqn+x} produces a new equation by adding \\spad{x} to both sides of equation eqn.") (($ |#1| $) "\\spad{x+eqn} produces a new equation by adding \\spad{x} to both sides of equation eqn.")) (|eval| (($ $ (|List| $)) "\\spad{eval(eqn, [x1=v1, ... xn=vn])} replaces \\spad{xi} by \\spad{vi} in equation \\spad{eqn}.") (($ $ $) "\\spad{eval(eqn, x=f)} replaces \\spad{x} by \\spad{f} in equation \\spad{eqn}.")) (|rhs| ((|#1| $) "\\spad{rhs(eqn)} returns the right hand side of equation \\spad{eqn}.")) (|lhs| ((|#1| $) "\\spad{lhs(eqn)} returns the left hand side of equation \\spad{eqn}.")) (|swap| (($ $) "\\spad{swap(eq)} interchanges left and right hand side of equation \\spad{eq}.")) (|equation| (($ |#1| |#1|) "\\spad{equation(a,b)} creates an equation.")) (= (($ |#1| |#1|) "\\spad{a=b} creates an equation."))) 
-((|unitsKnown| OR (|has| |#1| #1=(|Ring|)) (|has| |#1| (|Group|))) (|rightUnitary| |has| |#1| . #2=(#1#)) (|leftUnitary| |has| |#1| . #2#)) 
-(#1=(|HasCategory| |#1| (QUOTE (|Field|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #1# #3=(|HasCategory| |#1| (QUOTE (|Ring|)))) (OR #2# #1#) #4=(|HasCategory| |#1| (QUOTE (|AbelianGroup|))) #3# #5=(|HasCategory| |#1| (QUOTE (|SetCategory|))) #2# #6=(|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #7=(|Symbol|)))) (OR #6# #3#) (OR #4# #8=(|HasCategory| |#1| (QUOTE (|AbelianSemiGroup|))) #2# #1# #6# #3#) (OR #4# #2# #1# #6# #3#) (OR #2# #3#) (OR #9=(|HasCategory| |#1| (QUOTE (|Group|))) #10=(|HasCategory| |#1| (QUOTE (|Monoid|)))) #9# (OR #4# #8# #2# #1# #9# #10# #6# #3# #11=(|HasCategory| |#1| (QUOTE (|SemiGroup|))) #5#) (OR #9# #10# #11#) (|HasCategory| |#1| (|%list| (QUOTE |InnerEvalable|) (QUOTE #7#) #12=(|devaluate| |#1|))) (AND #5# (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) #12#))) (|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (|HasCategory| |#1| (QUOTE (|ExpressionSpace|))) (OR #1# #9#) (OR #4# #10#) (OR #9# #3#) #8# #11# #10#) 
+NIL 
+(#1=(|HasCategory| |#1| (QUOTE (|Field|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #1# #3=(|HasCategory| |#1| (QUOTE (|Ring|)))) (OR #2# #1#) #4=(|HasCategory| |#1| (QUOTE (|AbelianGroup|))) #3# #5=(|HasCategory| |#1| (QUOTE (|SetCategory|))) #2# #6=(|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #7=(|Symbol|)))) (OR #6# #3#) (OR #4# #8=(|HasCategory| |#1| (QUOTE (|AbelianSemiGroup|))) #2# #1# #6# #3#) (OR #4# #2# #1# #6# #3#) (OR #2# #3#) (OR #9=(|HasCategory| |#1| (QUOTE (|Group|))) #10=(|HasCategory| |#1| (QUOTE (|Monoid|)))) #9# (OR #4# #8# #2# #1# #9# #10# #6# #3# #11=(|HasCategory| |#1| (QUOTE (|SemiGroup|))) #5#) (OR #9# #10# #11#) (|HasCategory| |#1| (|%list| (QUOTE |InnerEvalable|) (QUOTE #7#) #12=(|devaluate| |#1|))) (AND #5# (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) #12#))) (|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (|HasCategory| |#1| (QUOTE (|ExpressionSpace|))) (OR #1# #9#) (OR #4# #10#) #8# #11# #10#) 
 (|EquationFunctions2| S R) 
 ((|constructor| (NIL "This package provides operations for mapping the sides of equations.")) (|map| (((|Equation| |#2|) (|Mapping| |#2| |#1|) (|Equation| |#1|)) "\\spad{map(f,eq)} returns an equation where \\spad{f} is applied to the sides of \\spad{eq}"))) 
 NIL 
@@ -970,7 +970,7 @@ NIL
 NIL 
 (|EuclideanDomain|) 
 ((|constructor| (NIL "A constructive euclidean domain,{} \\spadignore{i.e.} one can divide producing a quotient and a remainder where the remainder is either zero or is smaller (\\spadfun{euclideanSize}) than the divisor. \\blankline Conditional attributes: \\indented{2}{multiplicativeValuation\\tab{25}\\spad{Size(a*b)=Size(a)*Size(b)}} \\indented{2}{additiveValuation\\tab{25}\\spad{Size(a*b)=Size(a)+Size(b)}}")) (|multiEuclidean| (((|Union| (|List| $) "failed") (|List| $) $) "\\spad{multiEuclidean([f1,...,fn],z)} returns a list of coefficients \\spad{[a1, ..., an]} such that \\spad{ z / prod fi = sum aj/fj}. If no such list of coefficients exists,{} \"failed\" is returned.")) (|extendedEuclidean| (((|Union| (|Record| (|:| |coef1| $) (|:| |coef2| $)) "failed") $ $ $) "\\spad{extendedEuclidean(x,y,z)} either returns a record rec where \\spad{rec.coef1*x+rec.coef2*y=z} or returns \"failed\" if \\spad{z} cannot be expressed as a linear combination of \\spad{x} and \\spad{y}.") (((|Record| (|:| |coef1| $) (|:| |coef2| $) (|:| |generator| $)) $ $) "\\spad{extendedEuclidean(x,y)} returns a record rec where \\spad{rec.coef1*x+rec.coef2*y = rec.generator} and rec.generator is a gcd of \\spad{x} and \\spad{y}. The gcd is unique only up to associates if \\spadatt{canonicalUnitNormal} is not asserted. \\spadfun{principalIdeal} provides a version of this operation which accepts an arbitrary length list of arguments.")) (|rem| (($ $ $) "\\spad{x rem y} is the same as \\spad{divide(x,y).remainder}. See \\spadfunFrom{divide}{EuclideanDomain}.")) (|quo| (($ $ $) "\\spad{x quo y} is the same as \\spad{divide(x,y).quotient}. See \\spadfunFrom{divide}{EuclideanDomain}.")) (|divide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\spad{divide(x,y)} divides \\spad{x} by \\spad{y} producing a record containing a \\spad{quotient} and \\spad{remainder},{} where the remainder is smaller (see \\spadfunFrom{sizeLess?}{EuclideanDomain}) than the divisor \\spad{y}.")) (|euclideanSize| (((|NonNegativeInteger|) $) "\\spad{euclideanSize(x)} returns the euclidean size of the element \\spad{x}. Error: if \\spad{x} is zero.")) (|sizeLess?| (((|Boolean|) $ $) "\\spad{sizeLess?(x,y)} tests whether \\spad{x} is strictly smaller than \\spad{y} with respect to the \\spadfunFrom{euclideanSize}{EuclideanDomain}."))) 
-((|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|Evalable&| S R) 
 ((|constructor| (NIL "This category provides \\spadfun{eval} operations. A domain may belong to this category if it is possible to make ``evaluation'' substitutions.")) (|eval| (($ $ (|List| (|Equation| |#2|))) "\\spad{eval(f, [x1 = v1,...,xn = vn])} replaces \\spad{xi} by \\spad{vi} in \\spad{f}.") (($ $ (|Equation| |#2|)) "\\spad{eval(f,x = v)} replaces \\spad{x} by \\spad{v} in \\spad{f}."))) 
@@ -994,12 +994,12 @@ NIL
 NIL 
 (|ExponentialExpansion| R FE |var| |cen|) 
 ((|constructor| (NIL "UnivariatePuiseuxSeriesWithExponentialSingularity is a domain used to represent essential singularities of functions. Objects in this domain are quotients of sums,{} where each term in the sum is a univariate Puiseux series times the exponential of a univariate Puiseux series.")) (|coerce| (($ (|UnivariatePuiseuxSeries| |#2| |#3| |#4|)) "\\spad{coerce(f)} converts a \\spadtype{UnivariatePuiseuxSeries} to an \\spadtype{ExponentialExpansion}.")) (|limitPlus| (((|Union| (|OrderedCompletion| |#2|) "failed") $) "\\spad{limitPlus(f(var))} returns \\spad{limit(var -> a+,f(var))}."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| #2=(|UnivariatePuiseuxSeriesWithExponentialSingularity| |#1| |#2| |#3| |#4|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #8=(|Integer|)))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #9=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #8#))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (|%list| (QUOTE |InnerEvalable|) (QUOTE #3#) #10=(|%list| (QUOTE |UnivariatePuiseuxSeriesWithExponentialSingularity|) (|devaluate| |#1|) (|devaluate| |#2|) (|devaluate| |#3|) (|devaluate| |#4|)))) (|HasCategory| #2# (|%list| (QUOTE |Evalable|) #10#)) (|HasCategory| #2# (|%list| (QUOTE |Eltable|) #10# #10#)) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) #11=(AND (|HasCategory| $ #5#) #1#) (OR #11# #4#)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
+(#1=(|HasCategory| #2=(|UnivariatePuiseuxSeriesWithExponentialSingularity| |#1| |#2| |#3| |#4|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #8=(|Integer|)))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #9=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #8#))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (|%list| (QUOTE |InnerEvalable|) (QUOTE #3#) #10=(|%list| (QUOTE |UnivariatePuiseuxSeriesWithExponentialSingularity|) (|devaluate| |#1|) (|devaluate| |#2|) (|devaluate| |#3|) (|devaluate| |#4|)))) (|HasCategory| #2# (|%list| (QUOTE |Evalable|) #10#)) (|HasCategory| #2# (|%list| (QUOTE |Eltable|) #10# #10#)) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) #11=(AND (|HasCategory| $ #5#) #1#) (OR #11# #4#)) 
 (|Expression| R) 
 ((|constructor| (NIL "Expressions involving symbolic functions.")) (|squareFreePolynomial| (((|Factored| (|SparseUnivariatePolynomial| $)) (|SparseUnivariatePolynomial| $)) "\\spad{squareFreePolynomial(p)} \\undocumented{}")) (|factorPolynomial| (((|Factored| (|SparseUnivariatePolynomial| $)) (|SparseUnivariatePolynomial| $)) "\\spad{factorPolynomial(p)} \\undocumented{}")) (|simplifyPower| (($ $ (|Integer|)) "simplifyPower?(\\spad{f},{}\\spad{n}) \\undocumented{}")) (|number?| (((|Boolean|) $) "\\spad{number?(f)} tests if \\spad{f} is rational")) (|reduce| (($ $) "\\spad{reduce(f)} simplifies all the unreduced algebraic quantities present in \\spad{f} by applying their defining relations."))) 
-((|unitsKnown| OR (AND (|has| |#1| #1=(|IntegralDomain|)) (OR #2=(|has| |#1| (|Ring|)) #3=(|has| |#1| (|Group|)))) #2# #3#) (|leftUnitary| |has| |#1| . #4=((|CommutativeRing|))) (|rightUnitary| |has| |#1| . #4#) ((|commutative| "*") |has| |#1| . #5=(#1#)) (|noZeroDivisors| |has| |#1| . #5#) (|canonicalUnitNormal| |has| |#1| . #5#) (|canonicalsClosed| |has| |#1| . #5#)) 
-((OR #1=(AND #2=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #3=(|HasCategory| |#1| #4=(QUOTE (|RetractableTo| #5=(|Integer|))))) #6=(|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #5#))))) #2# (OR #2# #7=(|HasCategory| |#1| #8=(QUOTE (|Ring|)))) #7# #9=(|HasCategory| |#1| (QUOTE (|AbelianGroup|))) (OR #2# #6#) #10=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #11=(|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) #12=(|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (OR #10# #7#) (OR (AND #11# #13=(|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #5#)))) (AND #12# #13#) (AND #10# #13#) (AND #2# #13#) #14=(AND #13# #7#)) (OR #15=(|HasCategory| |#1| (QUOTE (|Group|))) #16=(|HasCategory| |#1| (QUOTE (|SemiGroup|)))) #15# (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|)))) (OR #3# #7#) #3# (|HasCategory| |#1| (QUOTE (|PatternMatchable| #17=(|Float|)))) (|HasCategory| |#1| (QUOTE (|PatternMatchable| #5#))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|Pattern| #17#)))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|Pattern| #5#)))) #1# (OR #9# #18=(|HasCategory| |#1| (QUOTE (|AbelianSemiGroup|))) #11# #12# #10# #2# #7#) (OR #9# #11# #12# #10# #2# #7#) (OR #11# #12# #10# #2# #7#) (AND (|HasCategory| |#1| (QUOTE (|GcdDomain|))) #2#) (OR #15# #2#) #14# (OR #14# #9#) (OR #14# #18# #16#) (OR #14# #18#) (OR #15# #7#) (OR (AND #2# #6#) #1#) #18# #16# #6# (|HasCategory| $ #8#) (|HasCategory| $ #4#)) 
+(((|commutative| "*") |has| |#1| . #1=((|IntegralDomain|))) (|noZeroDivisors| |has| |#1| . #1#) (|canonicalUnitNormal| |has| |#1| . #1#)) 
+((OR #1=(AND #2=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #3=(|HasCategory| |#1| #4=(QUOTE (|RetractableTo| #5=(|Integer|))))) #6=(|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #5#))))) #2# (OR #2# #7=(|HasCategory| |#1| #8=(QUOTE (|Ring|)))) #7# #9=(|HasCategory| |#1| (QUOTE (|AbelianGroup|))) (OR #2# #6#) #10=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #11=(|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) #12=(|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (OR #10# #7#) (OR (AND #11# #13=(|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #5#)))) (AND #12# #13#) (AND #10# #13#) (AND #2# #13#) #14=(AND #13# #7#)) (OR #15=(|HasCategory| |#1| (QUOTE (|Group|))) #16=(|HasCategory| |#1| (QUOTE (|SemiGroup|)))) #15# (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|)))) (OR #3# #7#) #3# (|HasCategory| |#1| (QUOTE (|PatternMatchable| #17=(|Float|)))) (|HasCategory| |#1| (QUOTE (|PatternMatchable| #5#))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|Pattern| #17#)))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|Pattern| #5#)))) #1# (OR #9# #18=(|HasCategory| |#1| (QUOTE (|AbelianSemiGroup|))) #11# #12# #10# #2# #7#) (OR #9# #11# #12# #10# #2# #7#) (OR #11# #12# #10# #2# #7#) (AND (|HasCategory| |#1| (QUOTE (|GcdDomain|))) #2#) (OR #15# #2#) #14# (OR #14# #9#) (OR #14# #18# #16#) (OR #14# #18#) (OR (AND #2# #6#) #1#) #18# #16# #6# (|HasCategory| $ #8#) (|HasCategory| $ #4#)) 
 (|ExpressionFunctions2| R S) 
 ((|constructor| (NIL "Lifting of maps to Expressions. Date Created: 16 Jan 1989 Date Last Updated: 22 Jan 1990")) (|map| (((|Expression| |#2|) (|Mapping| |#2| |#1|) (|Expression| |#1|)) "\\spad{map(f, e)} applies \\spad{f} to all the constants appearing in \\spad{e}."))) 
 NIL 
@@ -1018,7 +1018,7 @@ NIL
 NIL 
 (|ExponentialOfUnivariatePuiseuxSeries| FE |var| |cen|) 
 ((|constructor| (NIL "ExponentialOfUnivariatePuiseuxSeries is a domain used to represent essential singularities of functions. An object in this domain is a function of the form \\spad{exp(f(x))},{} where \\spad{f(x)} is a Puiseux series with no terms of non-negative degree. Objects are ordered according to order of singularity,{} with functions which tend more rapidly to zero or infinity considered to be larger. Thus,{} if \\spad{order(f(x)) < order(g(x))},{} \\spadignore{i.e.} the first non-zero term of \\spad{f(x)} has lower degree than the first non-zero term of \\spad{g(x)},{} then \\spad{exp(f(x)) > exp(g(x))}. If \\spad{order(f(x)) = order(g(x))},{} then the ordering is essentially random. This domain is used in computing limits involving functions with essential singularities.")) (|exponentialOrder| (((|Fraction| (|Integer|)) $) "\\spad{exponentialOrder(exp(c * x **(-n) + ...))} returns \\spad{-n}. exponentialOrder(0) returns \\spad{0}.")) (|exponent| (((|UnivariatePuiseuxSeries| |#1| |#2| |#3|) $) "\\spad{exponent(exp(f(x)))} returns \\spad{f(x)}")) (|exponential| (($ (|UnivariatePuiseuxSeries| |#1| |#2| |#3|)) "\\spad{exponential(f(x))} returns \\spad{exp(f(x))}. Note: the function does NOT check that \\spad{f(x)} has no non-negative terms."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| . #1=((|Field|))) (|canonicalsClosed| |has| |#1| . #1#) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (|Field|))) 
 (#1=(|HasCategory| |#1| (QUOTE (|Algebra| #2=(|Fraction| #3=(|Integer|))))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #5=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #5# #4#) (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (AND (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #6=(|Symbol|)))) #7=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #8=(|devaluate| |#1|) #9=(|%list| (QUOTE |Fraction|) (QUOTE #3#)) #8#)))) #7# (|HasCategory| #2# (QUOTE (|SemiGroup|))) #10=(|HasCategory| |#1| (QUOTE (|Field|))) (OR #5# #10# #4#) (OR #10# #4#) (AND #11=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #8# #8# #9#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #8# #12=(QUOTE #6#))))) #11# (OR (AND #1# (|HasCategory| |#1| (QUOTE (|AlgebraicallyClosedFunctionSpace| #3#))) (|HasCategory| |#1| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) (AND #1# (|HasSignature| |#1| (|%list| (QUOTE |integrate|) (|%list| #8# #8# #12#))) (|HasSignature| |#1| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #12#) #8#)))))) 
 (|FactoredFunctions| M) 
 ((|constructor| (NIL "computes various functions on factored arguments.")) (|log| (((|List| (|Record| (|:| |coef| (|NonNegativeInteger|)) (|:| |logand| |#1|))) (|Factored| |#1|)) "\\spad{log(f)} returns \\spad{[(a1,b1),...,(am,bm)]} such that the logarithm of \\spad{f} is equal to \\spad{a1*log(b1) + ... + am*log(bm)}.")) (|nthRoot| (((|Record| (|:| |exponent| (|NonNegativeInteger|)) (|:| |coef| |#1|) (|:| |radicand| (|List| |#1|))) (|Factored| |#1|) (|NonNegativeInteger|)) "\\spad{nthRoot(f, n)} returns \\spad{(p, r, [r1,...,rm])} such that the \\spad{n}th-root of \\spad{f} is equal to \\spad{r * \\spad{p}th-root(r1 * ... * rm)},{} where \\spad{r1},{}...,{}rm are distinct factors of \\spad{f},{} each of which has an exponent smaller than \\spad{p} in \\spad{f}."))) 
@@ -1030,7 +1030,7 @@ NIL
 NIL 
 (|FreeAbelianGroup| S) 
 ((|constructor| (NIL "The free abelian group on a set \\spad{S} is the monoid of finite sums of the form \\spad{reduce(+,[ni * si])} where the \\spad{si}'s are in \\spad{S},{} and the \\spad{ni}'s are integers. The operation is commutative."))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|OrderedSet|))) (|HasCategory| (|Integer|) (QUOTE (|OrderedAbelianMonoid|)))) 
 (|FreeAbelianMonoidCategory| S E) 
 ((|constructor| (NIL "A free abelian monoid on a set \\spad{S} is the monoid of finite sums of the form \\spad{reduce(+,[ni * si])} where the \\spad{si}'s are in \\spad{S},{} and the \\spad{ni}'s are in a given abelian monoid. The operation is commutative.")) (|highCommonTerms| (($ $ $) "\\spad{highCommonTerms(e1 a1 + ... + en an, f1 b1 + ... + fm bm)} returns \\indented{2}{\\spad{reduce(+,[max(ei, fi) ci])}} where \\spad{ci} ranges in the intersection of \\spad{{a1,...,an}} and \\spad{{b1,...,bm}}.")) (|mapGen| (($ (|Mapping| |#1| |#1|) $) "\\spad{mapGen(f, e1 a1 +...+ en an)} returns \\spad{e1 f(a1) +...+ en f(an)}.")) (|mapCoef| (($ (|Mapping| |#2| |#2|) $) "\\spad{mapCoef(f, e1 a1 +...+ en an)} returns \\spad{f(e1) a1 +...+ f(en) an}.")) (|coefficient| ((|#2| |#1| $) "\\spad{coefficient(s, e1 a1 + ... + en an)} returns \\spad{ei} such that \\spad{ai} = \\spad{s},{} or 0 if \\spad{s} is not one of the \\spad{ai}'s.")) (|nthFactor| ((|#1| $ (|Integer|)) "\\spad{nthFactor(x, n)} returns the factor of the n^th term of \\spad{x}.")) (|nthCoef| ((|#2| $ (|Integer|)) "\\spad{nthCoef(x, n)} returns the coefficient of the n^th term of \\spad{x}.")) (|terms| (((|List| (|Record| (|:| |gen| |#1|) (|:| |exp| |#2|))) $) "\\spad{terms(e1 a1 + ... + en an)} returns \\spad{[[a1, e1],...,[an, en]]}.")) (|size| (((|NonNegativeInteger|) $) "\\spad{size(x)} returns the number of terms in \\spad{x}. mapGen(\\spad{f},{} \\spad{a1}\\^\\spad{e1} ... an\\^en) returns \\spad{f(a1)\\^e1 ... f(an)\\^en}.")) (* (($ |#2| |#1|) "\\spad{e * s} returns \\spad{e} times \\spad{s}.")) (+ (($ |#1| $) "\\spad{s + x} returns the sum of \\spad{s} and \\spad{x}."))) 
@@ -1046,7 +1046,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|GcdDomain|))) (|HasCategory| |#2| (QUOTE (|IntegralDomain|))) (|HasCategory| |#2| (QUOTE (|CommutativeRing|)))) 
 (|FiniteAbelianMonoidRing| R E) 
 ((|constructor| (NIL "This category is similar to AbelianMonoidRing,{} except that the sum is assumed to be finite. It is a useful model for polynomials,{} but is somewhat more general.")) (|primitivePart| (($ $) "\\spad{primitivePart(p)} returns the unit normalized form of polynomial \\spad{p} divided by the content of \\spad{p}.")) (|content| ((|#1| $) "\\spad{content(p)} gives the gcd of the coefficients of polynomial \\spad{p}.")) (|exquo| (((|Union| $ "failed") $ |#1|) "\\spad{exquo(p,r)} returns the exact quotient of polynomial \\spad{p} by \\spad{r},{} or \"failed\" if none exists.")) (|binomThmExpt| (($ $ $ (|NonNegativeInteger|)) "\\spad{binomThmExpt(p,q,n)} returns \\spad{(x+y)^n} by means of the binomial theorem trick.")) (|pomopo!| (($ $ |#1| |#2| $) "\\spad{pomopo!(p1,r,e,p2)} returns \\spad{p1 + monomial(e,r) * p2} and may use \\spad{p1} as workspace. The constaant \\spad{r} is assumed to be nonzero.")) (|mapExponents| (($ (|Mapping| |#2| |#2|) $) "\\spad{mapExponents(fn,u)} maps function \\spad{fn} onto the exponents of the non-zero monomials of polynomial \\spad{u}.")) (|minimumDegree| ((|#2| $) "\\spad{minimumDegree(p)} gives the least exponent of a non-zero term of polynomial \\spad{p}. Error: if applied to 0.")) (|numberOfMonomials| (((|NonNegativeInteger|) $) "\\spad{numberOfMonomials(p)} gives the number of non-zero monomials in polynomial \\spad{p}.")) (|coefficients| (((|List| |#1|) $) "\\spad{coefficients(p)} gives the list of non-zero coefficients of polynomial \\spad{p}.")) (|ground| ((|#1| $) "\\spad{ground(p)} retracts polynomial \\spad{p} to the coefficient ring.")) (|ground?| (((|Boolean|) $) "\\spad{ground?(p)} tests if polynomial \\spad{p} is a member of the coefficient ring."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|))) 
 NIL 
 (|FlexibleArray| S) 
 ((|constructor| (NIL "\\indented{1}{A FlexibleArray is the notion of an array intended to allow for growth} at the end only. Hence the following efficient operations \\indented{2}{\\spad{append(x,a)} meaning append item \\spad{x} at the end of the array \\spad{a}} \\indented{2}{\\spad{delete(a,n)} meaning delete the last item from the array \\spad{a}} Flexible arrays support the other operations inherited from \\spadtype{ExtensibleLinearAggregate}. However,{} these are not efficient. Flexible arrays combine the \\spad{O(1)} access time property of arrays with growing and shrinking at the end in \\spad{O(1)} (average) time. This is done by using an ordinary array which may have zero or more empty slots at the end. When the array becomes full it is copied into a new larger (50\\% larger) array. Conversely,{} when the array becomes less than 1/2 full,{} it is copied into a smaller array. Flexible arrays provide for an efficient implementation of many data structures in particular heaps,{} stacks and sets."))) 
@@ -1058,7 +1058,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|Finite|)))) 
 (|FiniteAlgebraicExtensionField| F) 
 ((|constructor| (NIL "FiniteAlgebraicExtensionField {\\em F} is the category of fields which are finite algebraic extensions of the field {\\em F}. If {\\em F} is finite then any finite algebraic extension of {\\em F} is finite,{} too. Let {\\em K} be a finite algebraic extension of the finite field {\\em F}. The exponentiation of elements of {\\em K} defines a \\spad{Z}-module structure on the multiplicative group of {\\em K}. The additive group of {\\em K} becomes a module over the ring of polynomials over {\\em F} via the operation \\spadfun{linearAssociatedExp}(a:K,{}f:SparseUnivariatePolynomial \\spad{F}) which is linear over {\\em F},{} \\spadignore{i.e.} for elements {\\em a} from {\\em K},{} {\\em c,d} from {\\em F} and {\\em f,g} univariate polynomials over {\\em F} we have \\spadfun{linearAssociatedExp}(a,{}cf+dg) equals {\\em c} times \\spadfun{linearAssociatedExp}(a,{}\\spad{f}) plus {\\em d} times \\spadfun{linearAssociatedExp}(a,{}\\spad{g}). Therefore \\spadfun{linearAssociatedExp} is defined completely by its action on monomials from {\\em F[X]}: \\spadfun{linearAssociatedExp}(a,{}monomial(1,{}\\spad{k})\\$SUP(\\spad{F})) is defined to be \\spadfun{Frobenius}(a,{}\\spad{k}) which is {\\em a**(q**k)} where {\\em q=size()\\$F}. The operations order and discreteLog associated with the multiplicative exponentiation have additive analogues associated to the operation \\spadfun{linearAssociatedExp}. These are the functions \\spadfun{linearAssociatedOrder} and \\spadfun{linearAssociatedLog},{} respectively.")) (|linearAssociatedLog| (((|Union| (|SparseUnivariatePolynomial| |#1|) "failed") $ $) "\\spad{linearAssociatedLog(b,a)} returns a polynomial {\\em g},{} such that the \\spadfun{linearAssociatedExp}(\\spad{b},{}\\spad{g}) equals {\\em a}. If there is no such polynomial {\\em g},{} then \\spadfun{linearAssociatedLog} fails.") (((|SparseUnivariatePolynomial| |#1|) $) "\\spad{linearAssociatedLog(a)} returns a polynomial {\\em g},{} such that \\spadfun{linearAssociatedExp}(normalElement(),{}\\spad{g}) equals {\\em a}.")) (|linearAssociatedOrder| (((|SparseUnivariatePolynomial| |#1|) $) "\\spad{linearAssociatedOrder(a)} retruns the monic polynomial {\\em g} of least degree,{} such that \\spadfun{linearAssociatedExp}(a,{}\\spad{g}) is 0.")) (|linearAssociatedExp| (($ $ (|SparseUnivariatePolynomial| |#1|)) "\\spad{linearAssociatedExp(a,f)} is linear over {\\em F},{} \\spadignore{i.e.} for elements {\\em a} from {\\em \\$},{} {\\em c,d} form {\\em F} and {\\em f,g} univariate polynomials over {\\em F} we have \\spadfun{linearAssociatedExp}(a,{}cf+dg) equals {\\em c} times \\spadfun{linearAssociatedExp}(a,{}\\spad{f}) plus {\\em d} times \\spadfun{linearAssociatedExp}(a,{}\\spad{g}). Therefore \\spadfun{linearAssociatedExp} is defined completely by its action on monomials from {\\em F[X]}: \\spadfun{linearAssociatedExp}(a,{}monomial(1,{}\\spad{k})\\$SUP(\\spad{F})) is defined to be \\spadfun{Frobenius}(a,{}\\spad{k}) which is {\\em a**(q**k)},{} where {\\em q=size()\\$F}.")) (|generator| (($) "\\spad{generator()} returns a root of the defining polynomial. This element generates the field as an algebra over the ground field.")) (|normal?| (((|Boolean|) $) "\\spad{normal?(a)} tests whether the element \\spad{a} is normal over the ground field \\spad{F},{} \\spadignore{i.e.} \\spad{a**(q**i), 0 <= i <= extensionDegree()-1} is an \\spad{F}-basis,{} where \\spad{q = size()\\$F}. Implementation according to Lidl/Niederreiter: Theorem 2.39.")) (|normalElement| (($) "\\spad{normalElement()} returns a element,{} normal over the ground field \\spad{F},{} \\spadignore{i.e.} \\spad{a**(q**i), 0 <= i < extensionDegree()} is an \\spad{F}-basis,{} where \\spad{q = size()\\$F}. At the first call,{} the element is computed by \\spadfunFrom{createNormalElement}{FiniteAlgebraicExtensionField} then cached in a global variable. On subsequent calls,{} the element is retrieved by referencing the global variable.")) (|createNormalElement| (($) "\\spad{createNormalElement()} computes a normal element over the ground field \\spad{F},{} that is,{} \\spad{a**(q**i), 0 <= i < extensionDegree()} is an \\spad{F}-basis,{} where \\spad{q = size()\\$F}. Reference: Such an element exists Lidl/Niederreiter: Theorem 2.35.")) (|trace| (($ $ (|PositiveInteger|)) "\\spad{trace(a,d)} computes the trace of \\spad{a} with respect to the field of extension degree \\spad{d} over the ground field of size \\spad{q}. Error: if \\spad{d} does not divide the extension degree of \\spad{a}. Note: \\spad{trace(a,d) = reduce(+,[a**(q**(d*i)) for i in 0..n/d])}.") ((|#1| $) "\\spad{trace(a)} computes the trace of \\spad{a} with respect to the field considered as an algebra with 1 over the ground field \\spad{F}.")) (|norm| (($ $ (|PositiveInteger|)) "\\spad{norm(a,d)} computes the norm of \\spad{a} with respect to the field of extension degree \\spad{d} over the ground field of size. Error: if \\spad{d} does not divide the extension degree of \\spad{a}. Note: norm(a,{}\\spad{d}) = reduce(*,{}[a**(q**(d*i)) for \\spad{i} in 0..n/d])") ((|#1| $) "\\spad{norm(a)} computes the norm of \\spad{a} with respect to the field considered as an algebra with 1 over the ground field \\spad{F}.")) (|degree| (((|PositiveInteger|) $) "\\spad{degree(a)} returns the degree of the minimal polynomial of an element \\spad{a} over the ground field \\spad{F}.")) (|extensionDegree| (((|PositiveInteger|)) "\\spad{extensionDegree()} returns the degree of field extension.")) (|definingPolynomial| (((|SparseUnivariatePolynomial| |#1|)) "\\spad{definingPolynomial()} returns the polynomial used to define the field extension.")) (|minimalPolynomial| (((|SparseUnivariatePolynomial| $) $ (|PositiveInteger|)) "\\spad{minimalPolynomial(x,n)} computes the minimal polynomial of \\spad{x} over the field of extension degree \\spad{n} over the ground field \\spad{F}.") (((|SparseUnivariatePolynomial| |#1|) $) "\\spad{minimalPolynomial(a)} returns the minimal polynomial of an element \\spad{a} over the ground field \\spad{F}.")) (|represents| (($ (|Vector| |#1|)) "\\spad{represents([a1,..,an])} returns \\spad{a1*v1 + ... + an*vn},{} where \\spad{v1},{}...,{}vn are the elements of the fixed basis.")) (|coordinates| (((|Matrix| |#1|) (|Vector| $)) "\\spad{coordinates([v1,...,vm])} returns the coordinates of the \\spad{vi}'s with to the fixed basis. The coordinates of \\spad{vi} are contained in the \\spad{i}th row of the matrix returned by this function.") (((|Vector| |#1|) $) "\\spad{coordinates(a)} returns the coordinates of \\spad{a} with respect to the fixed \\spad{F}-vectorspace basis.")) (|basis| (((|Vector| $) (|PositiveInteger|)) "\\spad{basis(n)} returns a fixed basis of a subfield of \\$ as \\spad{F}-vectorspace.") (((|Vector| $)) "\\spad{basis()} returns a fixed basis of \\$ as \\spad{F}-vectorspace."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|FourierComponent| E) 
 ((|constructor| (NIL "\\indented{1}{Author: James Davenport} Date Created: 17 April 1992 Date Last Updated: 12 June 1992 Basic Functions: Related Constructors: Also See: AMS Classifications: Keywords: References: Description:")) (|argument| ((|#1| $) "\\spad{argument(x)} returns the argument of a given sin/cos expressions")) (|sin?| (((|Boolean|) $) "\\spad{sin?(x)} returns \\spad{true} if term is a sin,{} otherwise \\spad{false}")) (|cos| (($ |#1|) "\\spad{cos(x)} makes a cos kernel for use in Fourier series")) (|sin| (($ |#1|) "\\spad{sin(x)} makes a sin kernel for use in Fourier series"))) 
@@ -1094,7 +1094,7 @@ NIL
 NIL 
 (|FiniteField| |p| |n|) 
 ((|constructor| (NIL "FiniteField(\\spad{p},{}\\spad{n}) implements finite fields with p**n elements. This packages checks that \\spad{p} is prime. For a non-checking version,{} see \\spadtype{InnerFiniteField}."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((OR #1=(|HasCategory| #2=(|PrimeField| |#1|) (QUOTE (|CharacteristicNonZero|))) #3=(|HasCategory| #2# (QUOTE (|Finite|)))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) #3# #1#) 
 (|FunctionFieldCategory&| S F UP UPUP) 
 ((|constructor| (NIL "This category is a model for the function field of a plane algebraic curve.")) (|rationalPoints| (((|List| (|List| |#2|))) "\\spad{rationalPoints()} returns the list of all the affine rational points.")) (|nonSingularModel| (((|List| (|Polynomial| |#2|)) (|Symbol|)) "\\spad{nonSingularModel(u)} returns the equations in \\spad{u1},{}...,{}un of an affine non-singular model for the curve.")) (|algSplitSimple| (((|Record| (|:| |num| $) (|:| |den| |#3|) (|:| |derivden| |#3|) (|:| |gd| |#3|)) $ (|Mapping| |#3| |#3|)) "\\spad{algSplitSimple(f, D)} returns \\spad{[h,d,d',g]} such that \\spad{f=h/d},{} \\spad{h} is integral at all the normal places \\spad{w}.\\spad{r}.\\spad{t}. \\spad{D},{} \\spad{d' = Dd},{} \\spad{g = gcd(d, discriminant())} and \\spad{D} is the derivation to use. \\spad{f} must have at most simple finite poles.")) (|hyperelliptic| (((|Union| |#3| "failed")) "\\spad{hyperelliptic()} returns \\spad{p(x)} if the curve is the hyperelliptic defined by \\spad{y**2 = p(x)},{} \"failed\" otherwise.")) (|elliptic| (((|Union| |#3| "failed")) "\\spad{elliptic()} returns \\spad{p(x)} if the curve is the elliptic defined by \\spad{y**2 = p(x)},{} \"failed\" otherwise.")) (|elt| ((|#2| $ |#2| |#2|) "\\spad{elt(f,a,b)} or \\spad{f}(a,{} \\spad{b}) returns the value of \\spad{f} at the point \\spad{(x = a, y = b)} if it is not singular.")) (|primitivePart| (($ $) "\\spad{primitivePart(f)} removes the content of the denominator and the common content of the numerator of \\spad{f}.")) (|differentiate| (($ $ (|Mapping| |#3| |#3|)) "\\spad{differentiate(x, d)} extends the derivation \\spad{d} from UP to \\$ and applies it to \\spad{x}.")) (|integralDerivationMatrix| (((|Record| (|:| |num| (|Matrix| |#3|)) (|:| |den| |#3|)) (|Mapping| |#3| |#3|)) "\\spad{integralDerivationMatrix(d)} extends the derivation \\spad{d} from UP to \\$ and returns (\\spad{M},{} \\spad{Q}) such that the i^th row of \\spad{M} divided by \\spad{Q} form the coordinates of \\spad{d(wi)} with respect to \\spad{(w1,...,wn)} where \\spad{(w1,...,wn)} is the integral basis returned by integralBasis().")) (|integralRepresents| (($ (|Vector| |#3|) |#3|) "\\spad{integralRepresents([A1,...,An], D)} returns \\spad{(A1 w1+...+An wn)/D} where \\spad{(w1,...,wn)} is the integral basis of \\spad{integralBasis()}.")) (|integralCoordinates| (((|Record| (|:| |num| (|Vector| |#3|)) (|:| |den| |#3|)) $) "\\spad{integralCoordinates(f)} returns \\spad{[[A1,...,An], D]} such that \\spad{f = (A1 w1 +...+ An wn) / D} where \\spad{(w1,...,wn)} is the integral basis returned by \\spad{integralBasis()}.")) (|represents| (($ (|Vector| |#3|) |#3|) "\\spad{represents([A0,...,A(n-1)],D)} returns \\spad{(A0 + A1 y +...+ A(n-1)*y**(n-1))/D}.")) (|yCoordinates| (((|Record| (|:| |num| (|Vector| |#3|)) (|:| |den| |#3|)) $) "\\spad{yCoordinates(f)} returns \\spad{[[A1,...,An], D]} such that \\spad{f = (A1 + A2 y +...+ An y**(n-1)) / D}.")) (|inverseIntegralMatrixAtInfinity| (((|Matrix| (|Fraction| |#3|))) "\\spad{inverseIntegralMatrixAtInfinity()} returns \\spad{M} such that \\spad{M (v1,...,vn) = (1, y, ..., y**(n-1))} where \\spad{(v1,...,vn)} is the local integral basis at infinity returned by \\spad{infIntBasis()}.")) (|integralMatrixAtInfinity| (((|Matrix| (|Fraction| |#3|))) "\\spad{integralMatrixAtInfinity()} returns \\spad{M} such that \\spad{(v1,...,vn) = M (1, y, ..., y**(n-1))} where \\spad{(v1,...,vn)} is the local integral basis at infinity returned by \\spad{infIntBasis()}.")) (|inverseIntegralMatrix| (((|Matrix| (|Fraction| |#3|))) "\\spad{inverseIntegralMatrix()} returns \\spad{M} such that \\spad{M (w1,...,wn) = (1, y, ..., y**(n-1))} where \\spad{(w1,...,wn)} is the integral basis of \\spadfunFrom{integralBasis}{FunctionFieldCategory}.")) (|integralMatrix| (((|Matrix| (|Fraction| |#3|))) "\\spad{integralMatrix()} returns \\spad{M} such that \\spad{(w1,...,wn) = M (1, y, ..., y**(n-1))},{} where \\spad{(w1,...,wn)} is the integral basis of \\spadfunFrom{integralBasis}{FunctionFieldCategory}.")) (|reduceBasisAtInfinity| (((|Vector| $) (|Vector| $)) "\\spad{reduceBasisAtInfinity(b1,...,bn)} returns \\spad{(x**i * bj)} for all \\spad{i},{}\\spad{j} such that \\spad{x**i*bj} is locally integral at infinity.")) (|normalizeAtInfinity| (((|Vector| $) (|Vector| $)) "\\spad{normalizeAtInfinity(v)} makes \\spad{v} normal at infinity.")) (|complementaryBasis| (((|Vector| $) (|Vector| $)) "\\spad{complementaryBasis(b1,...,bn)} returns the complementary basis \\spad{(b1',...,bn')} of \\spad{(b1,...,bn)}.")) (|integral?| (((|Boolean|) $ |#3|) "\\spad{integral?(f, p)} tests whether \\spad{f} is locally integral at \\spad{p(x) = 0}.") (((|Boolean|) $ |#2|) "\\spad{integral?(f, a)} tests whether \\spad{f} is locally integral at \\spad{x = a}.") (((|Boolean|) $) "\\spad{integral?()} tests if \\spad{f} is integral over \\spad{k[x]}.")) (|integralAtInfinity?| (((|Boolean|) $) "\\spad{integralAtInfinity?()} tests if \\spad{f} is locally integral at infinity.")) (|integralBasisAtInfinity| (((|Vector| $)) "\\spad{integralBasisAtInfinity()} returns the local integral basis at infinity.")) (|integralBasis| (((|Vector| $)) "\\spad{integralBasis()} returns the integral basis for the curve.")) (|ramified?| (((|Boolean|) |#3|) "\\spad{ramified?(p)} tests whether \\spad{p(x) = 0} is ramified.") (((|Boolean|) |#2|) "\\spad{ramified?(a)} tests whether \\spad{x = a} is ramified.")) (|ramifiedAtInfinity?| (((|Boolean|)) "\\spad{ramifiedAtInfinity?()} tests if infinity is ramified.")) (|singular?| (((|Boolean|) |#3|) "\\spad{singular?(p)} tests whether \\spad{p(x) = 0} is singular.") (((|Boolean|) |#2|) "\\spad{singular?(a)} tests whether \\spad{x = a} is singular.")) (|singularAtInfinity?| (((|Boolean|)) "\\spad{singularAtInfinity?()} tests if there is a singularity at infinity.")) (|branchPoint?| (((|Boolean|) |#3|) "\\spad{branchPoint?(p)} tests whether \\spad{p(x) = 0} is a branch point.") (((|Boolean|) |#2|) "\\spad{branchPoint?(a)} tests whether \\spad{x = a} is a branch point.")) (|branchPointAtInfinity?| (((|Boolean|)) "\\spad{branchPointAtInfinity?()} tests if there is a branch point at infinity.")) (|rationalPoint?| (((|Boolean|) |#2| |#2|) "\\spad{rationalPoint?(a, b)} tests if \\spad{(x=a,y=b)} is on the curve.")) (|absolutelyIrreducible?| (((|Boolean|)) "\\spad{absolutelyIrreducible?()} tests if the curve absolutely irreducible?")) (|genus| (((|NonNegativeInteger|)) "\\spad{genus()} returns the genus of one absolutely irreducible component")) (|numberOfComponents| (((|NonNegativeInteger|)) "\\spad{numberOfComponents()} returns the number of absolutely irreducible components."))) 
@@ -1102,7 +1102,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|Finite|))) (|HasCategory| |#2| (QUOTE (|Field|)))) 
 (|FunctionFieldCategory| F UP UPUP) 
 ((|constructor| (NIL "This category is a model for the function field of a plane algebraic curve.")) (|rationalPoints| (((|List| (|List| |#1|))) "\\spad{rationalPoints()} returns the list of all the affine rational points.")) (|nonSingularModel| (((|List| (|Polynomial| |#1|)) (|Symbol|)) "\\spad{nonSingularModel(u)} returns the equations in \\spad{u1},{}...,{}un of an affine non-singular model for the curve.")) (|algSplitSimple| (((|Record| (|:| |num| $) (|:| |den| |#2|) (|:| |derivden| |#2|) (|:| |gd| |#2|)) $ (|Mapping| |#2| |#2|)) "\\spad{algSplitSimple(f, D)} returns \\spad{[h,d,d',g]} such that \\spad{f=h/d},{} \\spad{h} is integral at all the normal places \\spad{w}.\\spad{r}.\\spad{t}. \\spad{D},{} \\spad{d' = Dd},{} \\spad{g = gcd(d, discriminant())} and \\spad{D} is the derivation to use. \\spad{f} must have at most simple finite poles.")) (|hyperelliptic| (((|Union| |#2| "failed")) "\\spad{hyperelliptic()} returns \\spad{p(x)} if the curve is the hyperelliptic defined by \\spad{y**2 = p(x)},{} \"failed\" otherwise.")) (|elliptic| (((|Union| |#2| "failed")) "\\spad{elliptic()} returns \\spad{p(x)} if the curve is the elliptic defined by \\spad{y**2 = p(x)},{} \"failed\" otherwise.")) (|elt| ((|#1| $ |#1| |#1|) "\\spad{elt(f,a,b)} or \\spad{f}(a,{} \\spad{b}) returns the value of \\spad{f} at the point \\spad{(x = a, y = b)} if it is not singular.")) (|primitivePart| (($ $) "\\spad{primitivePart(f)} removes the content of the denominator and the common content of the numerator of \\spad{f}.")) (|differentiate| (($ $ (|Mapping| |#2| |#2|)) "\\spad{differentiate(x, d)} extends the derivation \\spad{d} from UP to \\$ and applies it to \\spad{x}.")) (|integralDerivationMatrix| (((|Record| (|:| |num| (|Matrix| |#2|)) (|:| |den| |#2|)) (|Mapping| |#2| |#2|)) "\\spad{integralDerivationMatrix(d)} extends the derivation \\spad{d} from UP to \\$ and returns (\\spad{M},{} \\spad{Q}) such that the i^th row of \\spad{M} divided by \\spad{Q} form the coordinates of \\spad{d(wi)} with respect to \\spad{(w1,...,wn)} where \\spad{(w1,...,wn)} is the integral basis returned by integralBasis().")) (|integralRepresents| (($ (|Vector| |#2|) |#2|) "\\spad{integralRepresents([A1,...,An], D)} returns \\spad{(A1 w1+...+An wn)/D} where \\spad{(w1,...,wn)} is the integral basis of \\spad{integralBasis()}.")) (|integralCoordinates| (((|Record| (|:| |num| (|Vector| |#2|)) (|:| |den| |#2|)) $) "\\spad{integralCoordinates(f)} returns \\spad{[[A1,...,An], D]} such that \\spad{f = (A1 w1 +...+ An wn) / D} where \\spad{(w1,...,wn)} is the integral basis returned by \\spad{integralBasis()}.")) (|represents| (($ (|Vector| |#2|) |#2|) "\\spad{represents([A0,...,A(n-1)],D)} returns \\spad{(A0 + A1 y +...+ A(n-1)*y**(n-1))/D}.")) (|yCoordinates| (((|Record| (|:| |num| (|Vector| |#2|)) (|:| |den| |#2|)) $) "\\spad{yCoordinates(f)} returns \\spad{[[A1,...,An], D]} such that \\spad{f = (A1 + A2 y +...+ An y**(n-1)) / D}.")) (|inverseIntegralMatrixAtInfinity| (((|Matrix| (|Fraction| |#2|))) "\\spad{inverseIntegralMatrixAtInfinity()} returns \\spad{M} such that \\spad{M (v1,...,vn) = (1, y, ..., y**(n-1))} where \\spad{(v1,...,vn)} is the local integral basis at infinity returned by \\spad{infIntBasis()}.")) (|integralMatrixAtInfinity| (((|Matrix| (|Fraction| |#2|))) "\\spad{integralMatrixAtInfinity()} returns \\spad{M} such that \\spad{(v1,...,vn) = M (1, y, ..., y**(n-1))} where \\spad{(v1,...,vn)} is the local integral basis at infinity returned by \\spad{infIntBasis()}.")) (|inverseIntegralMatrix| (((|Matrix| (|Fraction| |#2|))) "\\spad{inverseIntegralMatrix()} returns \\spad{M} such that \\spad{M (w1,...,wn) = (1, y, ..., y**(n-1))} where \\spad{(w1,...,wn)} is the integral basis of \\spadfunFrom{integralBasis}{FunctionFieldCategory}.")) (|integralMatrix| (((|Matrix| (|Fraction| |#2|))) "\\spad{integralMatrix()} returns \\spad{M} such that \\spad{(w1,...,wn) = M (1, y, ..., y**(n-1))},{} where \\spad{(w1,...,wn)} is the integral basis of \\spadfunFrom{integralBasis}{FunctionFieldCategory}.")) (|reduceBasisAtInfinity| (((|Vector| $) (|Vector| $)) "\\spad{reduceBasisAtInfinity(b1,...,bn)} returns \\spad{(x**i * bj)} for all \\spad{i},{}\\spad{j} such that \\spad{x**i*bj} is locally integral at infinity.")) (|normalizeAtInfinity| (((|Vector| $) (|Vector| $)) "\\spad{normalizeAtInfinity(v)} makes \\spad{v} normal at infinity.")) (|complementaryBasis| (((|Vector| $) (|Vector| $)) "\\spad{complementaryBasis(b1,...,bn)} returns the complementary basis \\spad{(b1',...,bn')} of \\spad{(b1,...,bn)}.")) (|integral?| (((|Boolean|) $ |#2|) "\\spad{integral?(f, p)} tests whether \\spad{f} is locally integral at \\spad{p(x) = 0}.") (((|Boolean|) $ |#1|) "\\spad{integral?(f, a)} tests whether \\spad{f} is locally integral at \\spad{x = a}.") (((|Boolean|) $) "\\spad{integral?()} tests if \\spad{f} is integral over \\spad{k[x]}.")) (|integralAtInfinity?| (((|Boolean|) $) "\\spad{integralAtInfinity?()} tests if \\spad{f} is locally integral at infinity.")) (|integralBasisAtInfinity| (((|Vector| $)) "\\spad{integralBasisAtInfinity()} returns the local integral basis at infinity.")) (|integralBasis| (((|Vector| $)) "\\spad{integralBasis()} returns the integral basis for the curve.")) (|ramified?| (((|Boolean|) |#2|) "\\spad{ramified?(p)} tests whether \\spad{p(x) = 0} is ramified.") (((|Boolean|) |#1|) "\\spad{ramified?(a)} tests whether \\spad{x = a} is ramified.")) (|ramifiedAtInfinity?| (((|Boolean|)) "\\spad{ramifiedAtInfinity?()} tests if infinity is ramified.")) (|singular?| (((|Boolean|) |#2|) "\\spad{singular?(p)} tests whether \\spad{p(x) = 0} is singular.") (((|Boolean|) |#1|) "\\spad{singular?(a)} tests whether \\spad{x = a} is singular.")) (|singularAtInfinity?| (((|Boolean|)) "\\spad{singularAtInfinity?()} tests if there is a singularity at infinity.")) (|branchPoint?| (((|Boolean|) |#2|) "\\spad{branchPoint?(p)} tests whether \\spad{p(x) = 0} is a branch point.") (((|Boolean|) |#1|) "\\spad{branchPoint?(a)} tests whether \\spad{x = a} is a branch point.")) (|branchPointAtInfinity?| (((|Boolean|)) "\\spad{branchPointAtInfinity?()} tests if there is a branch point at infinity.")) (|rationalPoint?| (((|Boolean|) |#1| |#1|) "\\spad{rationalPoint?(a, b)} tests if \\spad{(x=a,y=b)} is on the curve.")) (|absolutelyIrreducible?| (((|Boolean|)) "\\spad{absolutelyIrreducible?()} tests if the curve absolutely irreducible?")) (|genus| (((|NonNegativeInteger|)) "\\spad{genus()} returns the genus of one absolutely irreducible component")) (|numberOfComponents| (((|NonNegativeInteger|)) "\\spad{numberOfComponents()} returns the number of absolutely irreducible components."))) 
-((|noZeroDivisors| |has| (|Fraction| |#2|) . #1=((|Field|))) (|canonicalUnitNormal| |has| (|Fraction| |#2|) . #1#) (|canonicalsClosed| |has| (|Fraction| |#2|) . #1#) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| |has| (|Fraction| |#2|) . #1=((|Field|))) (|canonicalUnitNormal| |has| (|Fraction| |#2|) . #1#) ((|commutative| "*") . T)) 
 NIL 
 (|FunctionFieldCategoryFunctions2| R1 UP1 UPUP1 F1 R2 UP2 UPUP2 F2) 
 ((|constructor| (NIL "Lifts a map from rings to function fields over them.")) (|map| ((|#8| (|Mapping| |#5| |#1|) |#4|) "\\spad{map(f, p)} lifts \\spad{f} to \\spad{F1} and applies it to \\spad{p}."))) 
@@ -1110,15 +1110,15 @@ NIL
 NIL 
 (|FiniteFieldCyclicGroup| |p| |extdeg|) 
 ((|constructor| (NIL "FiniteFieldCyclicGroup(\\spad{p},{}\\spad{n}) implements a finite field extension of degee \\spad{n} over the prime field with \\spad{p} elements. Its elements are represented by powers of a primitive element,{} \\spadignore{i.e.} a generator of the multiplicative (cyclic) group. As primitive element we choose the root of the extension polynomial,{} which is created by {\\em createPrimitivePoly} from \\spadtype{FiniteFieldPolynomialPackage}. The Zech logarithms are stored in a table of size half of the field size,{} and use \\spadtype{SingleInteger} for representing field elements,{} hence,{} there are restrictions on the size of the field.")) (|getZechTable| (((|PrimitiveArray| (|SingleInteger|))) "\\spad{getZechTable()} returns the zech logarithm table of the field. This table is used to perform additions in the field quickly."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((OR #1=(|HasCategory| #2=(|PrimeField| |#1|) (QUOTE (|CharacteristicNonZero|))) #3=(|HasCategory| #2# (QUOTE (|Finite|)))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) #3# #1#) 
 (|FiniteFieldCyclicGroupExtensionByPolynomial| GF |defpol|) 
 ((|constructor| (NIL "FiniteFieldCyclicGroupExtensionByPolynomial(GF,{}defpol) implements a finite extension field of the ground field {\\em GF}. Its elements are represented by powers of a primitive element,{} \\spadignore{i.e.} a generator of the multiplicative (cyclic) group. As primitive element we choose the root of the extension polynomial {\\em defpol},{} which MUST be primitive (user responsibility). Zech logarithms are stored in a table of size half of the field size,{} and use \\spadtype{SingleInteger} for representing field elements,{} hence,{} there are restrictions on the size of the field.")) (|getZechTable| (((|PrimitiveArray| (|SingleInteger|))) "\\spad{getZechTable()} returns the zech logarithm table of the field it is used to perform additions in the field quickly."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((OR #1=(|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) #2=(|HasCategory| |#1| (QUOTE (|Finite|)))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #2# #1#) 
 (|FiniteFieldCyclicGroupExtension| GF |extdeg|) 
 ((|constructor| (NIL "FiniteFieldCyclicGroupExtension(GF,{}\\spad{n}) implements a extension of degree \\spad{n} over the ground field {\\em GF}. Its elements are represented by powers of a primitive element,{} \\spadignore{i.e.} a generator of the multiplicative (cyclic) group. As primitive element we choose the root of the extension polynomial,{} which is created by {\\em createPrimitivePoly} from \\spadtype{FiniteFieldPolynomialPackage}. Zech logarithms are stored in a table of size half of the field size,{} and use \\spadtype{SingleInteger} for representing field elements,{} hence,{} there are restrictions on the size of the field.")) (|getZechTable| (((|PrimitiveArray| (|SingleInteger|))) "\\spad{getZechTable()} returns the zech logarithm table of the field. This table is used to perform additions in the field quickly."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((OR #1=(|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) #2=(|HasCategory| |#1| (QUOTE (|Finite|)))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #2# #1#) 
 (|FiniteFieldFunctions| GF) 
 ((|constructor| (NIL "FiniteFieldFunctions(GF) is a package with functions concerning finite extension fields of the finite ground field {\\em GF},{} \\spadignore{e.g.} Zech logarithms.")) (|createLowComplexityNormalBasis| (((|Union| (|SparseUnivariatePolynomial| |#1|) (|Vector| (|List| (|Record| (|:| |value| |#1|) (|:| |index| (|SingleInteger|)))))) (|PositiveInteger|)) "\\spad{createLowComplexityNormalBasis(n)} tries to find a a low complexity normal basis of degree {\\em n} over {\\em GF} and returns its multiplication matrix If no low complexity basis is found it calls \\axiomFunFrom{createNormalPoly}{FiniteFieldPolynomialPackage}(\\spad{n}) to produce a normal polynomial of degree {\\em n} over {\\em GF}")) (|createLowComplexityTable| (((|Union| (|Vector| (|List| (|Record| (|:| |value| |#1|) (|:| |index| (|SingleInteger|))))) "failed") (|PositiveInteger|)) "\\spad{createLowComplexityTable(n)} tries to find a low complexity normal basis of degree {\\em n} over {\\em GF} and returns its multiplication matrix Fails,{} if it does not find a low complexity basis")) (|sizeMultiplication| (((|NonNegativeInteger|) (|Vector| (|List| (|Record| (|:| |value| |#1|) (|:| |index| (|SingleInteger|)))))) "\\spad{sizeMultiplication(m)} returns the number of entries of the multiplication table {\\em m}.")) (|createMultiplicationMatrix| (((|Matrix| |#1|) (|Vector| (|List| (|Record| (|:| |value| |#1|) (|:| |index| (|SingleInteger|)))))) "\\spad{createMultiplicationMatrix(m)} forms the multiplication table {\\em m} into a matrix over the ground field.")) (|createMultiplicationTable| (((|Vector| (|List| (|Record| (|:| |value| |#1|) (|:| |index| (|SingleInteger|))))) (|SparseUnivariatePolynomial| |#1|)) "\\spad{createMultiplicationTable(f)} generates a multiplication table for the normal basis of the field extension determined by {\\em f}. This is needed to perform multiplications between elements represented as coordinate vectors to this basis. See \\spadtype{FFNBP},{} \\spadtype{FFNBX}.")) (|createZechTable| (((|PrimitiveArray| (|SingleInteger|)) (|SparseUnivariatePolynomial| |#1|)) "\\spad{createZechTable(f)} generates a Zech logarithm table for the cyclic group representation of a extension of the ground field by the primitive polynomial {\\em f(x)},{} \\spadignore{i.e.} \\spad{Z(i)},{} defined by {\\em x**Z(i) = 1+x**i} is stored at index \\spad{i}. This is needed in particular to perform addition of field elements in finite fields represented in this way. See \\spadtype{FFCGP},{} \\spadtype{FFCGX}."))) 
@@ -1134,7 +1134,7 @@ NIL
 NIL 
 (|FiniteFieldCategory|) 
 ((|constructor| (NIL "FiniteFieldCategory is the category of finite fields")) (|representationType| (((|Union| "prime" "polynomial" "normal" "cyclic")) "\\spad{representationType()} returns the type of the representation,{} one of: \\spad{prime},{} \\spad{polynomial},{} \\spad{normal},{} or \\spad{cyclic}.")) (|order| (((|PositiveInteger|) $) "\\spad{order(b)} computes the order of an element \\spad{b} in the multiplicative group of the field. Error: if \\spad{b} equals 0.")) (|discreteLog| (((|NonNegativeInteger|) $) "\\spad{discreteLog(a)} computes the discrete logarithm of \\spad{a} with respect to \\spad{primitiveElement()} of the field.")) (|primitive?| (((|Boolean|) $) "\\spad{primitive?(b)} tests whether the element \\spad{b} is a generator of the (cyclic) multiplicative group of the field,{} \\spadignore{i.e.} is a primitive element. Implementation Note: see ch.IX.1.3,{} th.2 in \\spad{D}. Lipson.")) (|primitiveElement| (($) "\\spad{primitiveElement()} returns a primitive element stored in a global variable in the domain. At first call,{} the primitive element is computed by calling \\spadfun{createPrimitiveElement}.")) (|createPrimitiveElement| (($) "\\spad{createPrimitiveElement()} computes a generator of the (cyclic) multiplicative group of the field.")) (|tableForDiscreteLogarithm| (((|Table| (|PositiveInteger|) (|NonNegativeInteger|)) (|Integer|)) "\\spad{tableForDiscreteLogarithm(a,n)} returns a table of the discrete logarithms of \\spad{a**0} up to \\spad{a**(n-1)} which,{} called with key \\spad{lookup(a**i)} returns \\spad{i} for \\spad{i} in \\spad{0..n-1}. Error: if not called for prime divisors of order of \\indented{7}{multiplicative group.}")) (|factorsOfCyclicGroupSize| (((|List| (|Record| (|:| |factor| (|Integer|)) (|:| |exponent| (|Integer|))))) "\\spad{factorsOfCyclicGroupSize()} returns the factorization of size()\\spad{-1}")) (|conditionP| (((|Union| (|Vector| $) "failed") (|Matrix| $)) "\\spad{conditionP(mat)},{} given a matrix representing a homogeneous system of equations,{} returns a vector whose characteristic'th powers is a non-trivial solution,{} or \"failed\" if no such vector exists.")) (|charthRoot| (($ $) "\\spad{charthRoot(a)} takes the characteristic'th root of {\\em a}. Note: such a root is alway defined in finite fields."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|FunctionFieldIntegralBasis| R UP F) 
 ((|constructor| (NIL "In this package \\spad{R} is a Euclidean domain and \\spad{F} is a framed algebra over \\spad{R}. The package provides functions to compute the integral closure of \\spad{R} in the quotient field of \\spad{F}. It is assumed that \\spad{char(R/P) = char(R)} for any prime \\spad{P} of \\spad{R}. A typical instance of this is when \\spad{R = K[x]} and \\spad{F} is a function field over \\spad{R}.")) (|localIntegralBasis| (((|Record| (|:| |basis| (|Matrix| |#1|)) (|:| |basisDen| |#1|) (|:| |basisInv| (|Matrix| |#1|))) |#1|) "\\spad{integralBasis(p)} returns a record \\spad{[basis,basisDen,basisInv]} containing information regarding the local integral closure of \\spad{R} at the prime \\spad{p} in the quotient field of \\spad{F},{} where \\spad{F} is a framed algebra with \\spad{R}-module basis \\spad{w1,w2,...,wn}. If \\spad{basis} is the matrix \\spad{(aij, i = 1..n, j = 1..n)},{} then the \\spad{i}th element of the local integral basis is \\spad{vi = (1/basisDen) * sum(aij * wj, j = 1..n)},{} \\spadignore{i.e.} the \\spad{i}th row of \\spad{basis} contains the coordinates of the \\spad{i}th basis vector. Similarly,{} the \\spad{i}th row of the matrix \\spad{basisInv} contains the coordinates of \\spad{wi} with respect to the basis \\spad{v1,...,vn}: if \\spad{basisInv} is the matrix \\spad{(bij, i = 1..n, j = 1..n)},{} then \\spad{wi = sum(bij * vj, j = 1..n)}.")) (|integralBasis| (((|Record| (|:| |basis| (|Matrix| |#1|)) (|:| |basisDen| |#1|) (|:| |basisInv| (|Matrix| |#1|)))) "\\spad{integralBasis()} returns a record \\spad{[basis,basisDen,basisInv]} containing information regarding the integral closure of \\spad{R} in the quotient field of \\spad{F},{} where \\spad{F} is a framed algebra with \\spad{R}-module basis \\spad{w1,w2,...,wn}. If \\spad{basis} is the matrix \\spad{(aij, i = 1..n, j = 1..n)},{} then the \\spad{i}th element of the integral basis is \\spad{vi = (1/basisDen) * sum(aij * wj, j = 1..n)},{} \\spadignore{i.e.} the \\spad{i}th row of \\spad{basis} contains the coordinates of the \\spad{i}th basis vector. Similarly,{} the \\spad{i}th row of the matrix \\spad{basisInv} contains the coordinates of \\spad{wi} with respect to the basis \\spad{v1,...,vn}: if \\spad{basisInv} is the matrix \\spad{(bij, i = 1..n, j = 1..n)},{} then \\spad{wi = sum(bij * vj, j = 1..n)}.")) (|squareFree| (((|Factored| $) $) "\\spad{squareFree(x)} returns a square-free factorisation of \\spad{x}"))) 
@@ -1142,19 +1142,19 @@ NIL
 NIL 
 (|FiniteFieldNormalBasis| |p| |extdeg|) 
 ((|constructor| (NIL "FiniteFieldNormalBasis(\\spad{p},{}\\spad{n}) implements a finite extension field of degree \\spad{n} over the prime field with \\spad{p} elements. The elements are represented by coordinate vectors with respect to a normal basis,{} \\spadignore{i.e.} a basis consisting of the conjugates (\\spad{q}-powers) of an element,{} in this case called normal element. This is chosen as a root of the extension polynomial created by \\spadfunFrom{createNormalPoly}{FiniteFieldPolynomialPackage}.")) (|sizeMultiplication| (((|NonNegativeInteger|)) "\\spad{sizeMultiplication()} returns the number of entries in the multiplication table of the field. Note: The time of multiplication of field elements depends on this size.")) (|getMultiplicationMatrix| (((|Matrix| (|PrimeField| |#1|))) "\\spad{getMultiplicationMatrix()} returns the multiplication table in form of a matrix.")) (|getMultiplicationTable| (((|Vector| (|List| (|Record| (|:| |value| (|PrimeField| |#1|)) (|:| |index| (|SingleInteger|)))))) "\\spad{getMultiplicationTable()} returns the multiplication table for the normal basis of the field. This table is used to perform multiplications between field elements."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((OR #1=(|HasCategory| #2=(|PrimeField| |#1|) (QUOTE (|CharacteristicNonZero|))) #3=(|HasCategory| #2# (QUOTE (|Finite|)))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) #3# #1#) 
 (|FiniteFieldNormalBasisExtensionByPolynomial| GF |uni|) 
 ((|constructor| (NIL "FiniteFieldNormalBasisExtensionByPolynomial(GF,{}uni) implements a finite extension of the ground field {\\em GF}. The elements are represented by coordinate vectors with respect to. a normal basis,{} \\spadignore{i.e.} a basis consisting of the conjugates (\\spad{q}-powers) of an element,{} in this case called normal element,{} where \\spad{q} is the size of {\\em GF}. The normal element is chosen as a root of the extension polynomial,{} which MUST be normal over {\\em GF} (user responsibility)")) (|sizeMultiplication| (((|NonNegativeInteger|)) "\\spad{sizeMultiplication()} returns the number of entries in the multiplication table of the field. Note: the time of multiplication of field elements depends on this size.")) (|getMultiplicationMatrix| (((|Matrix| |#1|)) "\\spad{getMultiplicationMatrix()} returns the multiplication table in form of a matrix.")) (|getMultiplicationTable| (((|Vector| (|List| (|Record| (|:| |value| |#1|) (|:| |index| (|SingleInteger|)))))) "\\spad{getMultiplicationTable()} returns the multiplication table for the normal basis of the field. This table is used to perform multiplications between field elements."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((OR #1=(|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) #2=(|HasCategory| |#1| (QUOTE (|Finite|)))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #2# #1#) 
 (|FiniteFieldNormalBasisExtension| GF |extdeg|) 
 ((|constructor| (NIL "FiniteFieldNormalBasisExtensionByPolynomial(GF,{}\\spad{n}) implements a finite extension field of degree \\spad{n} over the ground field {\\em GF}. The elements are represented by coordinate vectors with respect to a normal basis,{} \\spadignore{i.e.} a basis consisting of the conjugates (\\spad{q}-powers) of an element,{} in this case called normal element. This is chosen as a root of the extension polynomial,{} created by {\\em createNormalPoly} from \\spadtype{FiniteFieldPolynomialPackage}")) (|sizeMultiplication| (((|NonNegativeInteger|)) "\\spad{sizeMultiplication()} returns the number of entries in the multiplication table of the field. Note: the time of multiplication of field elements depends on this size.")) (|getMultiplicationMatrix| (((|Matrix| |#1|)) "\\spad{getMultiplicationMatrix()} returns the multiplication table in form of a matrix.")) (|getMultiplicationTable| (((|Vector| (|List| (|Record| (|:| |value| |#1|) (|:| |index| (|SingleInteger|)))))) "\\spad{getMultiplicationTable()} returns the multiplication table for the normal basis of the field. This table is used to perform multiplications between field elements."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((OR #1=(|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) #2=(|HasCategory| |#1| (QUOTE (|Finite|)))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #2# #1#) 
 (|FiniteFieldExtensionByPolynomial| GF |defpol|) 
 ((|constructor| (NIL "FiniteFieldExtensionByPolynomial(GF,{} defpol) implements the extension of the finite field {\\em GF} generated by the extension polynomial {\\em defpol} which MUST be irreducible. Note: the user has the responsibility to ensure that {\\em defpol} is irreducible."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((OR #1=(|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) #2=(|HasCategory| |#1| (QUOTE (|Finite|)))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #2# #1#) 
 (|FiniteFieldPolynomialPackage| GF) 
 ((|constructor| (NIL "This package provides a number of functions for generating,{} counting and testing irreducible,{} normal,{} primitive,{} random polynomials over finite fields.")) (|reducedQPowers| (((|PrimitiveArray| (|SparseUnivariatePolynomial| |#1|)) (|SparseUnivariatePolynomial| |#1|)) "\\spad{reducedQPowers(f)} generates \\spad{[x,x**q,x**(q**2),...,x**(q**(n-1))]} reduced modulo \\spad{f} where \\spad{q = size()\\$GF} and \\spad{n = degree f}.")) (|leastAffineMultiple| (((|SparseUnivariatePolynomial| |#1|) (|SparseUnivariatePolynomial| |#1|)) "\\spad{leastAffineMultiple(f)} computes the least affine polynomial which is divisible by the polynomial \\spad{f} over the finite field {\\em GF},{} \\spadignore{i.e.} a polynomial whose exponents are 0 or a power of \\spad{q},{} the size of {\\em GF}.")) (|random| (((|SparseUnivariatePolynomial| |#1|) (|PositiveInteger|) (|PositiveInteger|)) "\\spad{random(m,n)}\\$FFPOLY(GF) generates a random monic polynomial of degree \\spad{d} over the finite field {\\em GF},{} \\spad{d} between \\spad{m} and \\spad{n}.") (((|SparseUnivariatePolynomial| |#1|) (|PositiveInteger|)) "\\spad{random(n)}\\$FFPOLY(GF) generates a random monic polynomial of degree \\spad{n} over the finite field {\\em GF}.")) (|nextPrimitiveNormalPoly| (((|Union| (|SparseUnivariatePolynomial| |#1|) "failed") (|SparseUnivariatePolynomial| |#1|)) "\\spad{nextPrimitiveNormalPoly(f)} yields the next primitive normal polynomial over a finite field {\\em GF} of the same degree as \\spad{f} in the following order,{} or \"failed\" if there are no greater ones. Error: if \\spad{f} has degree 0. Note: the input polynomial \\spad{f} is made monic. Also,{} \\spad{f < g} if the {\\em lookup} of the constant term of \\spad{f} is less than this number for \\spad{g} or,{} in case these numbers are equal,{} if the {\\em lookup} of the coefficient of the term of degree {\\em n-1} of \\spad{f} is less than this number for \\spad{g}. If these numbers are equals,{} \\spad{f < g} if the number of monomials of \\spad{f} is less than that for \\spad{g},{} or if the lists of exponents for \\spad{f} are lexicographically less than those for \\spad{g}. If these lists are also equal,{} the lists of coefficients are coefficients according to the lexicographic ordering induced by the ordering of the elements of {\\em GF} given by {\\em lookup}. This operation is equivalent to nextNormalPrimitivePoly(\\spad{f}).")) (|nextNormalPrimitivePoly| (((|Union| (|SparseUnivariatePolynomial| |#1|) "failed") (|SparseUnivariatePolynomial| |#1|)) "\\spad{nextNormalPrimitivePoly(f)} yields the next normal primitive polynomial over a finite field {\\em GF} of the same degree as \\spad{f} in the following order,{} or \"failed\" if there are no greater ones. Error: if \\spad{f} has degree 0. Note: the input polynomial \\spad{f} is made monic. Also,{} \\spad{f < g} if the {\\em lookup} of the constant term of \\spad{f} is less than this number for \\spad{g} or if {\\em lookup} of the coefficient of the term of degree {\\em n-1} of \\spad{f} is less than this number for \\spad{g}. Otherwise,{} \\spad{f < g} if the number of monomials of \\spad{f} is less than that for \\spad{g} or if the lists of exponents for \\spad{f} are lexicographically less than those for \\spad{g}. If these lists are also equal,{} the lists of coefficients are compared according to the lexicographic ordering induced by the ordering of the elements of {\\em GF} given by {\\em lookup}. This operation is equivalent to nextPrimitiveNormalPoly(\\spad{f}).")) (|nextNormalPoly| (((|Union| (|SparseUnivariatePolynomial| |#1|) "failed") (|SparseUnivariatePolynomial| |#1|)) "\\spad{nextNormalPoly(f)} yields the next normal polynomial over a finite field {\\em GF} of the same degree as \\spad{f} in the following order,{} or \"failed\" if there are no greater ones. Error: if \\spad{f} has degree 0. Note: the input polynomial \\spad{f} is made monic. Also,{} \\spad{f < g} if the {\\em lookup} of the coefficient of the term of degree {\\em n-1} of \\spad{f} is less than that for \\spad{g}. In case these numbers are equal,{} \\spad{f < g} if if the number of monomials of \\spad{f} is less that for \\spad{g} or if the list of exponents of \\spad{f} are lexicographically less than the corresponding list for \\spad{g}. If these lists are also equal,{} the lists of coefficients are compared according to the lexicographic ordering induced by the ordering of the elements of {\\em GF} given by {\\em lookup}.")) (|nextPrimitivePoly| (((|Union| (|SparseUnivariatePolynomial| |#1|) "failed") (|SparseUnivariatePolynomial| |#1|)) "\\spad{nextPrimitivePoly(f)} yields the next primitive polynomial over a finite field {\\em GF} of the same degree as \\spad{f} in the following order,{} or \"failed\" if there are no greater ones. Error: if \\spad{f} has degree 0. Note: the input polynomial \\spad{f} is made monic. Also,{} \\spad{f < g} if the {\\em lookup} of the constant term of \\spad{f} is less than this number for \\spad{g}. If these values are equal,{} then \\spad{f < g} if if the number of monomials of \\spad{f} is less than that for \\spad{g} or if the lists of exponents of \\spad{f} are lexicographically less than the corresponding list for \\spad{g}. If these lists are also equal,{} the lists of coefficients are compared according to the lexicographic ordering induced by the ordering of the elements of {\\em GF} given by {\\em lookup}.")) (|nextIrreduciblePoly| (((|Union| (|SparseUnivariatePolynomial| |#1|) "failed") (|SparseUnivariatePolynomial| |#1|)) "\\spad{nextIrreduciblePoly(f)} yields the next monic irreducible polynomial over a finite field {\\em GF} of the same degree as \\spad{f} in the following order,{} or \"failed\" if there are no greater ones. Error: if \\spad{f} has degree 0. Note: the input polynomial \\spad{f} is made monic. Also,{} \\spad{f < g} if the number of monomials of \\spad{f} is less than this number for \\spad{g}. If \\spad{f} and \\spad{g} have the same number of monomials,{} the lists of exponents are compared lexicographically. If these lists are also equal,{} the lists of coefficients are compared according to the lexicographic ordering induced by the ordering of the elements of {\\em GF} given by {\\em lookup}.")) (|createPrimitiveNormalPoly| (((|SparseUnivariatePolynomial| |#1|) (|PositiveInteger|)) "\\spad{createPrimitiveNormalPoly(n)}\\$FFPOLY(GF) generates a normal and primitive polynomial of degree \\spad{n} over the field {\\em GF}. polynomial of degree \\spad{n} over the field {\\em GF}.")) (|createNormalPrimitivePoly| (((|SparseUnivariatePolynomial| |#1|) (|PositiveInteger|)) "\\spad{createNormalPrimitivePoly(n)}\\$FFPOLY(GF) generates a normal and primitive polynomial of degree \\spad{n} over the field {\\em GF}. Note: this function is equivalent to createPrimitiveNormalPoly(\\spad{n})")) (|createNormalPoly| (((|SparseUnivariatePolynomial| |#1|) (|PositiveInteger|)) "\\spad{createNormalPoly(n)}\\$FFPOLY(GF) generates a normal polynomial of degree \\spad{n} over the finite field {\\em GF}.")) (|createPrimitivePoly| (((|SparseUnivariatePolynomial| |#1|) (|PositiveInteger|)) "\\spad{createPrimitivePoly(n)}\\$FFPOLY(GF) generates a primitive polynomial of degree \\spad{n} over the finite field {\\em GF}.")) (|createIrreduciblePoly| (((|SparseUnivariatePolynomial| |#1|) (|PositiveInteger|)) "\\spad{createIrreduciblePoly(n)}\\$FFPOLY(GF) generates a monic irreducible univariate polynomial of degree \\spad{n} over the finite field {\\em GF}.")) (|numberOfNormalPoly| (((|PositiveInteger|) (|PositiveInteger|)) "\\spad{numberOfNormalPoly(n)}\\$FFPOLY(GF) yields the number of normal polynomials of degree \\spad{n} over the finite field {\\em GF}.")) (|numberOfPrimitivePoly| (((|PositiveInteger|) (|PositiveInteger|)) "\\spad{numberOfPrimitivePoly(n)}\\$FFPOLY(GF) yields the number of primitive polynomials of degree \\spad{n} over the finite field {\\em GF}.")) (|numberOfIrreduciblePoly| (((|PositiveInteger|) (|PositiveInteger|)) "\\spad{numberOfIrreduciblePoly(n)}\\$FFPOLY(GF) yields the number of monic irreducible univariate polynomials of degree \\spad{n} over the finite field {\\em GF}.")) (|normal?| (((|Boolean|) (|SparseUnivariatePolynomial| |#1|)) "\\spad{normal?(f)} tests whether the polynomial \\spad{f} over a finite field is normal,{} \\spadignore{i.e.} its roots are linearly independent over the field.")) (|primitive?| (((|Boolean|) (|SparseUnivariatePolynomial| |#1|)) "\\spad{primitive?(f)} tests whether the polynomial \\spad{f} over a finite field is primitive,{} \\spadignore{i.e.} all its roots are primitive."))) 
@@ -1170,7 +1170,7 @@ NIL
 NIL 
 (|FiniteFieldExtension| GF |n|) 
 ((|constructor| (NIL "FiniteFieldExtensionByPolynomial(GF,{} \\spad{n}) implements an extension of the finite field {\\em GF} of degree \\spad{n} generated by the extension polynomial constructed by \\spadfunFrom{createIrreduciblePoly}{FiniteFieldPolynomialPackage} from \\spadtype{FiniteFieldPolynomialPackage}."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((OR #1=(|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) #2=(|HasCategory| |#1| (QUOTE (|Finite|)))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #2# #1#) 
 (|FGLMIfCanPackage| R |ls|) 
 ((|constructor| (NIL "This is just an interface between several packages and domains. The goal is to compute lexicographical Groebner bases of sets of polynomial with type \\spadtype{Polynomial R} by the {\\em FGLM} algorithm if this is possible (\\spadignore{i.e.} if the input system generates a zero-dimensional ideal).")) (|groebner| (((|List| (|Polynomial| |#1|)) (|List| (|Polynomial| |#1|))) "\\axiom{groebner(\\spad{lq1})} returns the lexicographical Groebner basis of \\axiom{\\spad{lq1}}. If \\axiom{\\spad{lq1}} generates a zero-dimensional ideal then the {\\em FGLM} strategy is used,{} otherwise the {\\em Sugar} strategy is used.")) (|fglmIfCan| (((|Union| (|List| (|Polynomial| |#1|)) "failed") (|List| (|Polynomial| |#1|))) "\\axiom{fglmIfCan(\\spad{lq1})} returns the lexicographical Groebner basis of \\axiom{\\spad{lq1}} by using the {\\em FGLM} strategy,{} if \\axiom{zeroDimensional?(\\spad{lq1})} holds.")) (|zeroDimensional?| (((|Boolean|) (|List| (|Polynomial| |#1|))) "\\axiom{zeroDimensional?(\\spad{lq1})} returns \\spad{true} iff \\axiom{\\spad{lq1}} generates a zero-dimensional ideal \\spad{w}.\\spad{r}.\\spad{t}. the variables of \\axiom{ls}."))) 
@@ -1178,15 +1178,15 @@ NIL
 NIL 
 (|FreeGroup| S) 
 ((|constructor| (NIL "The free group on a set \\spad{S} is the group of finite products of the form \\spad{reduce(*,[si ** ni])} where the \\spad{si}'s are in \\spad{S},{} and the \\spad{ni}'s are integers. The multiplication is not commutative.")) (|factors| (((|List| (|Record| (|:| |gen| |#1|) (|:| |exp| (|Integer|)))) $) "\\spad{factors(a1\\^e1,...,an\\^en)} returns \\spad{[[a1, e1],...,[an, en]]}.")) (|mapGen| (($ (|Mapping| |#1| |#1|) $) "\\spad{mapGen(f, a1\\^e1 ... an\\^en)} returns \\spad{f(a1)\\^e1 ... f(an)\\^en}.")) (|mapExpon| (($ (|Mapping| (|Integer|) (|Integer|)) $) "\\spad{mapExpon(f, a1\\^e1 ... an\\^en)} returns \\spad{a1\\^f(e1) ... an\\^f(en)}.")) (|nthFactor| ((|#1| $ (|Integer|)) "\\spad{nthFactor(x, n)} returns the factor of the n^th monomial of \\spad{x}.")) (|nthExpon| (((|Integer|) $ (|Integer|)) "\\spad{nthExpon(x, n)} returns the exponent of the n^th monomial of \\spad{x}.")) (|size| (((|NonNegativeInteger|) $) "\\spad{size(x)} returns the number of monomials in \\spad{x}.")) (** (($ |#1| (|Integer|)) "\\spad{s ** n} returns the product of \\spad{s} by itself \\spad{n} times.")) (* (($ $ |#1|) "\\spad{x * s} returns the product of \\spad{x} by \\spad{s} on the right.") (($ |#1| $) "\\spad{s * x} returns the product of \\spad{x} by \\spad{s} on the left."))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|Field&| S) 
-((|constructor| (NIL "The category of commutative fields,{} \\spadignore{i.e.} commutative rings where all non-zero elements have multiplicative inverses. The \\spadfun{factor} operation while trivial is useful to have defined. \\blankline")) (|canonicalsClosed| ((|attribute|) "since \\spad{0*0=0},{} \\spad{1*1=1}")) (|canonicalUnitNormal| ((|attribute|) "either 0 or 1.")) (/ (($ $ $) "\\spad{x/y} divides the element \\spad{x} by the element \\spad{y}. Error: if \\spad{y} is 0."))) 
+((|constructor| (NIL "The category of commutative fields,{} \\spadignore{i.e.} commutative rings where all non-zero elements have multiplicative inverses. The \\spadfun{factor} operation while trivial is useful to have defined. \\blankline")) (|canonicalUnitNormal| ((|attribute|) "either 0 or 1.")) (/ (($ $ $) "\\spad{x/y} divides the element \\spad{x} by the element \\spad{y}. Error: if \\spad{y} is 0."))) 
 NIL 
 NIL 
 (|Field|) 
-((|constructor| (NIL "The category of commutative fields,{} \\spadignore{i.e.} commutative rings where all non-zero elements have multiplicative inverses. The \\spadfun{factor} operation while trivial is useful to have defined. \\blankline")) (|canonicalsClosed| ((|attribute|) "since \\spad{0*0=0},{} \\spad{1*1=1}")) (|canonicalUnitNormal| ((|attribute|) "either 0 or 1.")) (/ (($ $ $) "\\spad{x/y} divides the element \\spad{x} by the element \\spad{y}. Error: if \\spad{y} is 0."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|constructor| (NIL "The category of commutative fields,{} \\spadignore{i.e.} commutative rings where all non-zero elements have multiplicative inverses. The \\spadfun{factor} operation while trivial is useful to have defined. \\blankline")) (|canonicalUnitNormal| ((|attribute|) "either 0 or 1.")) (/ (($ $ $) "\\spad{x/y} divides the element \\spad{x} by the element \\spad{y}. Error: if \\spad{y} is 0."))) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|File| S) 
 ((|constructor| (NIL "This domain provides a basic model of files to save arbitrary values. The operations provide sequential access to the contents.")) (|readIfCan!| (((|Union| |#1| "failed") $) "\\spad{readIfCan!(f)} returns a value from the file \\spad{f},{} if possible. If \\spad{f} is not open for reading,{} or if \\spad{f} is at the end of file then \\spad{\"failed\"} is the result."))) 
@@ -1197,12 +1197,12 @@ NIL
 NIL 
 NIL 
 (|FiniteRankNonAssociativeAlgebra&| S R) 
-((|constructor| (NIL "A FiniteRankNonAssociativeAlgebra is a non associative algebra over a commutative ring \\spad{R} which is a free \\spad{R}-module of finite rank.")) (|unitsKnown| ((|attribute|) "unitsKnown means that \\spadfun{recip} truly yields reciprocal or \\spad{\"failed\"} if not a unit,{} similarly for \\spadfun{leftRecip} and \\spadfun{rightRecip}. The reason is that we use left,{} respectively right,{} minimal polynomials to decide this question.")) (|unit| (((|Union| $ "failed")) "\\spad{unit()} returns a unit of the algebra (necessarily unique),{} or \\spad{\"failed\"} if there is none.")) (|rightUnit| (((|Union| $ "failed")) "\\spad{rightUnit()} returns a right unit of the algebra (not necessarily unique),{} or \\spad{\"failed\"} if there is none.")) (|leftUnit| (((|Union| $ "failed")) "\\spad{leftUnit()} returns a left unit of the algebra (not necessarily unique),{} or \\spad{\"failed\"} if there is none.")) (|rightUnits| (((|Union| (|Record| (|:| |particular| $) (|:| |basis| (|List| $))) "failed")) "\\spad{rightUnits()} returns the affine space of all right units of the algebra,{} or \\spad{\"failed\"} if there is none.")) (|leftUnits| (((|Union| (|Record| (|:| |particular| $) (|:| |basis| (|List| $))) "failed")) "\\spad{leftUnits()} returns the affine space of all left units of the algebra,{} or \\spad{\"failed\"} if there is none.")) (|rightMinimalPolynomial| (((|SparseUnivariatePolynomial| |#2|) $) "\\spad{rightMinimalPolynomial(a)} returns the polynomial determined by the smallest non-trivial linear combination of right powers of \\spad{a}. Note: the polynomial never has a constant term as in general the algebra has no unit.")) (|leftMinimalPolynomial| (((|SparseUnivariatePolynomial| |#2|) $) "\\spad{leftMinimalPolynomial(a)} returns the polynomial determined by the smallest non-trivial linear combination of left powers of \\spad{a}. Note: the polynomial never has a constant term as in general the algebra has no unit.")) (|associatorDependence| (((|List| (|Vector| |#2|))) "\\spad{associatorDependence()} looks for the associator identities,{} \\spadignore{i.e.} finds a basis of the solutions of the linear combinations of the six permutations of \\spad{associator(a,b,c)} which yield 0,{} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra. The order of the permutations is \\spad{123 231 312 132 321 213}.")) (|rightRecip| (((|Union| $ "failed") $) "\\spad{rightRecip(a)} returns an element,{} which is a right inverse of \\spad{a},{} or \\spad{\"failed\"} if there is no unit element,{} if such an element doesn't exist or cannot be determined (see unitsKnown).")) (|leftRecip| (((|Union| $ "failed") $) "\\spad{leftRecip(a)} returns an element,{} which is a left inverse of \\spad{a},{} or \\spad{\"failed\"} if there is no unit element,{} if such an element doesn't exist or cannot be determined (see unitsKnown).")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(a)} returns an element,{} which is both a left and a right inverse of \\spad{a},{} or \\spad{\"failed\"} if there is no unit element,{} if such an element doesn't exist or cannot be determined (see unitsKnown).")) (|lieAlgebra?| (((|Boolean|)) "\\spad{lieAlgebra?()} tests if the algebra is anticommutative and \\spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra (Jacobi identity). Example: for every associative algebra \\spad{(A,+,@)} we can construct a Lie algebra \\spad{(A,+,*)},{} where \\spad{a*b := a@b-b@a}.")) (|jordanAlgebra?| (((|Boolean|)) "\\spad{jordanAlgebra?()} tests if the algebra is commutative,{} characteristic is not 2,{} and \\spad{(a*b)*a**2 - a*(b*a**2) = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra (Jordan identity). Example: for every associative algebra \\spad{(A,+,@)} we can construct a Jordan algebra \\spad{(A,+,*)},{} where \\spad{a*b := (a@b+b@a)/2}.")) (|noncommutativeJordanAlgebra?| (((|Boolean|)) "\\spad{noncommutativeJordanAlgebra?()} tests if the algebra is flexible and Jordan admissible.")) (|jordanAdmissible?| (((|Boolean|)) "\\spad{jordanAdmissible?()} tests if 2 is invertible in the coefficient domain and the multiplication defined by \\spad{(1/2)(a*b+b*a)} determines a Jordan algebra,{} \\spadignore{i.e.} satisfies the Jordan identity. The property of \\spadatt{commutative(\"*\")} follows from by definition.")) (|lieAdmissible?| (((|Boolean|)) "\\spad{lieAdmissible?()} tests if the algebra defined by the commutators is a Lie algebra,{} \\spadignore{i.e.} satisfies the Jacobi identity. The property of anticommutativity follows from definition.")) (|jacobiIdentity?| (((|Boolean|)) "\\spad{jacobiIdentity?()} tests if \\spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra. For example,{} this holds for crossed products of 3-dimensional vectors.")) (|powerAssociative?| (((|Boolean|)) "\\spad{powerAssociative?()} tests if all subalgebras generated by a single element are associative.")) (|alternative?| (((|Boolean|)) "\\spad{alternative?()} tests if \\spad{2*associator(a,a,b) = 0 = 2*associator(a,b,b)} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|flexible?| (((|Boolean|)) "\\spad{flexible?()} tests if \\spad{2*associator(a,b,a) = 0} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|rightAlternative?| (((|Boolean|)) "\\spad{rightAlternative?()} tests if \\spad{2*associator(a,b,b) = 0} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|leftAlternative?| (((|Boolean|)) "\\spad{leftAlternative?()} tests if \\spad{2*associator(a,a,b) = 0} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|antiAssociative?| (((|Boolean|)) "\\spad{antiAssociative?()} tests if multiplication in algebra is anti-associative,{} \\spadignore{i.e.} \\spad{(a*b)*c + a*(b*c) = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra.")) (|associative?| (((|Boolean|)) "\\spad{associative?()} tests if multiplication in algebra is associative.")) (|antiCommutative?| (((|Boolean|)) "\\spad{antiCommutative?()} tests if \\spad{a*a = 0} for all \\spad{a} in the algebra. Note: this implies \\spad{a*b + b*a = 0} for all \\spad{a} and \\spad{b}.")) (|commutative?| (((|Boolean|)) "\\spad{commutative?()} tests if multiplication in the algebra is commutative.")) (|rightCharacteristicPolynomial| (((|SparseUnivariatePolynomial| |#2|) $) "\\spad{rightCharacteristicPolynomial(a)} returns the characteristic polynomial of the right regular representation of \\spad{a} with respect to any basis.")) (|leftCharacteristicPolynomial| (((|SparseUnivariatePolynomial| |#2|) $) "\\spad{leftCharacteristicPolynomial(a)} returns the characteristic polynomial of the left regular representation of \\spad{a} with respect to any basis.")) (|rightTraceMatrix| (((|Matrix| |#2|) (|Vector| $)) "\\spad{rightTraceMatrix([v1,...,vn])} is the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the right trace of the product \\spad{vi*vj}.")) (|leftTraceMatrix| (((|Matrix| |#2|) (|Vector| $)) "\\spad{leftTraceMatrix([v1,...,vn])} is the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the left trace of the product \\spad{vi*vj}.")) (|rightDiscriminant| ((|#2| (|Vector| $)) "\\spad{rightDiscriminant([v1,...,vn])} returns the determinant of the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the right trace of the product \\spad{vi*vj}. Note: the same as \\spad{determinant(rightTraceMatrix([v1,...,vn]))}.")) (|leftDiscriminant| ((|#2| (|Vector| $)) "\\spad{leftDiscriminant([v1,...,vn])} returns the determinant of the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the left trace of the product \\spad{vi*vj}. Note: the same as \\spad{determinant(leftTraceMatrix([v1,...,vn]))}.")) (|represents| (($ (|Vector| |#2|) (|Vector| $)) "\\spad{represents([a1,...,am],[v1,...,vm])} returns the linear combination \\spad{a1*vm + ... + an*vm}.")) (|coordinates| (((|Matrix| |#2|) (|Vector| $) (|Vector| $)) "\\spad{coordinates([a1,...,am],[v1,...,vn])} returns a matrix whose \\spad{i}-th row is formed by the coordinates of \\spad{ai} with respect to the \\spad{R}-module basis \\spad{v1},{}...,{}\\spad{vn}.") (((|Vector| |#2|) $ (|Vector| $)) "\\spad{coordinates(a,[v1,...,vn])} returns the coordinates of \\spad{a} with respect to the \\spad{R}-module basis \\spad{v1},{}...,{}\\spad{vn}.")) (|rightNorm| ((|#2| $) "\\spad{rightNorm(a)} returns the determinant of the right regular representation of \\spad{a}.")) (|leftNorm| ((|#2| $) "\\spad{leftNorm(a)} returns the determinant of the left regular representation of \\spad{a}.")) (|rightTrace| ((|#2| $) "\\spad{rightTrace(a)} returns the trace of the right regular representation of \\spad{a}.")) (|leftTrace| ((|#2| $) "\\spad{leftTrace(a)} returns the trace of the left regular representation of \\spad{a}.")) (|rightRegularRepresentation| (((|Matrix| |#2|) $ (|Vector| $)) "\\spad{rightRegularRepresentation(a,[v1,...,vn])} returns the matrix of the linear map defined by right multiplication by \\spad{a} with respect to the \\spad{R}-module basis \\spad{[v1,...,vn]}.")) (|leftRegularRepresentation| (((|Matrix| |#2|) $ (|Vector| $)) "\\spad{leftRegularRepresentation(a,[v1,...,vn])} returns the matrix of the linear map defined by left multiplication by \\spad{a} with respect to the \\spad{R}-module basis \\spad{[v1,...,vn]}.")) (|structuralConstants| (((|Vector| (|Matrix| |#2|)) (|Vector| $)) "\\spad{structuralConstants([v1,v2,...,vm])} calculates the structural constants \\spad{[(gammaijk) for k in 1..m]} defined by \\spad{vi * vj = gammaij1 * v1 + ... + gammaijm * vm},{} where \\spad{[v1,...,vm]} is an \\spad{R}-module basis of a subalgebra.")) (|conditionsForIdempotents| (((|List| (|Polynomial| |#2|)) (|Vector| $)) "\\spad{conditionsForIdempotents([v1,...,vn])} determines a complete list of polynomial equations for the coefficients of idempotents with respect to the \\spad{R}-module basis \\spad{v1},{}...,{}\\spad{vn}.")) (|rank| (((|PositiveInteger|)) "\\spad{rank()} returns the rank of the algebra as \\spad{R}-module.")) (|someBasis| (((|Vector| $)) "\\spad{someBasis()} returns some \\spad{R}-module basis."))) 
+((|constructor| (NIL "A FiniteRankNonAssociativeAlgebra is a non associative algebra over a commutative ring \\spad{R} which is a free \\spad{R}-module of finite rank.")) (|unit| (((|Union| $ "failed")) "\\spad{unit()} returns a unit of the algebra (necessarily unique),{} or \\spad{\"failed\"} if there is none.")) (|rightUnit| (((|Union| $ "failed")) "\\spad{rightUnit()} returns a right unit of the algebra (not necessarily unique),{} or \\spad{\"failed\"} if there is none.")) (|leftUnit| (((|Union| $ "failed")) "\\spad{leftUnit()} returns a left unit of the algebra (not necessarily unique),{} or \\spad{\"failed\"} if there is none.")) (|rightUnits| (((|Union| (|Record| (|:| |particular| $) (|:| |basis| (|List| $))) "failed")) "\\spad{rightUnits()} returns the affine space of all right units of the algebra,{} or \\spad{\"failed\"} if there is none.")) (|leftUnits| (((|Union| (|Record| (|:| |particular| $) (|:| |basis| (|List| $))) "failed")) "\\spad{leftUnits()} returns the affine space of all left units of the algebra,{} or \\spad{\"failed\"} if there is none.")) (|rightMinimalPolynomial| (((|SparseUnivariatePolynomial| |#2|) $) "\\spad{rightMinimalPolynomial(a)} returns the polynomial determined by the smallest non-trivial linear combination of right powers of \\spad{a}. Note: the polynomial never has a constant term as in general the algebra has no unit.")) (|leftMinimalPolynomial| (((|SparseUnivariatePolynomial| |#2|) $) "\\spad{leftMinimalPolynomial(a)} returns the polynomial determined by the smallest non-trivial linear combination of left powers of \\spad{a}. Note: the polynomial never has a constant term as in general the algebra has no unit.")) (|associatorDependence| (((|List| (|Vector| |#2|))) "\\spad{associatorDependence()} looks for the associator identities,{} \\spadignore{i.e.} finds a basis of the solutions of the linear combinations of the six permutations of \\spad{associator(a,b,c)} which yield 0,{} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra. The order of the permutations is \\spad{123 231 312 132 321 213}.")) (|rightRecip| (((|Union| $ "failed") $) "\\spad{rightRecip(a)} returns an element,{} which is a right inverse of \\spad{a},{} or \\spad{\"failed\"} if there is no unit element,{} if such an element doesn't exist or cannot be determined.")) (|leftRecip| (((|Union| $ "failed") $) "\\spad{leftRecip(a)} returns an element,{} which is a left inverse of \\spad{a},{} or \\spad{\"failed\"} if there is no unit element,{} if such an element doesn't exist or cannot be determined.")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(a)} returns an element,{} which is both a left and a right inverse of \\spad{a},{} or \\spad{\"failed\"} if there is no unit element,{} if such an element doesn't exist or cannot be determined.")) (|lieAlgebra?| (((|Boolean|)) "\\spad{lieAlgebra?()} tests if the algebra is anticommutative and \\spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra (Jacobi identity). Example: for every associative algebra \\spad{(A,+,@)} we can construct a Lie algebra \\spad{(A,+,*)},{} where \\spad{a*b := a@b-b@a}.")) (|jordanAlgebra?| (((|Boolean|)) "\\spad{jordanAlgebra?()} tests if the algebra is commutative,{} characteristic is not 2,{} and \\spad{(a*b)*a**2 - a*(b*a**2) = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra (Jordan identity). Example: for every associative algebra \\spad{(A,+,@)} we can construct a Jordan algebra \\spad{(A,+,*)},{} where \\spad{a*b := (a@b+b@a)/2}.")) (|noncommutativeJordanAlgebra?| (((|Boolean|)) "\\spad{noncommutativeJordanAlgebra?()} tests if the algebra is flexible and Jordan admissible.")) (|jordanAdmissible?| (((|Boolean|)) "\\spad{jordanAdmissible?()} tests if 2 is invertible in the coefficient domain and the multiplication defined by \\spad{(1/2)(a*b+b*a)} determines a Jordan algebra,{} \\spadignore{i.e.} satisfies the Jordan identity. The property of \\spadatt{commutative(\"*\")} follows from by definition.")) (|lieAdmissible?| (((|Boolean|)) "\\spad{lieAdmissible?()} tests if the algebra defined by the commutators is a Lie algebra,{} \\spadignore{i.e.} satisfies the Jacobi identity. The property of anticommutativity follows from definition.")) (|jacobiIdentity?| (((|Boolean|)) "\\spad{jacobiIdentity?()} tests if \\spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra. For example,{} this holds for crossed products of 3-dimensional vectors.")) (|powerAssociative?| (((|Boolean|)) "\\spad{powerAssociative?()} tests if all subalgebras generated by a single element are associative.")) (|alternative?| (((|Boolean|)) "\\spad{alternative?()} tests if \\spad{2*associator(a,a,b) = 0 = 2*associator(a,b,b)} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|flexible?| (((|Boolean|)) "\\spad{flexible?()} tests if \\spad{2*associator(a,b,a) = 0} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|rightAlternative?| (((|Boolean|)) "\\spad{rightAlternative?()} tests if \\spad{2*associator(a,b,b) = 0} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|leftAlternative?| (((|Boolean|)) "\\spad{leftAlternative?()} tests if \\spad{2*associator(a,a,b) = 0} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|antiAssociative?| (((|Boolean|)) "\\spad{antiAssociative?()} tests if multiplication in algebra is anti-associative,{} \\spadignore{i.e.} \\spad{(a*b)*c + a*(b*c) = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra.")) (|associative?| (((|Boolean|)) "\\spad{associative?()} tests if multiplication in algebra is associative.")) (|antiCommutative?| (((|Boolean|)) "\\spad{antiCommutative?()} tests if \\spad{a*a = 0} for all \\spad{a} in the algebra. Note: this implies \\spad{a*b + b*a = 0} for all \\spad{a} and \\spad{b}.")) (|commutative?| (((|Boolean|)) "\\spad{commutative?()} tests if multiplication in the algebra is commutative.")) (|rightCharacteristicPolynomial| (((|SparseUnivariatePolynomial| |#2|) $) "\\spad{rightCharacteristicPolynomial(a)} returns the characteristic polynomial of the right regular representation of \\spad{a} with respect to any basis.")) (|leftCharacteristicPolynomial| (((|SparseUnivariatePolynomial| |#2|) $) "\\spad{leftCharacteristicPolynomial(a)} returns the characteristic polynomial of the left regular representation of \\spad{a} with respect to any basis.")) (|rightTraceMatrix| (((|Matrix| |#2|) (|Vector| $)) "\\spad{rightTraceMatrix([v1,...,vn])} is the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the right trace of the product \\spad{vi*vj}.")) (|leftTraceMatrix| (((|Matrix| |#2|) (|Vector| $)) "\\spad{leftTraceMatrix([v1,...,vn])} is the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the left trace of the product \\spad{vi*vj}.")) (|rightDiscriminant| ((|#2| (|Vector| $)) "\\spad{rightDiscriminant([v1,...,vn])} returns the determinant of the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the right trace of the product \\spad{vi*vj}. Note: the same as \\spad{determinant(rightTraceMatrix([v1,...,vn]))}.")) (|leftDiscriminant| ((|#2| (|Vector| $)) "\\spad{leftDiscriminant([v1,...,vn])} returns the determinant of the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the left trace of the product \\spad{vi*vj}. Note: the same as \\spad{determinant(leftTraceMatrix([v1,...,vn]))}.")) (|represents| (($ (|Vector| |#2|) (|Vector| $)) "\\spad{represents([a1,...,am],[v1,...,vm])} returns the linear combination \\spad{a1*vm + ... + an*vm}.")) (|coordinates| (((|Matrix| |#2|) (|Vector| $) (|Vector| $)) "\\spad{coordinates([a1,...,am],[v1,...,vn])} returns a matrix whose \\spad{i}-th row is formed by the coordinates of \\spad{ai} with respect to the \\spad{R}-module basis \\spad{v1},{}...,{}\\spad{vn}.") (((|Vector| |#2|) $ (|Vector| $)) "\\spad{coordinates(a,[v1,...,vn])} returns the coordinates of \\spad{a} with respect to the \\spad{R}-module basis \\spad{v1},{}...,{}\\spad{vn}.")) (|rightNorm| ((|#2| $) "\\spad{rightNorm(a)} returns the determinant of the right regular representation of \\spad{a}.")) (|leftNorm| ((|#2| $) "\\spad{leftNorm(a)} returns the determinant of the left regular representation of \\spad{a}.")) (|rightTrace| ((|#2| $) "\\spad{rightTrace(a)} returns the trace of the right regular representation of \\spad{a}.")) (|leftTrace| ((|#2| $) "\\spad{leftTrace(a)} returns the trace of the left regular representation of \\spad{a}.")) (|rightRegularRepresentation| (((|Matrix| |#2|) $ (|Vector| $)) "\\spad{rightRegularRepresentation(a,[v1,...,vn])} returns the matrix of the linear map defined by right multiplication by \\spad{a} with respect to the \\spad{R}-module basis \\spad{[v1,...,vn]}.")) (|leftRegularRepresentation| (((|Matrix| |#2|) $ (|Vector| $)) "\\spad{leftRegularRepresentation(a,[v1,...,vn])} returns the matrix of the linear map defined by left multiplication by \\spad{a} with respect to the \\spad{R}-module basis \\spad{[v1,...,vn]}.")) (|structuralConstants| (((|Vector| (|Matrix| |#2|)) (|Vector| $)) "\\spad{structuralConstants([v1,v2,...,vm])} calculates the structural constants \\spad{[(gammaijk) for k in 1..m]} defined by \\spad{vi * vj = gammaij1 * v1 + ... + gammaijm * vm},{} where \\spad{[v1,...,vm]} is an \\spad{R}-module basis of a subalgebra.")) (|conditionsForIdempotents| (((|List| (|Polynomial| |#2|)) (|Vector| $)) "\\spad{conditionsForIdempotents([v1,...,vn])} determines a complete list of polynomial equations for the coefficients of idempotents with respect to the \\spad{R}-module basis \\spad{v1},{}...,{}\\spad{vn}.")) (|rank| (((|PositiveInteger|)) "\\spad{rank()} returns the rank of the algebra as \\spad{R}-module.")) (|someBasis| (((|Vector| $)) "\\spad{someBasis()} returns some \\spad{R}-module basis."))) 
 NIL 
 ((|HasCategory| |#2| (QUOTE (|IntegralDomain|)))) 
 (|FiniteRankNonAssociativeAlgebra| R) 
-((|constructor| (NIL "A FiniteRankNonAssociativeAlgebra is a non associative algebra over a commutative ring \\spad{R} which is a free \\spad{R}-module of finite rank.")) (|unitsKnown| ((|attribute|) "unitsKnown means that \\spadfun{recip} truly yields reciprocal or \\spad{\"failed\"} if not a unit,{} similarly for \\spadfun{leftRecip} and \\spadfun{rightRecip}. The reason is that we use left,{} respectively right,{} minimal polynomials to decide this question.")) (|unit| (((|Union| $ "failed")) "\\spad{unit()} returns a unit of the algebra (necessarily unique),{} or \\spad{\"failed\"} if there is none.")) (|rightUnit| (((|Union| $ "failed")) "\\spad{rightUnit()} returns a right unit of the algebra (not necessarily unique),{} or \\spad{\"failed\"} if there is none.")) (|leftUnit| (((|Union| $ "failed")) "\\spad{leftUnit()} returns a left unit of the algebra (not necessarily unique),{} or \\spad{\"failed\"} if there is none.")) (|rightUnits| (((|Union| (|Record| (|:| |particular| $) (|:| |basis| (|List| $))) "failed")) "\\spad{rightUnits()} returns the affine space of all right units of the algebra,{} or \\spad{\"failed\"} if there is none.")) (|leftUnits| (((|Union| (|Record| (|:| |particular| $) (|:| |basis| (|List| $))) "failed")) "\\spad{leftUnits()} returns the affine space of all left units of the algebra,{} or \\spad{\"failed\"} if there is none.")) (|rightMinimalPolynomial| (((|SparseUnivariatePolynomial| |#1|) $) "\\spad{rightMinimalPolynomial(a)} returns the polynomial determined by the smallest non-trivial linear combination of right powers of \\spad{a}. Note: the polynomial never has a constant term as in general the algebra has no unit.")) (|leftMinimalPolynomial| (((|SparseUnivariatePolynomial| |#1|) $) "\\spad{leftMinimalPolynomial(a)} returns the polynomial determined by the smallest non-trivial linear combination of left powers of \\spad{a}. Note: the polynomial never has a constant term as in general the algebra has no unit.")) (|associatorDependence| (((|List| (|Vector| |#1|))) "\\spad{associatorDependence()} looks for the associator identities,{} \\spadignore{i.e.} finds a basis of the solutions of the linear combinations of the six permutations of \\spad{associator(a,b,c)} which yield 0,{} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra. The order of the permutations is \\spad{123 231 312 132 321 213}.")) (|rightRecip| (((|Union| $ "failed") $) "\\spad{rightRecip(a)} returns an element,{} which is a right inverse of \\spad{a},{} or \\spad{\"failed\"} if there is no unit element,{} if such an element doesn't exist or cannot be determined (see unitsKnown).")) (|leftRecip| (((|Union| $ "failed") $) "\\spad{leftRecip(a)} returns an element,{} which is a left inverse of \\spad{a},{} or \\spad{\"failed\"} if there is no unit element,{} if such an element doesn't exist or cannot be determined (see unitsKnown).")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(a)} returns an element,{} which is both a left and a right inverse of \\spad{a},{} or \\spad{\"failed\"} if there is no unit element,{} if such an element doesn't exist or cannot be determined (see unitsKnown).")) (|lieAlgebra?| (((|Boolean|)) "\\spad{lieAlgebra?()} tests if the algebra is anticommutative and \\spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra (Jacobi identity). Example: for every associative algebra \\spad{(A,+,@)} we can construct a Lie algebra \\spad{(A,+,*)},{} where \\spad{a*b := a@b-b@a}.")) (|jordanAlgebra?| (((|Boolean|)) "\\spad{jordanAlgebra?()} tests if the algebra is commutative,{} characteristic is not 2,{} and \\spad{(a*b)*a**2 - a*(b*a**2) = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra (Jordan identity). Example: for every associative algebra \\spad{(A,+,@)} we can construct a Jordan algebra \\spad{(A,+,*)},{} where \\spad{a*b := (a@b+b@a)/2}.")) (|noncommutativeJordanAlgebra?| (((|Boolean|)) "\\spad{noncommutativeJordanAlgebra?()} tests if the algebra is flexible and Jordan admissible.")) (|jordanAdmissible?| (((|Boolean|)) "\\spad{jordanAdmissible?()} tests if 2 is invertible in the coefficient domain and the multiplication defined by \\spad{(1/2)(a*b+b*a)} determines a Jordan algebra,{} \\spadignore{i.e.} satisfies the Jordan identity. The property of \\spadatt{commutative(\"*\")} follows from by definition.")) (|lieAdmissible?| (((|Boolean|)) "\\spad{lieAdmissible?()} tests if the algebra defined by the commutators is a Lie algebra,{} \\spadignore{i.e.} satisfies the Jacobi identity. The property of anticommutativity follows from definition.")) (|jacobiIdentity?| (((|Boolean|)) "\\spad{jacobiIdentity?()} tests if \\spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra. For example,{} this holds for crossed products of 3-dimensional vectors.")) (|powerAssociative?| (((|Boolean|)) "\\spad{powerAssociative?()} tests if all subalgebras generated by a single element are associative.")) (|alternative?| (((|Boolean|)) "\\spad{alternative?()} tests if \\spad{2*associator(a,a,b) = 0 = 2*associator(a,b,b)} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|flexible?| (((|Boolean|)) "\\spad{flexible?()} tests if \\spad{2*associator(a,b,a) = 0} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|rightAlternative?| (((|Boolean|)) "\\spad{rightAlternative?()} tests if \\spad{2*associator(a,b,b) = 0} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|leftAlternative?| (((|Boolean|)) "\\spad{leftAlternative?()} tests if \\spad{2*associator(a,a,b) = 0} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|antiAssociative?| (((|Boolean|)) "\\spad{antiAssociative?()} tests if multiplication in algebra is anti-associative,{} \\spadignore{i.e.} \\spad{(a*b)*c + a*(b*c) = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra.")) (|associative?| (((|Boolean|)) "\\spad{associative?()} tests if multiplication in algebra is associative.")) (|antiCommutative?| (((|Boolean|)) "\\spad{antiCommutative?()} tests if \\spad{a*a = 0} for all \\spad{a} in the algebra. Note: this implies \\spad{a*b + b*a = 0} for all \\spad{a} and \\spad{b}.")) (|commutative?| (((|Boolean|)) "\\spad{commutative?()} tests if multiplication in the algebra is commutative.")) (|rightCharacteristicPolynomial| (((|SparseUnivariatePolynomial| |#1|) $) "\\spad{rightCharacteristicPolynomial(a)} returns the characteristic polynomial of the right regular representation of \\spad{a} with respect to any basis.")) (|leftCharacteristicPolynomial| (((|SparseUnivariatePolynomial| |#1|) $) "\\spad{leftCharacteristicPolynomial(a)} returns the characteristic polynomial of the left regular representation of \\spad{a} with respect to any basis.")) (|rightTraceMatrix| (((|Matrix| |#1|) (|Vector| $)) "\\spad{rightTraceMatrix([v1,...,vn])} is the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the right trace of the product \\spad{vi*vj}.")) (|leftTraceMatrix| (((|Matrix| |#1|) (|Vector| $)) "\\spad{leftTraceMatrix([v1,...,vn])} is the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the left trace of the product \\spad{vi*vj}.")) (|rightDiscriminant| ((|#1| (|Vector| $)) "\\spad{rightDiscriminant([v1,...,vn])} returns the determinant of the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the right trace of the product \\spad{vi*vj}. Note: the same as \\spad{determinant(rightTraceMatrix([v1,...,vn]))}.")) (|leftDiscriminant| ((|#1| (|Vector| $)) "\\spad{leftDiscriminant([v1,...,vn])} returns the determinant of the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the left trace of the product \\spad{vi*vj}. Note: the same as \\spad{determinant(leftTraceMatrix([v1,...,vn]))}.")) (|represents| (($ (|Vector| |#1|) (|Vector| $)) "\\spad{represents([a1,...,am],[v1,...,vm])} returns the linear combination \\spad{a1*vm + ... + an*vm}.")) (|coordinates| (((|Matrix| |#1|) (|Vector| $) (|Vector| $)) "\\spad{coordinates([a1,...,am],[v1,...,vn])} returns a matrix whose \\spad{i}-th row is formed by the coordinates of \\spad{ai} with respect to the \\spad{R}-module basis \\spad{v1},{}...,{}\\spad{vn}.") (((|Vector| |#1|) $ (|Vector| $)) "\\spad{coordinates(a,[v1,...,vn])} returns the coordinates of \\spad{a} with respect to the \\spad{R}-module basis \\spad{v1},{}...,{}\\spad{vn}.")) (|rightNorm| ((|#1| $) "\\spad{rightNorm(a)} returns the determinant of the right regular representation of \\spad{a}.")) (|leftNorm| ((|#1| $) "\\spad{leftNorm(a)} returns the determinant of the left regular representation of \\spad{a}.")) (|rightTrace| ((|#1| $) "\\spad{rightTrace(a)} returns the trace of the right regular representation of \\spad{a}.")) (|leftTrace| ((|#1| $) "\\spad{leftTrace(a)} returns the trace of the left regular representation of \\spad{a}.")) (|rightRegularRepresentation| (((|Matrix| |#1|) $ (|Vector| $)) "\\spad{rightRegularRepresentation(a,[v1,...,vn])} returns the matrix of the linear map defined by right multiplication by \\spad{a} with respect to the \\spad{R}-module basis \\spad{[v1,...,vn]}.")) (|leftRegularRepresentation| (((|Matrix| |#1|) $ (|Vector| $)) "\\spad{leftRegularRepresentation(a,[v1,...,vn])} returns the matrix of the linear map defined by left multiplication by \\spad{a} with respect to the \\spad{R}-module basis \\spad{[v1,...,vn]}.")) (|structuralConstants| (((|Vector| (|Matrix| |#1|)) (|Vector| $)) "\\spad{structuralConstants([v1,v2,...,vm])} calculates the structural constants \\spad{[(gammaijk) for k in 1..m]} defined by \\spad{vi * vj = gammaij1 * v1 + ... + gammaijm * vm},{} where \\spad{[v1,...,vm]} is an \\spad{R}-module basis of a subalgebra.")) (|conditionsForIdempotents| (((|List| (|Polynomial| |#1|)) (|Vector| $)) "\\spad{conditionsForIdempotents([v1,...,vn])} determines a complete list of polynomial equations for the coefficients of idempotents with respect to the \\spad{R}-module basis \\spad{v1},{}...,{}\\spad{vn}.")) (|rank| (((|PositiveInteger|)) "\\spad{rank()} returns the rank of the algebra as \\spad{R}-module.")) (|someBasis| (((|Vector| $)) "\\spad{someBasis()} returns some \\spad{R}-module basis."))) 
-((|unitsKnown| |has| |#1| (|IntegralDomain|)) (|leftUnitary| . T) (|rightUnitary| . T)) 
+((|constructor| (NIL "A FiniteRankNonAssociativeAlgebra is a non associative algebra over a commutative ring \\spad{R} which is a free \\spad{R}-module of finite rank.")) (|unit| (((|Union| $ "failed")) "\\spad{unit()} returns a unit of the algebra (necessarily unique),{} or \\spad{\"failed\"} if there is none.")) (|rightUnit| (((|Union| $ "failed")) "\\spad{rightUnit()} returns a right unit of the algebra (not necessarily unique),{} or \\spad{\"failed\"} if there is none.")) (|leftUnit| (((|Union| $ "failed")) "\\spad{leftUnit()} returns a left unit of the algebra (not necessarily unique),{} or \\spad{\"failed\"} if there is none.")) (|rightUnits| (((|Union| (|Record| (|:| |particular| $) (|:| |basis| (|List| $))) "failed")) "\\spad{rightUnits()} returns the affine space of all right units of the algebra,{} or \\spad{\"failed\"} if there is none.")) (|leftUnits| (((|Union| (|Record| (|:| |particular| $) (|:| |basis| (|List| $))) "failed")) "\\spad{leftUnits()} returns the affine space of all left units of the algebra,{} or \\spad{\"failed\"} if there is none.")) (|rightMinimalPolynomial| (((|SparseUnivariatePolynomial| |#1|) $) "\\spad{rightMinimalPolynomial(a)} returns the polynomial determined by the smallest non-trivial linear combination of right powers of \\spad{a}. Note: the polynomial never has a constant term as in general the algebra has no unit.")) (|leftMinimalPolynomial| (((|SparseUnivariatePolynomial| |#1|) $) "\\spad{leftMinimalPolynomial(a)} returns the polynomial determined by the smallest non-trivial linear combination of left powers of \\spad{a}. Note: the polynomial never has a constant term as in general the algebra has no unit.")) (|associatorDependence| (((|List| (|Vector| |#1|))) "\\spad{associatorDependence()} looks for the associator identities,{} \\spadignore{i.e.} finds a basis of the solutions of the linear combinations of the six permutations of \\spad{associator(a,b,c)} which yield 0,{} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra. The order of the permutations is \\spad{123 231 312 132 321 213}.")) (|rightRecip| (((|Union| $ "failed") $) "\\spad{rightRecip(a)} returns an element,{} which is a right inverse of \\spad{a},{} or \\spad{\"failed\"} if there is no unit element,{} if such an element doesn't exist or cannot be determined.")) (|leftRecip| (((|Union| $ "failed") $) "\\spad{leftRecip(a)} returns an element,{} which is a left inverse of \\spad{a},{} or \\spad{\"failed\"} if there is no unit element,{} if such an element doesn't exist or cannot be determined.")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(a)} returns an element,{} which is both a left and a right inverse of \\spad{a},{} or \\spad{\"failed\"} if there is no unit element,{} if such an element doesn't exist or cannot be determined.")) (|lieAlgebra?| (((|Boolean|)) "\\spad{lieAlgebra?()} tests if the algebra is anticommutative and \\spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra (Jacobi identity). Example: for every associative algebra \\spad{(A,+,@)} we can construct a Lie algebra \\spad{(A,+,*)},{} where \\spad{a*b := a@b-b@a}.")) (|jordanAlgebra?| (((|Boolean|)) "\\spad{jordanAlgebra?()} tests if the algebra is commutative,{} characteristic is not 2,{} and \\spad{(a*b)*a**2 - a*(b*a**2) = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra (Jordan identity). Example: for every associative algebra \\spad{(A,+,@)} we can construct a Jordan algebra \\spad{(A,+,*)},{} where \\spad{a*b := (a@b+b@a)/2}.")) (|noncommutativeJordanAlgebra?| (((|Boolean|)) "\\spad{noncommutativeJordanAlgebra?()} tests if the algebra is flexible and Jordan admissible.")) (|jordanAdmissible?| (((|Boolean|)) "\\spad{jordanAdmissible?()} tests if 2 is invertible in the coefficient domain and the multiplication defined by \\spad{(1/2)(a*b+b*a)} determines a Jordan algebra,{} \\spadignore{i.e.} satisfies the Jordan identity. The property of \\spadatt{commutative(\"*\")} follows from by definition.")) (|lieAdmissible?| (((|Boolean|)) "\\spad{lieAdmissible?()} tests if the algebra defined by the commutators is a Lie algebra,{} \\spadignore{i.e.} satisfies the Jacobi identity. The property of anticommutativity follows from definition.")) (|jacobiIdentity?| (((|Boolean|)) "\\spad{jacobiIdentity?()} tests if \\spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra. For example,{} this holds for crossed products of 3-dimensional vectors.")) (|powerAssociative?| (((|Boolean|)) "\\spad{powerAssociative?()} tests if all subalgebras generated by a single element are associative.")) (|alternative?| (((|Boolean|)) "\\spad{alternative?()} tests if \\spad{2*associator(a,a,b) = 0 = 2*associator(a,b,b)} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|flexible?| (((|Boolean|)) "\\spad{flexible?()} tests if \\spad{2*associator(a,b,a) = 0} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|rightAlternative?| (((|Boolean|)) "\\spad{rightAlternative?()} tests if \\spad{2*associator(a,b,b) = 0} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|leftAlternative?| (((|Boolean|)) "\\spad{leftAlternative?()} tests if \\spad{2*associator(a,a,b) = 0} for all \\spad{a},{} \\spad{b} in the algebra. Note: we only can test this; in general we don't know whether \\spad{2*a=0} implies \\spad{a=0}.")) (|antiAssociative?| (((|Boolean|)) "\\spad{antiAssociative?()} tests if multiplication in algebra is anti-associative,{} \\spadignore{i.e.} \\spad{(a*b)*c + a*(b*c) = 0} for all \\spad{a},{}\\spad{b},{}\\spad{c} in the algebra.")) (|associative?| (((|Boolean|)) "\\spad{associative?()} tests if multiplication in algebra is associative.")) (|antiCommutative?| (((|Boolean|)) "\\spad{antiCommutative?()} tests if \\spad{a*a = 0} for all \\spad{a} in the algebra. Note: this implies \\spad{a*b + b*a = 0} for all \\spad{a} and \\spad{b}.")) (|commutative?| (((|Boolean|)) "\\spad{commutative?()} tests if multiplication in the algebra is commutative.")) (|rightCharacteristicPolynomial| (((|SparseUnivariatePolynomial| |#1|) $) "\\spad{rightCharacteristicPolynomial(a)} returns the characteristic polynomial of the right regular representation of \\spad{a} with respect to any basis.")) (|leftCharacteristicPolynomial| (((|SparseUnivariatePolynomial| |#1|) $) "\\spad{leftCharacteristicPolynomial(a)} returns the characteristic polynomial of the left regular representation of \\spad{a} with respect to any basis.")) (|rightTraceMatrix| (((|Matrix| |#1|) (|Vector| $)) "\\spad{rightTraceMatrix([v1,...,vn])} is the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the right trace of the product \\spad{vi*vj}.")) (|leftTraceMatrix| (((|Matrix| |#1|) (|Vector| $)) "\\spad{leftTraceMatrix([v1,...,vn])} is the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the left trace of the product \\spad{vi*vj}.")) (|rightDiscriminant| ((|#1| (|Vector| $)) "\\spad{rightDiscriminant([v1,...,vn])} returns the determinant of the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the right trace of the product \\spad{vi*vj}. Note: the same as \\spad{determinant(rightTraceMatrix([v1,...,vn]))}.")) (|leftDiscriminant| ((|#1| (|Vector| $)) "\\spad{leftDiscriminant([v1,...,vn])} returns the determinant of the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the left trace of the product \\spad{vi*vj}. Note: the same as \\spad{determinant(leftTraceMatrix([v1,...,vn]))}.")) (|represents| (($ (|Vector| |#1|) (|Vector| $)) "\\spad{represents([a1,...,am],[v1,...,vm])} returns the linear combination \\spad{a1*vm + ... + an*vm}.")) (|coordinates| (((|Matrix| |#1|) (|Vector| $) (|Vector| $)) "\\spad{coordinates([a1,...,am],[v1,...,vn])} returns a matrix whose \\spad{i}-th row is formed by the coordinates of \\spad{ai} with respect to the \\spad{R}-module basis \\spad{v1},{}...,{}\\spad{vn}.") (((|Vector| |#1|) $ (|Vector| $)) "\\spad{coordinates(a,[v1,...,vn])} returns the coordinates of \\spad{a} with respect to the \\spad{R}-module basis \\spad{v1},{}...,{}\\spad{vn}.")) (|rightNorm| ((|#1| $) "\\spad{rightNorm(a)} returns the determinant of the right regular representation of \\spad{a}.")) (|leftNorm| ((|#1| $) "\\spad{leftNorm(a)} returns the determinant of the left regular representation of \\spad{a}.")) (|rightTrace| ((|#1| $) "\\spad{rightTrace(a)} returns the trace of the right regular representation of \\spad{a}.")) (|leftTrace| ((|#1| $) "\\spad{leftTrace(a)} returns the trace of the left regular representation of \\spad{a}.")) (|rightRegularRepresentation| (((|Matrix| |#1|) $ (|Vector| $)) "\\spad{rightRegularRepresentation(a,[v1,...,vn])} returns the matrix of the linear map defined by right multiplication by \\spad{a} with respect to the \\spad{R}-module basis \\spad{[v1,...,vn]}.")) (|leftRegularRepresentation| (((|Matrix| |#1|) $ (|Vector| $)) "\\spad{leftRegularRepresentation(a,[v1,...,vn])} returns the matrix of the linear map defined by left multiplication by \\spad{a} with respect to the \\spad{R}-module basis \\spad{[v1,...,vn]}.")) (|structuralConstants| (((|Vector| (|Matrix| |#1|)) (|Vector| $)) "\\spad{structuralConstants([v1,v2,...,vm])} calculates the structural constants \\spad{[(gammaijk) for k in 1..m]} defined by \\spad{vi * vj = gammaij1 * v1 + ... + gammaijm * vm},{} where \\spad{[v1,...,vm]} is an \\spad{R}-module basis of a subalgebra.")) (|conditionsForIdempotents| (((|List| (|Polynomial| |#1|)) (|Vector| $)) "\\spad{conditionsForIdempotents([v1,...,vn])} determines a complete list of polynomial equations for the coefficients of idempotents with respect to the \\spad{R}-module basis \\spad{v1},{}...,{}\\spad{vn}.")) (|rank| (((|PositiveInteger|)) "\\spad{rank()} returns the rank of the algebra as \\spad{R}-module.")) (|someBasis| (((|Vector| $)) "\\spad{someBasis()} returns some \\spad{R}-module basis."))) 
+NIL 
 NIL 
 (|FiniteAggregate&| A S) 
 ((|constructor| (NIL "A finite aggregate is a homogeneous aggregate with a finite number of elements.")) (|member?| (((|Boolean|) |#2| $) "\\spad{member?(x,u)} tests if \\spad{x} is a member of \\spad{u}. For collections,{} \\axiom{member?(\\spad{x},{}\\spad{u}) = reduce(or,{}[x=y for \\spad{y} in \\spad{u}],{}\\spad{false})}.")) (|find| (((|Union| |#2| "failed") (|Mapping| (|Boolean|) |#2|) $) "\\spad{find(p,u)} returns the first \\spad{x} in \\spad{u} such that \\spad{p(x)} is \\spad{true},{} and \\spad{\"failed\"} otherwise.")) (|reduce| ((|#2| (|Mapping| |#2| |#2| |#2|) $ |#2| |#2|) "\\spad{reduce(f,u,x,z)} reduces the binary operation \\spad{f} across \\spad{u},{} stopping when an \"absorbing element\" \\spad{z} is encountered. As for \\spad{reduce(f,u,x)},{} \\spad{x} is the identity operation of \\spad{f}. Same as \\spad{reduce(f,u,x)} when \\spad{u} contains no element \\spad{z}. Thus the third argument \\spad{x} is returned when \\spad{u} is empty.") ((|#2| (|Mapping| |#2| |#2| |#2|) $ |#2|) "\\spad{reduce(f,u,x)} reduces the binary operation \\spad{f} across \\spad{u},{} where \\spad{x} is the starting value,{} usually the identity operation of \\spad{f}. Same as \\spad{reduce(f,u)} if \\spad{u} has 2 or more elements. Returns \\spad{f(x,y)} if \\spad{u} has one element \\spad{y},{} \\spad{x} if \\spad{u} is empty. For example,{} \\spad{reduce(+,u,0)} returns the sum of the elements of \\spad{u}.") ((|#2| (|Mapping| |#2| |#2| |#2|) $) "\\spad{reduce(f,u)} reduces the binary operation \\spad{f} across \\spad{u}. For example,{} if \\spad{u} is \\spad{[x,y,...,z]} then \\spad{reduce(f,u)} returns \\spad{f(..f(f(x,y),...),z)}. Note: if \\spad{u} has one element \\spad{x},{} \\spad{reduce(f,u)} returns \\spad{x}. Error: if \\spad{u} is empty.")) (|members| (((|List| |#2|) $) "\\spad{members(u)} returns a list of the consecutive elements of \\spad{u}. For collections,{} \\axiom{members([\\spad{x},{}\\spad{y},{}...,{}\\spad{z}]) = (\\spad{x},{}\\spad{y},{}...,{}\\spad{z})}.")) (|count| (((|NonNegativeInteger|) |#2| $) "\\spad{count(x,u)} returns the number of occurrences of \\spad{x} in \\spad{u}. For collections,{} \\axiom{count(\\spad{x},{}\\spad{u}) = reduce(+,{}[x=y for \\spad{y} in \\spad{u}],{}0)}.") (((|NonNegativeInteger|) (|Mapping| (|Boolean|) |#2|) $) "\\spad{count(p,u)} returns the number of elements \\spad{x} \\indented{1}{in \\spad{u} such that \\axiom{\\spad{p}(\\spad{x})} holds. For collections,{}} \\axiom{count(\\spad{p},{}\\spad{u}) = reduce(+,{}[1 for \\spad{x} in \\spad{u} | \\spad{p}(\\spad{x})],{}0)}.")) (|every?| (((|Boolean|) (|Mapping| (|Boolean|) |#2|) $) "\\spad{every?(f,u)} tests if \\spad{p}(\\spad{x}) holds for all elements \\spad{x} of \\spad{u}. Note: for collections,{} \\axiom{every?(\\spad{p},{}\\spad{u}) = reduce(and,{}map(\\spad{f},{}\\spad{u}),{}\\spad{true},{}\\spad{false})}.")) (|any?| (((|Boolean|) (|Mapping| (|Boolean|) |#2|) $) "\\spad{any?(p,u)} tests if \\spad{p(x)} is \\spad{true} for any element \\spad{x} of \\spad{u}. Note: for collections,{} \\axiom{any?(\\spad{p},{}\\spad{u}) = reduce(or,{}map(\\spad{f},{}\\spad{u}),{}\\spad{false},{}\\spad{true})}.")) (|#| (((|NonNegativeInteger|) $) "\\spad{\\#u} returns the number of items in \\spad{u}."))) 
@@ -1226,7 +1226,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|Field|)))) 
 (|FiniteRankAlgebra| R UP) 
 ((|constructor| (NIL "A FiniteRankAlgebra is an algebra over a commutative ring \\spad{R} which is a free \\spad{R}-module of finite rank.")) (|minimalPolynomial| ((|#2| $) "\\spad{minimalPolynomial(a)} returns the minimal polynomial of \\spad{a}.")) (|characteristicPolynomial| ((|#2| $) "\\spad{characteristicPolynomial(a)} returns the characteristic polynomial of the regular representation of \\spad{a} with respect to any basis.")) (|traceMatrix| (((|Matrix| |#1|) (|Vector| $)) "\\spad{traceMatrix([v1,..,vn])} is the \\spad{n}-by-\\spad{n} matrix ( Tr(\\spad{vi} * vj) )")) (|discriminant| ((|#1| (|Vector| $)) "\\spad{discriminant([v1,..,vn])} returns \\spad{determinant(traceMatrix([v1,..,vn]))}.")) (|represents| (($ (|Vector| |#1|) (|Vector| $)) "\\spad{represents([a1,..,an],[v1,..,vn])} returns \\spad{a1*v1 + ... + an*vn}.")) (|coordinates| (((|Matrix| |#1|) (|Vector| $) (|Vector| $)) "\\spad{coordinates([v1,...,vm], basis)} returns the coordinates of the \\spad{vi}'s with to the basis \\spad{basis}. The coordinates of \\spad{vi} are contained in the \\spad{i}th row of the matrix returned by this function.") (((|Vector| |#1|) $ (|Vector| $)) "\\spad{coordinates(a,basis)} returns the coordinates of \\spad{a} with respect to the \\spad{basis} \\spad{basis}.")) (|norm| ((|#1| $) "\\spad{norm(a)} returns the determinant of the regular representation of \\spad{a} with respect to any basis.")) (|trace| ((|#1| $) "\\spad{trace(a)} returns the trace of the regular representation of \\spad{a} with respect to any basis.")) (|regularRepresentation| (((|Matrix| |#1|) $ (|Vector| $)) "\\spad{regularRepresentation(a,basis)} returns the matrix of the linear map defined by left multiplication by \\spad{a} with respect to the \\spad{basis} \\spad{basis}.")) (|rank| (((|PositiveInteger|)) "\\spad{rank()} returns the rank of the algebra."))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 NIL 
 (|FiniteLinearAggregate&| A S) 
 ((|constructor| (NIL "A finite linear aggregate is a linear aggregate of finite length. The finite property of the aggregate adds several exports to the list of exports from \\spadtype{LinearAggregate} such as \\spadfun{reverse},{} \\spadfun{sort},{} and so on.")) (|sort!| (($ $) "\\spad{sort!(u)} returns \\spad{u} with its elements in ascending order.") (($ (|Mapping| (|Boolean|) |#2| |#2|) $) "\\spad{sort!(p,u)} returns \\spad{u} with its elements ordered by \\spad{p}.")) (|reverse!| (($ $) "\\spad{reverse!(u)} returns \\spad{u} with its elements in reverse order.")) (|copyInto!| (($ $ $ (|Integer|)) "\\spad{copyInto!(u,v,i)} returns aggregate \\spad{u} containing a copy of \\spad{v} inserted at element \\spad{i}.")) (|position| (((|Integer|) |#2| $ (|Integer|)) "\\spad{position(x,a,n)} returns the index \\spad{i} of the first occurrence of \\spad{x} in \\axiom{a} where \\axiom{\\spad{i} >= \\spad{n}},{} and \\axiom{minIndex(a) - 1} if no such \\spad{x} is found.") (((|Integer|) |#2| $) "\\spad{position(x,a)} returns the index \\spad{i} of the first occurrence of \\spad{x} in a,{} and \\axiom{minIndex(a) - 1} if there is no such \\spad{x}.") (((|Integer|) (|Mapping| (|Boolean|) |#2|) $) "\\spad{position(p,a)} returns the index \\spad{i} of the first \\spad{x} in \\axiom{a} such that \\axiom{\\spad{p}(\\spad{x})} is \\spad{true},{} and \\axiom{minIndex(a) - 1} if there is no such \\spad{x}.")) (|sorted?| (((|Boolean|) $) "\\spad{sorted?(u)} tests if the elements of \\spad{u} are in ascending order.") (((|Boolean|) (|Mapping| (|Boolean|) |#2| |#2|) $) "\\spad{sorted?(p,a)} tests if \\axiom{a} is sorted according to predicate \\spad{p}.")) (|sort| (($ $) "\\spad{sort(u)} returns an \\spad{u} with elements in ascending order. Note: \\axiom{sort(\\spad{u}) = sort(<=,{}\\spad{u})}.") (($ (|Mapping| (|Boolean|) |#2| |#2|) $) "\\spad{sort(p,a)} returns a copy of \\axiom{a} sorted using total ordering predicate \\spad{p}.")) (|reverse| (($ $) "\\spad{reverse(a)} returns a copy of \\axiom{a} with elements in reverse order.")) (|merge| (($ $ $) "\\spad{merge(u,v)} merges \\spad{u} and \\spad{v} in ascending order. Note: \\axiom{merge(\\spad{u},{}\\spad{v}) = merge(<=,{}\\spad{u},{}\\spad{v})}.") (($ (|Mapping| (|Boolean|) |#2| |#2|) $ $) "\\spad{merge(p,a,b)} returns an aggregate \\spad{c} which merges \\axiom{a} and \\spad{b}. The result is produced by examining each element \\spad{x} of \\axiom{a} and \\spad{y} of \\spad{b} successively. If \\axiom{\\spad{p}(\\spad{x},{}\\spad{y})} is \\spad{true},{} then \\spad{x} is inserted into the result; otherwise \\spad{y} is inserted. If \\spad{x} is chosen,{} the next element of \\axiom{a} is examined,{} and so on. When all the elements of one aggregate are examined,{} the remaining elements of the other are appended. For example,{} \\axiom{merge(<,{}[1,{}3],{}[2,{}7,{}5])} returns \\axiom{[1,{}2,{}3,{}7,{}5]}."))) 
@@ -1241,8 +1241,8 @@ NIL
 NIL 
 NIL 
 (|FreeLieAlgebra| |VarSet| R) 
-((|constructor| (NIL "The category of free Lie algebras. It is used by domains of non-commutative algebra: \\spadtype{LiePolynomial} and \\spadtype{XPBWPolynomial}. \\newline Author: Michel Petitot (petitot@lifl.fr)")) (|eval| (($ $ (|List| |#1|) (|List| $)) "\\axiom{eval(\\spad{p},{} [\\spad{x1},{}...,{}xn],{} [\\spad{v1},{}...,{}vn])} replaces \\axiom{\\spad{xi}} by \\axiom{\\spad{vi}} in \\axiom{\\spad{p}}.") (($ $ |#1| $) "\\axiom{eval(\\spad{p},{} \\spad{x},{} \\spad{v})} replaces \\axiom{\\spad{x}} by \\axiom{\\spad{v}} in \\axiom{\\spad{p}}.")) (|varList| (((|List| |#1|) $) "\\axiom{varList(\\spad{x})} returns the list of distinct entries of \\axiom{\\spad{x}}.")) (|trunc| (($ $ (|NonNegativeInteger|)) "\\axiom{trunc(\\spad{p},{}\\spad{n})} returns the polynomial \\axiom{\\spad{p}} truncated at order \\axiom{\\spad{n}}.")) (|mirror| (($ $) "\\axiom{mirror(\\spad{x})} returns \\axiom{Sum(r_i mirror(w_i))} if \\axiom{\\spad{x}} is \\axiom{Sum(r_i w_i)}.")) (|LiePoly| (($ (|LyndonWord| |#1|)) "\\axiom{LiePoly(\\spad{l})} returns the bracketed form of \\axiom{\\spad{l}} as a Lie polynomial.")) (|rquo| (((|XRecursivePolynomial| |#1| |#2|) (|XRecursivePolynomial| |#1| |#2|) $) "\\axiom{rquo(\\spad{x},{}\\spad{y})} returns the right simplification of \\axiom{\\spad{x}} by \\axiom{\\spad{y}}.")) (|lquo| (((|XRecursivePolynomial| |#1| |#2|) (|XRecursivePolynomial| |#1| |#2|) $) "\\axiom{lquo(\\spad{x},{}\\spad{y})} returns the left simplification of \\axiom{\\spad{x}} by \\axiom{\\spad{y}}.")) (|degree| (((|NonNegativeInteger|) $) "\\axiom{degree(\\spad{x})} returns the greatest length of a word in the support of \\axiom{\\spad{x}}.")) (|coerce| (((|XRecursivePolynomial| |#1| |#2|) $) "\\axiom{coerce(\\spad{x})} returns \\axiom{\\spad{x}} as a recursive polynomial.") (((|XDistributedPolynomial| |#1| |#2|) $) "\\axiom{coerce(\\spad{x})} returns \\axiom{\\spad{x}} as distributed polynomial.") (($ |#1|) "\\axiom{coerce(\\spad{x})} returns \\axiom{\\spad{x}} as a Lie polynomial.")) (|coef| ((|#2| (|XRecursivePolynomial| |#1| |#2|) $) "\\axiom{coef(\\spad{x},{}\\spad{y})} returns the scalar product of \\axiom{\\spad{x}} by \\axiom{\\spad{y}},{} the set of words being regarded as an orthogonal basis."))) 
-((|JacobiIdentity| . T) (|NullSquare| . T) (|leftUnitary| . T) (|rightUnitary| . T)) 
+((|constructor| (NIL "The category of free Lie algebras. It is used by domains of non-commutative algebra: \\spadtype{LiePolynomial} and \\spadtype{XPBWPolynomial}. \\newline Author: Michel Petitot (petitot@lifl.fr)")) (|eval| (($ $ (|List| |#1|) (|List| $)) "\\axiom{eval(\\spad{p},{} [\\spad{x1},{}...,{}xn],{} [\\spad{v1},{}...,{}vn])} replaces \\axiom{\\spad{xi}} by \\axiom{\\spad{vi}} in \\axiom{\\spad{p}}.") (($ $ |#1| $) "\\axiom{eval(\\spad{p},{} \\spad{x},{} \\spad{v})} replaces \\axiom{\\spad{x}} by \\axiom{\\spad{v}} in \\axiom{\\spad{p}}.")) (|varList| (((|List| |#1|) $) "\\axiom{varList(\\spad{x})} returns the list of distinct entries of \\axiom{\\spad{x}}.")) (|trunc| (($ $ (|NonNegativeInteger|)) "\\axiom{trunc(\\spad{p},{}\\spad{n})} returns the polynomial \\axiom{\\spad{p}} truncated at order \\axiom{\\spad{n}}.")) (|mirror| (($ $) "\\axiom{mirror(\\spad{x})} returns \\axiom{Sum(r_i mirror(w_i))} if \\axiom{\\spad{x}} is \\axiom{Sum(r_i w_i)}.")) (|LiePoly| (($ (|LyndonWord| |#1|)) "\\axiom{LiePoly(\\spad{l})} returns the bracketed form of \\axiom{\\spad{l}} as a Lie polynomial.")) (|rquo| (((|XRecursivePolynomial| |#1| |#2|) (|XRecursivePolynomial| |#1| |#2|) $) "\\axiom{rquo(\\spad{x},{}\\spad{y})} returns the right simplification of \\axiom{\\spad{x}} by \\axiom{\\spad{y}}.")) (|lquo| (((|XRecursivePolynomial| |#1| |#2|) (|XRecursivePolynomial| |#1| |#2|) $) "\\axiom{lquo(\\spad{x},{}\\spad{y})} returns the left simplification of \\axiom{\\spad{x}} by \\axiom{\\spad{y}}.")) (|degree| (((|NonNegativeInteger|) $) "\\axiom{degree(\\spad{x})} returns the greatest length of a word in the support of \\axiom{\\spad{x}}.")) (|coerce| (($ |#1|) "\\axiom{coerce(\\spad{x})} returns \\axiom{\\spad{x}} as a Lie polynomial.")) (|coef| ((|#2| (|XRecursivePolynomial| |#1| |#2|) $) "\\axiom{coef(\\spad{x},{}\\spad{y})} returns the scalar product of \\axiom{\\spad{x}} by \\axiom{\\spad{y}},{} the set of words being regarded as an orthogonal basis."))) 
+NIL 
 NIL 
 (|FiniteLinearAggregateSort| S V) 
 ((|constructor| (NIL "This package exports 3 sorting algorithms which work over FiniteLinearAggregates.")) (|shellSort| ((|#2| (|Mapping| (|Boolean|) |#1| |#1|) |#2|) "\\spad{shellSort(f, agg)} sorts the aggregate agg with the ordering function \\spad{f} using the shellSort algorithm.")) (|heapSort| ((|#2| (|Mapping| (|Boolean|) |#1| |#1|) |#2|) "\\spad{heapSort(f, agg)} sorts the aggregate agg with the ordering function \\spad{f} using the heapsort algorithm.")) (|quickSort| ((|#2| (|Mapping| (|Boolean|) |#1| |#1|) |#2|) "\\spad{quickSort(f, agg)} sorts the aggregate agg with the ordering function \\spad{f} using the quicksort algorithm."))) 
@@ -1258,7 +1258,7 @@ NIL
 NIL 
 (|Float|) 
 ((|outputSpacing| (((|Void|) (|NonNegativeInteger|)) "\\spad{outputSpacing(n)} inserts a space after \\spad{n} (default 10) digits on output; outputSpacing(0) means no spaces are inserted.")) (|outputGeneral| (((|Void|) (|NonNegativeInteger|)) "\\spad{outputGeneral(n)} sets the output mode to general notation with \\spad{n} significant digits displayed.") (((|Void|)) "\\spad{outputGeneral()} sets the output mode (default mode) to general notation; numbers will be displayed in either fixed or floating (scientific) notation depending on the magnitude.")) (|outputFixed| (((|Void|) (|NonNegativeInteger|)) "\\spad{outputFixed(n)} sets the output mode to fixed point notation,{} with \\spad{n} digits displayed after the decimal point.") (((|Void|)) "\\spad{outputFixed()} sets the output mode to fixed point notation; the output will contain a decimal point.")) (|outputFloating| (((|Void|) (|NonNegativeInteger|)) "\\spad{outputFloating(n)} sets the output mode to floating (scientific) notation with \\spad{n} significant digits displayed after the decimal point.") (((|Void|)) "\\spad{outputFloating()} sets the output mode to floating (scientific) notation,{} \\spadignore{i.e.} \\spad{mantissa * 10 exponent} is displayed as \\spad{0.mantissa E exponent}.")) (|atan| (($ $ $) "\\spad{atan(x,y)} computes the arc tangent from \\spad{x} with phase \\spad{y}.")) (|exp1| (($) "\\spad{exp1()} returns exp 1: \\spad{2.7182818284...}.")) (|log10| (($ $) "\\spad{log10(x)} computes the logarithm for \\spad{x} to base 10.") (($) "\\spad{log10()} returns \\spad{ln 10}: \\spad{2.3025809299...}.")) (|log2| (($ $) "\\spad{log2(x)} computes the logarithm for \\spad{x} to base 2.") (($) "\\spad{log2()} returns \\spad{ln 2},{} \\spadignore{i.e.} \\spad{0.6931471805...}.")) (|rationalApproximation| (((|Fraction| (|Integer|)) $ (|NonNegativeInteger|) (|NonNegativeInteger|)) "\\spad{rationalApproximation(f, n, b)} computes a rational approximation \\spad{r} to \\spad{f} with relative error \\spad{< b**(-n)},{} that is \\spad{|(r-f)/f| < b**(-n)}.") (((|Fraction| (|Integer|)) $ (|NonNegativeInteger|)) "\\spad{rationalApproximation(f, n)} computes a rational approximation \\spad{r} to \\spad{f} with relative error \\spad{< 10**(-n)}.")) (|shift| (($ $ (|Integer|)) "\\spad{shift(x,n)} adds \\spad{n} to the exponent of float \\spad{x}.")) (|relerror| (((|Integer|) $ $) "\\spad{relerror(x,y)} computes the absolute value of \\spad{x - y} divided by \\spad{y},{} when \\spad{y \\~= 0}.")) (|normalize| (($ $) "\\spad{normalize(x)} normalizes \\spad{x} at current precision.")) (** (($ $ $) "\\spad{x ** y} computes \\spad{exp(y log x)} where \\spad{x >= 0}.")) (/ (($ $ (|Integer|)) "\\spad{x / i} computes the division from \\spad{x} by an integer \\spad{i}."))) 
-((|arbitraryExponent| . T) (|arbitraryPrecision| . T) (|approximate| . T) (|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|arbitraryExponent| . T) (|arbitraryPrecision| . T) (|approximate| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|FloatingComplexPackage| |Par|) 
 ((|constructor| (NIL "\\indented{3}{This is a package for the approximation of complex solutions for} systems of equations of rational functions with complex rational coefficients. The results are expressed as either complex rational numbers or complex floats depending on the type of the precision parameter which can be either a rational number or a floating point number.")) (|complexRoots| (((|List| (|List| (|Complex| |#1|))) (|List| (|Fraction| (|Polynomial| (|Complex| (|Integer|))))) (|List| (|Symbol|)) |#1|) "\\spad{complexRoots(lrf, lv, eps)} finds all the complex solutions of a list of rational functions with rational number coefficients with respect the the variables appearing in \\spad{lv}. Each solution is computed to precision eps and returned as list corresponding to the order of variables in \\spad{lv}.") (((|List| (|Complex| |#1|)) (|Fraction| (|Polynomial| (|Complex| (|Integer|)))) |#1|) "\\spad{complexRoots(rf, eps)} finds all the complex solutions of a univariate rational function with rational number coefficients. The solutions are computed to precision eps.")) (|complexSolve| (((|List| (|Equation| (|Polynomial| (|Complex| |#1|)))) (|Equation| (|Fraction| (|Polynomial| (|Complex| (|Integer|))))) |#1|) "\\spad{complexSolve(eq,eps)} finds all the complex solutions of the equation \\spad{eq} of rational functions with rational rational coefficients with respect to all the variables appearing in \\spad{eq},{} with precision \\spad{eps}.") (((|List| (|Equation| (|Polynomial| (|Complex| |#1|)))) (|Fraction| (|Polynomial| (|Complex| (|Integer|)))) |#1|) "\\spad{complexSolve(p,eps)} find all the complex solutions of the rational function \\spad{p} with complex rational coefficients with respect to all the variables appearing in \\spad{p},{} with precision \\spad{eps}.") (((|List| (|List| (|Equation| (|Polynomial| (|Complex| |#1|))))) (|List| (|Equation| (|Fraction| (|Polynomial| (|Complex| (|Integer|)))))) |#1|) "\\spad{complexSolve(leq,eps)} finds all the complex solutions to precision \\spad{eps} of the system \\spad{leq} of equations of rational functions over complex rationals with respect to all the variables appearing in lp.") (((|List| (|List| (|Equation| (|Polynomial| (|Complex| |#1|))))) (|List| (|Fraction| (|Polynomial| (|Complex| (|Integer|))))) |#1|) "\\spad{complexSolve(lp,eps)} finds all the complex solutions to precision \\spad{eps} of the system \\spad{lp} of rational functions over the complex rationals with respect to all the variables appearing in \\spad{lp}."))) 
@@ -1270,15 +1270,19 @@ NIL
 NIL 
 (|FreeModule| R S) 
 ((|constructor| (NIL "A \\spad{bi}-module is a free module over a ring with generators indexed by an ordered set. Each element can be expressed as a finite linear combination of generators. Only non-zero terms are stored."))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (AND (|HasCategory| |#1| #1=(QUOTE (|SetCategory|))) (|HasCategory| |#2| #1#))) 
 (|FreeModule1| R S) 
 ((|constructor| (NIL "This domain implements linear combinations of elements from the domain \\spad{S} with coefficients in the domain \\spad{R} where \\spad{S} is an ordered set and \\spad{R} is a ring (which may be non-commutative). This domain is used by domains of non-commutative algebra such as: \\indented{4}{\\spadtype{XDistributedPolynomial},{}} \\indented{4}{\\spadtype{XRecursivePolynomial}.} Author: Michel Petitot (petitot@lifl.fr)")) (* (($ |#2| |#1|) "\\spad{s*r} returns the product \\spad{r*s} used by \\spadtype{XRecursivePolynomial}"))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|CommutativeRing|)))) 
+(|FreeMagma| |VarSet|) 
+((|constructor| (NIL "This type is the basic representation of parenthesized words (binary trees over arbitrary symbols) useful in \\spadtype{LiePolynomial}. \\newline Author: Michel Petitot (petitot@lifl.fr).")) (|varList| (((|List| |#1|) $) "\\axiom{varList(\\spad{x})} returns the list of distinct entries of \\axiom{\\spad{x}}.")) (|right| (($ $) "\\axiom{right(\\spad{x})} returns right subtree of \\axiom{\\spad{x}} or error if \\axiomOpFrom{retractable?}{FreeMagma}(\\axiom{\\spad{x}}) is \\spad{true}.")) (|retractable?| (((|Boolean|) $) "\\axiom{retractable?(\\spad{x})} tests if \\axiom{\\spad{x}} is a tree with only one entry.")) (|rest| (($ $) "\\axiom{rest(\\spad{x})} return \\axiom{\\spad{x}} without the first entry or error if \\axiomOpFrom{retractable?}{FreeMagma}(\\axiom{\\spad{x}}) is \\spad{true}.")) (|mirror| (($ $) "\\axiom{mirror(\\spad{x})} returns the reversed word of \\axiom{\\spad{x}}. That is \\axiom{\\spad{x}} itself if \\axiomOpFrom{retractable?}{FreeMagma}(\\axiom{\\spad{x}}) is \\spad{true} and \\axiom{mirror(\\spad{z}) * mirror(\\spad{y})} if \\axiom{\\spad{x}} is \\axiom{y*z}.")) (|lexico| (((|Boolean|) $ $) "\\axiom{lexico(\\spad{x},{}\\spad{y})} returns \\axiom{\\spad{true}} iff \\axiom{\\spad{x}} is smaller than \\axiom{\\spad{y}} \\spad{w}.\\spad{r}.\\spad{t}. the lexicographical ordering induced by \\axiom{VarSet}. \\spad{N}.\\spad{B}. This operation does not take into account the tree structure of its arguments. Thus this is not a total ordering.")) (|length| (((|PositiveInteger|) $) "\\axiom{length(\\spad{x})} returns the number of entries in \\axiom{\\spad{x}}.")) (|left| (($ $) "\\axiom{left(\\spad{x})} returns left subtree of \\axiom{\\spad{x}} or error if \\axiomOpFrom{retractable?}{FreeMagma}(\\axiom{\\spad{x}}) is \\spad{true}.")) (|first| ((|#1| $) "\\axiom{first(\\spad{x})} returns the first entry of the tree \\axiom{\\spad{x}}.")) (* (($ $ $) "\\axiom{x*y} returns the tree \\axiom{[\\spad{x},{}\\spad{y}]}."))) 
+NIL 
+NIL 
 (|FreeModuleCat| R |Basis|) 
 ((|constructor| (NIL "A domain of this category implements formal linear combinations of elements from a domain \\spad{Basis} with coefficients in a domain \\spad{R}. The domain \\spad{Basis} needs only to belong to the category \\spadtype{SetCategory} and \\spad{R} to the category \\spadtype{Ring}. Thus the coefficient ring may be non-commutative. See the \\spadtype{XDistributedPolynomial} constructor for examples of domains built with the \\spadtype{FreeModuleCat} category constructor. Author: Michel Petitot (petitot@lifl.fr)")) (|reductum| (($ $) "\\spad{reductum(x)} returns \\spad{x} minus its leading term.")) (|leadingTerm| (((|Record| (|:| |k| |#2|) (|:| |c| |#1|)) $) "\\spad{leadingTerm(x)} returns the first term which appears in \\spad{ListOfTerms(x)}.")) (|leadingCoefficient| ((|#1| $) "\\spad{leadingCoefficient(x)} returns the first coefficient which appears in \\spad{ListOfTerms(x)}.")) (|leadingMonomial| ((|#2| $) "\\spad{leadingMonomial(x)} returns the first element from \\spad{Basis} which appears in \\spad{ListOfTerms(x)}.")) (|numberOfMonomials| (((|NonNegativeInteger|) $) "\\spad{numberOfMonomials(x)} returns the number of monomials of \\spad{x}.")) (|monomials| (((|List| $) $) "\\spad{monomials(x)} returns the list of \\spad{r_i*b_i} whose sum is \\spad{x}.")) (|coefficients| (((|List| |#1|) $) "\\spad{coefficients(x)} returns the list of coefficients of \\spad{x}.")) (|ListOfTerms| (((|List| (|Record| (|:| |k| |#2|) (|:| |c| |#1|))) $) "\\spad{ListOfTerms(x)} returns a list \\spad{lt} of terms with type \\spad{Record(k: Basis, c: R)} such that \\spad{x} equals \\spad{reduce(+, map(x +-> monom(x.k, x.c), lt))}.")) (|monomial?| (((|Boolean|) $) "\\spad{monomial?(x)} returns \\spad{true} if \\spad{x} contains a single monomial.")) (|monom| (($ |#2| |#1|) "\\spad{monom(b,r)} returns the element with the single monomial \\indented{1}{\\spad{b} and coefficient \\spad{r}.}")) (|coefficient| ((|#1| $ |#2|) "\\spad{coefficient(x,b)} returns the coefficient of \\spad{b} in \\spad{x}.")) (* (($ |#1| |#2|) "\\spad{r*b} returns the product of \\spad{r} by \\spad{b}."))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 NIL 
 (|FreeMonoidCategory| S) 
 ((|constructor| (NIL "A free monoid on a set \\spad{S} is the monoid of finite products of the form \\spad{reduce(*,[si ** ni])} where the \\spad{si}'s are in \\spad{S},{} and the \\spad{ni}'s are nonnegative integers. The multiplication is not commutative.")) (|mapGen| (($ (|Mapping| |#1| |#1|) $) "\\spad{mapGen(f, a1\\^e1 ... an\\^en)} returns \\spad{f(a1)\\^e1 ... f(an)\\^en}.")) (|mapExpon| (($ (|Mapping| (|NonNegativeInteger|) (|NonNegativeInteger|)) $) "\\spad{mapExpon(f, a1\\^e1 ... an\\^en)} returns \\spad{a1\\^f(e1) ... an\\^f(en)}.")) (|nthFactor| ((|#1| $ (|Integer|)) "\\spad{nthFactor(x, n)} returns the factor of the n^th monomial of \\spad{x}.")) (|nthExpon| (((|NonNegativeInteger|) $ (|Integer|)) "\\spad{nthExpon(x, n)} returns the exponent of the n^th monomial of \\spad{x}.")) (|factors| (((|List| (|Record| (|:| |gen| |#1|) (|:| |exp| (|NonNegativeInteger|)))) $) "\\spad{factors(a1\\^e1,...,an\\^en)} returns \\spad{[[a1, e1],...,[an, en]]}.")) (|size| (((|NonNegativeInteger|) $) "\\spad{size(x)} returns the number of monomials in \\spad{x}.")) (|overlap| (((|Record| (|:| |lm| $) (|:| |mm| $) (|:| |rm| $)) $ $) "\\spad{overlap(x, y)} returns \\spad{[l, m, r]} such that \\spad{x = l * m},{} \\spad{y = m * r} and \\spad{l} and \\spad{r} have no overlap,{} \\spadignore{i.e.} \\spad{overlap(l, r) = [l, 1, r]}.")) (|divide| (((|Union| (|Record| (|:| |lm| $) (|:| |rm| $)) "failed") $ $) "\\spad{divide(x, y)} returns the left and right exact quotients of \\spad{x} by \\spad{y},{} \\spadignore{i.e.} \\spad{[l, r]} such that \\spad{x = l * y * r},{} \"failed\" if \\spad{x} is not of the form \\spad{l * y * r}.")) (|rquo| (((|Union| $ "failed") $ $) "\\spad{rquo(x, y)} returns the exact right quotient of \\spad{x} by \\spad{y} \\spadignore{i.e.} \\spad{q} such that \\spad{x = q * y},{} \"failed\" if \\spad{x} is not of the form \\spad{q * y}.")) (|lquo| (((|Union| $ "failed") $ $) "\\spad{lquo(x, y)} returns the exact left quotient of \\spad{x} by \\spad{y} \\spadignore{i.e.} \\spad{q} such that \\spad{x = y * q},{} \"failed\" if \\spad{x} is not of the form \\spad{y * q}.")) (|hcrf| (($ $ $) "\\spad{hcrf(x, y)} returns the highest common right factor of \\spad{x} and \\spad{y},{} \\spadignore{i.e.} the largest \\spad{d} such that \\spad{x = a d} and \\spad{y = b d}.")) (|hclf| (($ $ $) "\\spad{hclf(x, y)} returns the highest common left factor of \\spad{x} and \\spad{y},{} \\spadignore{i.e.} the largest \\spad{d} such that \\spad{x = d a} and \\spad{y = d b}.")) (** (($ |#1| (|NonNegativeInteger|)) "\\spad{s ** n} returns the product of \\spad{s} by itself \\spad{n} times.")) (* (($ $ |#1|) "\\spad{x * s} returns the product of \\spad{x} by \\spad{s} on the right.") (($ |#1| $) "\\spad{s * x} returns the product of \\spad{x} by \\spad{s} on the left."))) 
@@ -1298,7 +1302,7 @@ NIL
 NIL 
 (|FreeNilpotentLie| |n| |class| R) 
 ((|constructor| (NIL "Generate the Free Lie Algebra over a ring \\spad{R} with identity; A \\spad{P}. Hall basis is generated by a package call to HallBasis.")) (|generator| (($ (|NonNegativeInteger|)) "\\spad{generator(i)} is the \\spad{i}th Hall Basis element")) (|shallowExpand| (((|OutputForm|) $) "\\spad{shallowExpand(x)} \\undocumented{}")) (|deepExpand| (((|OutputForm|) $) "\\spad{deepExpand(x)} \\undocumented{}")) (|dimension| (((|NonNegativeInteger|)) "\\spad{dimension()} is the rank of this Lie algebra"))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 NIL 
 (|FindOrderFinite| F UP UPUP R) 
 ((|constructor| (NIL "\\indented{1}{Finds the order of a divisor over a finite field} Author: Manuel Bronstein Date Created: 1988 Date Last Updated: 11 Jul 1990")) (|order| (((|NonNegativeInteger|) (|FiniteDivisor| |#1| |#2| |#3| |#4|)) "\\spad{order(x)} \\undocumented"))) 
@@ -1318,7 +1322,7 @@ NIL
 NIL 
 (|FieldOfPrimeCharacteristic|) 
 ((|constructor| (NIL "FieldOfPrimeCharacteristic is the category of fields of prime characteristic,{} \\spadignore{e.g.} finite fields,{} algebraic closures of fields of prime characteristic,{} transcendental extensions of of fields of prime characteristic.")) (|primeFrobenius| (($ $ (|NonNegativeInteger|)) "\\spad{primeFrobenius(a,s)} returns \\spad{a**(p**s)} where \\spad{p} is the characteristic.") (($ $) "\\spad{primeFrobenius(a)} returns \\spad{a ** p} where \\spad{p} is the characteristic.")) (|discreteLog| (((|Union| (|NonNegativeInteger|) "failed") $ $) "\\spad{discreteLog(b,a)} computes \\spad{s} with \\spad{b**s = a} if such an \\spad{s} exists.")) (|order| (((|OnePointCompletion| (|PositiveInteger|)) $) "\\spad{order(a)} computes the order of an element in the multiplicative group of the field. Error: if \\spad{a} is 0."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|FloatingPointSystem&| S) 
 ((|constructor| (NIL "This category is intended as a model for floating point systems. A floating point system is a model for the real numbers. In fact,{} it is an approximation in the sense that not all real numbers are exactly representable by floating point numbers. A floating point system is characterized by the following: \\blankline \\indented{2}{1: \\spadfunFrom{base}{FloatingPointSystem} of the \\spadfunFrom{exponent}{FloatingPointSystem}.} \\indented{9}{(actual implemenations are usually binary or decimal)} \\indented{2}{2: \\spadfunFrom{precision}{FloatingPointSystem} of the \\spadfunFrom{mantissa}{FloatingPointSystem} (arbitrary or fixed)} \\indented{2}{3: rounding error for operations} \\blankline Because a Float is an approximation to the real numbers,{} even though it is defined to be a join of a Field and OrderedRing,{} some of the attributes do not hold. In particular associative(\"+\") does not hold. Algorithms defined over a field need special considerations when the field is a floating point system.")) (|max| (($) "\\spad{max()} returns the maximum floating point number.")) (|min| (($) "\\spad{min()} returns the minimum floating point number.")) (|decreasePrecision| (((|PositiveInteger|) (|Integer|)) "\\spad{decreasePrecision(n)} decreases the current \\spadfunFrom{precision}{FloatingPointSystem} precision by \\spad{n} decimal digits.")) (|increasePrecision| (((|PositiveInteger|) (|Integer|)) "\\spad{increasePrecision(n)} increases the current \\spadfunFrom{precision}{FloatingPointSystem} by \\spad{n} decimal digits.")) (|precision| (((|PositiveInteger|) (|PositiveInteger|)) "\\spad{precision(n)} set the precision in the base to \\spad{n} decimal digits.") (((|PositiveInteger|)) "\\spad{precision()} returns the precision in digits base.")) (|digits| (((|PositiveInteger|) (|PositiveInteger|)) "\\spad{digits(d)} set the \\spadfunFrom{precision}{FloatingPointSystem} to \\spad{d} digits.") (((|PositiveInteger|)) "\\spad{digits()} returns ceiling's precision in decimal digits.")) (|bits| (((|PositiveInteger|) (|PositiveInteger|)) "\\spad{bits(n)} set the \\spadfunFrom{precision}{FloatingPointSystem} to \\spad{n} bits.") (((|PositiveInteger|)) "\\spad{bits()} returns ceiling's precision in bits.")) (|mantissa| (((|Integer|) $) "\\spad{mantissa(x)} returns the mantissa part of \\spad{x}.")) (|exponent| (((|Integer|) $) "\\spad{exponent(x)} returns the \\spadfunFrom{exponent}{FloatingPointSystem} part of \\spad{x}.")) (|base| (((|PositiveInteger|)) "\\spad{base()} returns the base of the \\spadfunFrom{exponent}{FloatingPointSystem}.")) (|order| (((|Integer|) $) "\\spad{order x} is the order of magnitude of \\spad{x}. Note: \\spad{base ** order x <= |x| < base ** (1 + order x)}.")) (|float| (($ (|Integer|) (|Integer|) (|PositiveInteger|)) "\\spad{float(a,e,b)} returns \\spad{a * b ** e}.") (($ (|Integer|) (|Integer|)) "\\spad{float(a,e)} returns \\spad{a * base() ** e}.")) (|approximate| ((|attribute|) "\\spad{approximate} means \"is an approximation to the real numbers\"."))) 
@@ -1326,20 +1330,20 @@ NIL
 ((|HasAttribute| |#1| (QUOTE |arbitraryExponent|)) (|HasAttribute| |#1| (QUOTE |arbitraryPrecision|))) 
 (|FloatingPointSystem|) 
 ((|constructor| (NIL "This category is intended as a model for floating point systems. A floating point system is a model for the real numbers. In fact,{} it is an approximation in the sense that not all real numbers are exactly representable by floating point numbers. A floating point system is characterized by the following: \\blankline \\indented{2}{1: \\spadfunFrom{base}{FloatingPointSystem} of the \\spadfunFrom{exponent}{FloatingPointSystem}.} \\indented{9}{(actual implemenations are usually binary or decimal)} \\indented{2}{2: \\spadfunFrom{precision}{FloatingPointSystem} of the \\spadfunFrom{mantissa}{FloatingPointSystem} (arbitrary or fixed)} \\indented{2}{3: rounding error for operations} \\blankline Because a Float is an approximation to the real numbers,{} even though it is defined to be a join of a Field and OrderedRing,{} some of the attributes do not hold. In particular associative(\"+\") does not hold. Algorithms defined over a field need special considerations when the field is a floating point system.")) (|max| (($) "\\spad{max()} returns the maximum floating point number.")) (|min| (($) "\\spad{min()} returns the minimum floating point number.")) (|decreasePrecision| (((|PositiveInteger|) (|Integer|)) "\\spad{decreasePrecision(n)} decreases the current \\spadfunFrom{precision}{FloatingPointSystem} precision by \\spad{n} decimal digits.")) (|increasePrecision| (((|PositiveInteger|) (|Integer|)) "\\spad{increasePrecision(n)} increases the current \\spadfunFrom{precision}{FloatingPointSystem} by \\spad{n} decimal digits.")) (|precision| (((|PositiveInteger|) (|PositiveInteger|)) "\\spad{precision(n)} set the precision in the base to \\spad{n} decimal digits.") (((|PositiveInteger|)) "\\spad{precision()} returns the precision in digits base.")) (|digits| (((|PositiveInteger|) (|PositiveInteger|)) "\\spad{digits(d)} set the \\spadfunFrom{precision}{FloatingPointSystem} to \\spad{d} digits.") (((|PositiveInteger|)) "\\spad{digits()} returns ceiling's precision in decimal digits.")) (|bits| (((|PositiveInteger|) (|PositiveInteger|)) "\\spad{bits(n)} set the \\spadfunFrom{precision}{FloatingPointSystem} to \\spad{n} bits.") (((|PositiveInteger|)) "\\spad{bits()} returns ceiling's precision in bits.")) (|mantissa| (((|Integer|) $) "\\spad{mantissa(x)} returns the mantissa part of \\spad{x}.")) (|exponent| (((|Integer|) $) "\\spad{exponent(x)} returns the \\spadfunFrom{exponent}{FloatingPointSystem} part of \\spad{x}.")) (|base| (((|PositiveInteger|)) "\\spad{base()} returns the base of the \\spadfunFrom{exponent}{FloatingPointSystem}.")) (|order| (((|Integer|) $) "\\spad{order x} is the order of magnitude of \\spad{x}. Note: \\spad{base ** order x <= |x| < base ** (1 + order x)}.")) (|float| (($ (|Integer|) (|Integer|) (|PositiveInteger|)) "\\spad{float(a,e,b)} returns \\spad{a * b ** e}.") (($ (|Integer|) (|Integer|)) "\\spad{float(a,e)} returns \\spad{a * base() ** e}.")) (|approximate| ((|attribute|) "\\spad{approximate} means \"is an approximation to the real numbers\"."))) 
-((|approximate| . T) (|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|approximate| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|Factored| R) 
 ((|constructor| (NIL "\\spadtype{Factored} creates a domain whose objects are kept in factored form as long as possible. Thus certain operations like multiplication and gcd are relatively easy to do. Others,{} like addition require somewhat more work,{} and unless the argument domain provides a factor function,{} the result may not be completely factored. Each object consists of a unit and a list of factors,{} where a factor has a member of \\spad{R} (the \"base\"),{} and exponent and a flag indicating what is known about the base. A flag may be one of \"nil\",{} \"sqfr\",{} \"irred\" or \"prime\",{} which respectively mean that nothing is known about the base,{} it is square-free,{} it is irreducible,{} or it is prime. The current restriction to integral domains allows simplification to be performed without worrying about multiplication order.")) (|rationalIfCan| (((|Union| (|Fraction| (|Integer|)) "failed") $) "\\spad{rationalIfCan(u)} returns a rational number if \\spad{u} really is one,{} and \"failed\" otherwise.")) (|rational| (((|Fraction| (|Integer|)) $) "\\spad{rational(u)} assumes spadvar{\\spad{u}} is actually a rational number and does the conversion to rational number (see \\spadtype{Fraction Integer}).")) (|rational?| (((|Boolean|) $) "\\spad{rational?(u)} tests if \\spadvar{\\spad{u}} is actually a rational number (see \\spadtype{Fraction Integer}).")) (|unitNormalize| (($ $) "\\spad{unitNormalize(u)} normalizes the unit part of the factorization. For example,{} when working with factored integers,{} this operation will ensure that the bases are all positive integers.")) (|unit| ((|#1| $) "\\spad{unit(u)} extracts the unit part of the factorization.")) (|flagFactor| (($ |#1| (|Integer|) (|Union| #1="nil" #2="sqfr" #3="irred" #4="prime")) "\\spad{flagFactor(base,exponent,flag)} creates a factored object with a single factor whose \\spad{base} is asserted to be properly described by the information \\spad{flag}.")) (|sqfrFactor| (($ |#1| (|Integer|)) "\\spad{sqfrFactor(base,exponent)} creates a factored object with a single factor whose \\spad{base} is asserted to be square-free (flag = \"sqfr\").")) (|primeFactor| (($ |#1| (|Integer|)) "\\spad{primeFactor(base,exponent)} creates a factored object with a single factor whose \\spad{base} is asserted to be prime (flag = \"prime\").")) (|numberOfFactors| (((|NonNegativeInteger|) $) "\\spad{numberOfFactors(u)} returns the number of factors in \\spadvar{\\spad{u}}.")) (|nthFlag| (((|Union| #1# #2# #3# #4#) $ (|Integer|)) "\\spad{nthFlag(u,n)} returns the information flag of the \\spad{n}th factor of \\spadvar{\\spad{u}}. If \\spadvar{\\spad{n}} is not a valid index for a factor (for example,{} less than 1 or too big),{} \"nil\" is returned.")) (|nthFactor| ((|#1| $ (|Integer|)) "\\spad{nthFactor(u,n)} returns the base of the \\spad{n}th factor of \\spadvar{\\spad{u}}. If \\spadvar{\\spad{n}} is not a valid index for a factor (for example,{} less than 1 or too big),{} 1 is returned. If \\spadvar{\\spad{u}} consists only of a unit,{} the unit is returned.")) (|nthExponent| (((|Integer|) $ (|Integer|)) "\\spad{nthExponent(u,n)} returns the exponent of the \\spad{n}th factor of \\spadvar{\\spad{u}}. If \\spadvar{\\spad{n}} is not a valid index for a factor (for example,{} less than 1 or too big),{} 0 is returned.")) (|irreducibleFactor| (($ |#1| (|Integer|)) "\\spad{irreducibleFactor(base,exponent)} creates a factored object with a single factor whose \\spad{base} is asserted to be irreducible (flag = \"irred\").")) (|factors| (((|List| (|Record| (|:| |factor| |#1|) (|:| |exponent| (|Integer|)))) $) "\\spad{factors(u)} returns a list of the factors in a form suitable for iteration. That is,{} it returns a list where each element is a record containing a base and exponent. The original object is the product of all the factors and the unit (which can be extracted by \\axiom{unit(\\spad{u})}).")) (|nilFactor| (($ |#1| (|Integer|)) "\\spad{nilFactor(base,exponent)} creates a factored object with a single factor with no information about the kind of \\spad{base} (flag = \"nil\").")) (|factorList| (((|List| (|Record| (|:| |flg| (|Union| #1# #2# #3# #4#)) (|:| |fctr| |#1|) (|:| |xpnt| (|Integer|)))) $) "\\spad{factorList(u)} returns the list of factors with flags (for use by factoring code).")) (|makeFR| (($ |#1| (|List| (|Record| (|:| |flg| (|Union| #1# #2# #3# #4#)) (|:| |fctr| |#1|) (|:| |xpnt| (|Integer|))))) "\\spad{makeFR(unit,listOfFactors)} creates a factored object (for use by factoring code).")) (|exponent| (((|Integer|) $) "\\spad{exponent(u)} returns the exponent of the first factor of \\spadvar{\\spad{u}},{} or 0 if the factored form consists solely of a unit.")) (|expand| ((|#1| $) "\\spad{expand(f)} multiplies the unit and factors together,{} yielding an \"unfactored\" object. Note: this is purposely not called \\spadfun{coerce} which would cause the interpreter to do this automatically."))) 
-((|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-((|HasCategory| |#1| (QUOTE (|InnerEvalable| #1=(|Symbol|) $))) (|HasCategory| |#1| (QUOTE (|Evalable| $))) (|HasCategory| |#1| (QUOTE (|Eltable| $ $))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|)))) #2=(|HasCategory| |#1| (QUOTE (|UniqueFactorizationDomain|))) (OR #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #2#) (|HasCategory| |#1| (QUOTE (|RealConstant|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #4=(|Integer|))))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #4#))) (|HasCategory| |#1| (|%list| (QUOTE |InnerEvalable|) (QUOTE #1#) #5=(|devaluate| |#1|))) (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) #5#)) (|HasCategory| |#1| (|%list| (QUOTE |Eltable|) #5# #5#)) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #1#))) (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #1#))) (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|))) #3#) 
+((|noZeroDivisors| . T) ((|commutative| "*") . T)) 
+((|HasCategory| |#1| (QUOTE (|InnerEvalable| #1=(|Symbol|) $))) (|HasCategory| |#1| (QUOTE (|Evalable| $))) (|HasCategory| |#1| (QUOTE (|Eltable| $ $))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|)))) #2=(|HasCategory| |#1| (QUOTE (|UniqueFactorizationDomain|))) (OR #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #2#) (|HasCategory| |#1| (QUOTE (|RealConstant|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #4=(|Integer|))))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #4#))) (|HasCategory| |#1| (|%list| (QUOTE |InnerEvalable|) (QUOTE #1#) #5=(|devaluate| |#1|))) (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) #5#)) (|HasCategory| |#1| (|%list| (QUOTE |Eltable|) #5# #5#)) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #1#))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #1#))) (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|))) #3#) 
 (|FactoredFunctions2| R S) 
 ((|constructor| (NIL "\\spadtype{FactoredFunctions2} contains functions that involve factored objects whose underlying domains may not be the same. For example,{} \\spadfun{map} might be used to coerce an object of type \\spadtype{Factored(Integer)} to \\spadtype{Factored(Complex(Integer))}.")) (|map| (((|Factored| |#2|) (|Mapping| |#2| |#1|) (|Factored| |#1|)) "\\spad{map(fn,u)} is used to apply the function \\userfun{\\spad{fn}} to every factor of \\spadvar{\\spad{u}}. The new factored object will have all its information flags set to \"nil\". This function is used,{} for example,{} to coerce every factor base to another type."))) 
 NIL 
 NIL 
 (|Fraction| S) 
 ((|constructor| (NIL "Fraction takes an IntegralDomain \\spad{S} and produces the domain of Fractions with numerators and denominators from \\spad{S}. If \\spad{S} is also a GcdDomain,{} then gcd's between numerator and denominator will be cancelled during all operations.")) (|canonical| ((|attribute|) "\\spad{canonical} means that equal elements are in fact identical."))) 
-((|canonical| AND (|has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|has| |#1| (|GcdDomain|)) (|has| |#1| (ATTRIBUTE |canonical|))) (|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #2=(|Symbol|)))) #3=(|HasCategory| |#1| #4=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#1| (QUOTE (|RealConstant|))) #5=(|HasCategory| |#1| (QUOTE (|OrderedIntegralDomain|))) #6=(|HasCategory| |#1| (QUOTE (|OrderedSet|))) (OR #5# #6#) (|HasCategory| |#1| (QUOTE (|RetractableTo| #7=(|Integer|)))) (|HasCategory| |#1| (QUOTE (|StepThrough|))) (|HasCategory| |#1| (QUOTE (|PatternMatchable| #8=(|Float|)))) (|HasCategory| |#1| (QUOTE (|PatternMatchable| #7#))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|Pattern| #7#)))) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #7#))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #2#))) (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #2#))) (|HasCategory| |#1| (|%list| (QUOTE |InnerEvalable|) (QUOTE #2#) #9=(|devaluate| |#1|))) (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) #9#)) (|HasCategory| |#1| (|%list| (QUOTE |Eltable|) #9# #9#)) (|HasCategory| |#1| (QUOTE (|EuclideanDomain|))) (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|))) (AND (|HasAttribute| |#1| (QUOTE |canonical|)) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) (|HasCategory| |#1| (QUOTE (|GcdDomain|)))) #10=(AND #1# (|HasCategory| $ #4#)) (OR #10# #3#)) 
+((|canonical| AND (|has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|has| |#1| (|GcdDomain|)) (|has| |#1| (ATTRIBUTE |canonical|))) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
+(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #2=(|Symbol|)))) #3=(|HasCategory| |#1| #4=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#1| (QUOTE (|RealConstant|))) #5=(|HasCategory| |#1| (QUOTE (|OrderedIntegralDomain|))) #6=(|HasCategory| |#1| (QUOTE (|OrderedSet|))) (OR #5# #6#) (|HasCategory| |#1| (QUOTE (|RetractableTo| #7=(|Integer|)))) (|HasCategory| |#1| (QUOTE (|StepThrough|))) (|HasCategory| |#1| (QUOTE (|PatternMatchable| #8=(|Float|)))) (|HasCategory| |#1| (QUOTE (|PatternMatchable| #7#))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|Pattern| #7#)))) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #7#))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #2#))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #2#))) (|HasCategory| |#1| (|%list| (QUOTE |InnerEvalable|) (QUOTE #2#) #9=(|devaluate| |#1|))) (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) #9#)) (|HasCategory| |#1| (|%list| (QUOTE |Eltable|) #9# #9#)) (|HasCategory| |#1| (QUOTE (|EuclideanDomain|))) (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|))) (AND (|HasAttribute| |#1| (QUOTE |canonical|)) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) (|HasCategory| |#1| (QUOTE (|GcdDomain|)))) #10=(AND #1# (|HasCategory| $ #4#)) (OR #10# #3#)) 
 (|FractionFunctions2| A B) 
 ((|constructor| (NIL "This package extends a map between integral domains to a map between Fractions over those domains by applying the map to the numerators and denominators.")) (|map| (((|Fraction| |#2|) (|Mapping| |#2| |#1|) (|Fraction| |#1|)) "\\spad{map(func,frac)} applies the function \\spad{func} to the numerator and denominator of the fraction \\spad{frac}."))) 
 NIL 
@@ -1350,7 +1354,7 @@ NIL
 NIL 
 (|FramedAlgebra| R UP) 
 ((|constructor| (NIL "A \\spadtype{FramedAlgebra} is a \\spadtype{FiniteRankAlgebra} together with a fixed \\spad{R}-module basis.")) (|regularRepresentation| (((|Matrix| |#1|) $) "\\spad{regularRepresentation(a)} returns the matrix of the linear map defined by left multiplication by \\spad{a} with respect to the fixed basis.")) (|discriminant| ((|#1|) "\\spad{discriminant()} = determinant(traceMatrix()).")) (|traceMatrix| (((|Matrix| |#1|)) "\\spad{traceMatrix()} is the \\spad{n}-by-\\spad{n} matrix ( \\spad{Tr(vi * vj)} ),{} where \\spad{v1},{} ...,{} vn are the elements of the fixed basis.")) (|convert| (($ (|Vector| |#1|)) "\\spad{convert([a1,..,an])} returns \\spad{a1*v1 + ... + an*vn},{} where \\spad{v1},{} ...,{} vn are the elements of the fixed basis.") (((|Vector| |#1|) $) "\\spad{convert(a)} returns the coordinates of \\spad{a} with respect to the fixed \\spad{R}-module basis.")) (|represents| (($ (|Vector| |#1|)) "\\spad{represents([a1,..,an])} returns \\spad{a1*v1 + ... + an*vn},{} where \\spad{v1},{} ...,{} vn are the elements of the fixed basis.")) (|coordinates| (((|Matrix| |#1|) (|Vector| $)) "\\spad{coordinates([v1,...,vm])} returns the coordinates of the \\spad{vi}'s with to the fixed basis. The coordinates of \\spad{vi} are contained in the \\spad{i}th row of the matrix returned by this function.") (((|Vector| |#1|) $) "\\spad{coordinates(a)} returns the coordinates of \\spad{a} with respect to the fixed \\spad{R}-module basis.")) (|basis| (((|Vector| $)) "\\spad{basis()} returns the fixed \\spad{R}-module basis."))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 NIL 
 (|FullyRetractableTo&| A S) 
 ((|constructor| (NIL "\\indented{2}{A is fully retractable to \\spad{B} means that A is retractable to \\spad{B},{} and,{}} \\indented{2}{in addition,{} if \\spad{B} is retractable to the integers or rational} \\indented{2}{numbers then so is A.} \\indented{2}{In particular,{} what we are asserting is that there are no integers} \\indented{2}{(rationals) in A which don't retract into \\spad{B}.} Date Created: March 1990 Date Last Updated: 9 April 1991"))) 
@@ -1362,7 +1366,7 @@ NIL
 NIL 
 (|FractionalIdeal| R F UP A) 
 ((|constructor| (NIL "Fractional ideals in a framed algebra.")) (|randomLC| ((|#4| (|NonNegativeInteger|) (|Vector| |#4|)) "\\spad{randomLC(n,x)} should be local but conditional.")) (|minimize| (($ $) "\\spad{minimize(I)} returns a reduced set of generators for \\spad{I}.")) (|denom| ((|#1| $) "\\spad{denom(1/d * (f1,...,fn))} returns \\spad{d}.")) (|numer| (((|Vector| |#4|) $) "\\spad{numer(1/d * (f1,...,fn))} = the vector \\spad{[f1,...,fn]}.")) (|norm| ((|#2| $) "\\spad{norm(I)} returns the norm of the ideal \\spad{I}.")) (|basis| (((|Vector| |#4|) $) "\\spad{basis((f1,...,fn))} returns the vector \\spad{[f1,...,fn]}.")) (|ideal| (($ (|Vector| |#4|)) "\\spad{ideal([f1,...,fn])} returns the ideal \\spad{(f1,...,fn)}."))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|FractionalIdealFunctions2| R1 F1 U1 A1 R2 F2 U2 A2) 
 ((|constructor| (NIL "\\indented{1}{Lifting of morphisms to fractional ideals.} Author: Manuel Bronstein Date Created: 1 Feb 1989 Date Last Updated: 27 Feb 1990 Keywords: ideal,{} algebra,{} module.")) (|map| (((|FractionalIdeal| |#5| |#6| |#7| |#8|) (|Mapping| |#5| |#1|) (|FractionalIdeal| |#1| |#2| |#3| |#4|)) "\\spad{map(f,i)} \\undocumented{}"))) 
@@ -1382,7 +1386,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|Field|)))) 
 (|FramedNonAssociativeAlgebra| R) 
 ((|constructor| (NIL "FramedNonAssociativeAlgebra(\\spad{R}) is a \\spadtype{FiniteRankNonAssociativeAlgebra} (\\spadignore{i.e.} a non associative algebra over \\spad{R} which is a free \\spad{R}-module of finite rank) over a commutative ring \\spad{R} together with a fixed \\spad{R}-module basis.")) (|apply| (($ (|Matrix| |#1|) $) "\\spad{apply(m,a)} defines a left operation of \\spad{n} by \\spad{n} matrices where \\spad{n} is the rank of the algebra in terms of matrix-vector multiplication,{} this is a substitute for a left module structure. Error: if shape of matrix doesn't fit.")) (|rightRankPolynomial| (((|SparseUnivariatePolynomial| (|Polynomial| |#1|))) "\\spad{rightRankPolynomial()} calculates the right minimal polynomial of the generic element in the algebra,{} defined by the same structural constants over the polynomial ring in symbolic coefficients with respect to the fixed basis.")) (|leftRankPolynomial| (((|SparseUnivariatePolynomial| (|Polynomial| |#1|))) "\\spad{leftRankPolynomial()} calculates the left minimal polynomial of the generic element in the algebra,{} defined by the same structural constants over the polynomial ring in symbolic coefficients with respect to the fixed basis.")) (|rightRegularRepresentation| (((|Matrix| |#1|) $) "\\spad{rightRegularRepresentation(a)} returns the matrix of the linear map defined by right multiplication by \\spad{a} with respect to the fixed \\spad{R}-module basis.")) (|leftRegularRepresentation| (((|Matrix| |#1|) $) "\\spad{leftRegularRepresentation(a)} returns the matrix of the linear map defined by left multiplication by \\spad{a} with respect to the fixed \\spad{R}-module basis.")) (|rightTraceMatrix| (((|Matrix| |#1|)) "\\spad{rightTraceMatrix()} is the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the right trace of the product \\spad{vi*vj},{} where \\spad{v1},{}...,{}\\spad{vn} are the elements of the fixed \\spad{R}-module basis.")) (|leftTraceMatrix| (((|Matrix| |#1|)) "\\spad{leftTraceMatrix()} is the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by left trace of the product \\spad{vi*vj},{} where \\spad{v1},{}...,{}\\spad{vn} are the elements of the fixed \\spad{R}-module basis.")) (|rightDiscriminant| ((|#1|) "\\spad{rightDiscriminant()} returns the determinant of the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the right trace of the product \\spad{vi*vj},{} where \\spad{v1},{}...,{}\\spad{vn} are the elements of the fixed \\spad{R}-module basis. Note: the same as \\spad{determinant(rightTraceMatrix())}.")) (|leftDiscriminant| ((|#1|) "\\spad{leftDiscriminant()} returns the determinant of the \\spad{n}-by-\\spad{n} matrix whose element at the \\spad{i}\\spad{-}th row and \\spad{j}\\spad{-}th column is given by the left trace of the product \\spad{vi*vj},{} where \\spad{v1},{}...,{}\\spad{vn} are the elements of the fixed \\spad{R}-module basis. Note: the same as \\spad{determinant(leftTraceMatrix())}.")) (|convert| (($ (|Vector| |#1|)) "\\spad{convert([a1,...,an])} returns \\spad{a1*v1 + ... + an*vn},{} where \\spad{v1},{} ...,{} \\spad{vn} are the elements of the fixed \\spad{R}-module basis.") (((|Vector| |#1|) $) "\\spad{convert(a)} returns the coordinates of \\spad{a} with respect to the fixed \\spad{R}-module basis.")) (|represents| (($ (|Vector| |#1|)) "\\spad{represents([a1,...,an])} returns \\spad{a1*v1 + ... + an*vn},{} where \\spad{v1},{} ...,{} \\spad{vn} are the elements of the fixed \\spad{R}-module basis.")) (|conditionsForIdempotents| (((|List| (|Polynomial| |#1|))) "\\spad{conditionsForIdempotents()} determines a complete list of polynomial equations for the coefficients of idempotents with respect to the fixed \\spad{R}-module basis.")) (|structuralConstants| (((|Vector| (|Matrix| |#1|))) "\\spad{structuralConstants()} calculates the structural constants \\spad{[(gammaijk) for k in 1..rank()]} defined by \\spad{vi * vj = gammaij1 * v1 + ... + gammaijn * vn},{} where \\spad{v1},{}...,{}\\spad{vn} is the fixed \\spad{R}-module basis.")) (|coordinates| (((|Matrix| |#1|) (|Vector| $)) "\\spad{coordinates([a1,...,am])} returns a matrix whose \\spad{i}-th row is formed by the coordinates of \\spad{ai} with respect to the fixed \\spad{R}-module basis.") (((|Vector| |#1|) $) "\\spad{coordinates(a)} returns the coordinates of \\spad{a} with respect to the fixed \\spad{R}-module basis.")) (|basis| (((|Vector| $)) "\\spad{basis()} returns the fixed \\spad{R}-module basis."))) 
-((|unitsKnown| |has| |#1| (|IntegralDomain|)) (|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 NIL 
 (|FactoredFunctionUtilities| R) 
 ((|constructor| (NIL "\\spadtype{FactoredFunctionUtilities} implements some utility functions for manipulating factored objects.")) (|mergeFactors| (((|Factored| |#1|) (|Factored| |#1|) (|Factored| |#1|)) "\\spad{mergeFactors(u,v)} is used when the factorizations of \\spadvar{\\spad{u}} and \\spadvar{\\spad{v}} are known to be disjoint,{} \\spadignore{e.g.} resulting from a content/primitive part split. Essentially,{} it creates a new factored object by multiplying the units together and appending the lists of factors.")) (|refine| (((|Factored| |#1|) (|Factored| |#1|) (|Mapping| (|Factored| |#1|) |#1|)) "\\spad{refine(u,fn)} is used to apply the function \\userfun{\\spad{fn}} to each factor of \\spadvar{\\spad{u}} and then build a new factored object from the results. For example,{} if \\spadvar{\\spad{u}} were created by calling \\spad{nilFactor(10,2)} then \\spad{refine(u,factor)} would create a factored object equal to that created by \\spad{factor(100)} or \\spad{primeFactor(2,2) * primeFactor(5,2)}."))) 
@@ -1394,7 +1398,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|RetractableTo| (|Integer|)))) (|HasCategory| |#2| (QUOTE (|IntegralDomain|))) (|HasCategory| |#2| (QUOTE (|CommutativeRing|))) (|HasCategory| |#2| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|Ring|))) (|HasCategory| |#2| (QUOTE (|AbelianGroup|))) (|HasCategory| |#2| (QUOTE (|AbelianSemiGroup|))) (|HasCategory| |#2| (QUOTE (|Group|))) (|HasCategory| |#2| (QUOTE (|SemiGroup|))) (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|InputForm|))))) 
 (|FunctionSpace| R) 
 ((|constructor| (NIL "A space of formal functions with arguments in an arbitrary ordered set.")) (|univariate| (((|Fraction| (|SparseUnivariatePolynomial| $)) $ (|Kernel| $)) "\\spad{univariate(f, k)} returns \\spad{f} viewed as a univariate fraction in \\spad{k}.")) (/ (($ (|SparseMultivariatePolynomial| |#1| (|Kernel| $)) (|SparseMultivariatePolynomial| |#1| (|Kernel| $))) "\\spad{p1/p2} returns the quotient of \\spad{p1} and \\spad{p2} as an element of \\%.")) (|denominator| (($ $) "\\spad{denominator(f)} returns the denominator of \\spad{f} converted to \\%.")) (|denom| (((|SparseMultivariatePolynomial| |#1| (|Kernel| $)) $) "\\spad{denom(f)} returns the denominator of \\spad{f} viewed as a polynomial in the kernels over \\spad{R}.")) (|convert| (($ (|Factored| $)) "\\spad{convert(f1\\^e1 ... fm\\^em)} returns \\spad{(f1)\\^e1 ... (fm)\\^em} as an element of \\%,{} using formal kernels created using a \\spadfunFrom{paren}{ExpressionSpace}.")) (|isPower| (((|Union| (|Record| (|:| |val| $) (|:| |exponent| (|Integer|))) "failed") $) "\\spad{isPower(p)} returns \\spad{[x, n]} if \\spad{p = x**n} and \\spad{n <> 0}.")) (|numerator| (($ $) "\\spad{numerator(f)} returns the numerator of \\spad{f} converted to \\%.")) (|numer| (((|SparseMultivariatePolynomial| |#1| (|Kernel| $)) $) "\\spad{numer(f)} returns the numerator of \\spad{f} viewed as a polynomial in the kernels over \\spad{R} if \\spad{R} is an integral domain. If not,{} then numer(\\spad{f}) = \\spad{f} viewed as a polynomial in the kernels over \\spad{R}.")) (|coerce| (($ (|Fraction| (|Polynomial| (|Fraction| |#1|)))) "\\spad{coerce(f)} returns \\spad{f} as an element of \\%.") (($ (|Polynomial| (|Fraction| |#1|))) "\\spad{coerce(p)} returns \\spad{p} as an element of \\%.") (($ (|Fraction| |#1|)) "\\spad{coerce(q)} returns \\spad{q} as an element of \\%.") (($ (|SparseMultivariatePolynomial| |#1| (|Kernel| $))) "\\spad{coerce(p)} returns \\spad{p} as an element of \\%.")) (|isMult| (((|Union| (|Record| (|:| |coef| (|Integer|)) (|:| |var| (|Kernel| $))) "failed") $) "\\spad{isMult(p)} returns \\spad{[n, x]} if \\spad{p = n * x} and \\spad{n <> 0}.")) (|isPlus| (((|Union| (|List| $) "failed") $) "\\spad{isPlus(p)} returns \\spad{[m1,...,mn]} if \\spad{p = m1 +...+ mn} and \\spad{n > 1}.")) (|isExpt| (((|Union| (|Record| (|:| |var| (|Kernel| $)) (|:| |exponent| (|Integer|))) "failed") $ (|Symbol|)) "\\spad{isExpt(p,f)} returns \\spad{[x, n]} if \\spad{p = x**n} and \\spad{n <> 0} and \\spad{x = f(a)}.") (((|Union| (|Record| (|:| |var| (|Kernel| $)) (|:| |exponent| (|Integer|))) "failed") $ (|BasicOperator|)) "\\spad{isExpt(p,op)} returns \\spad{[x, n]} if \\spad{p = x**n} and \\spad{n <> 0} and \\spad{x = op(a)}.") (((|Union| (|Record| (|:| |var| (|Kernel| $)) (|:| |exponent| (|Integer|))) "failed") $) "\\spad{isExpt(p)} returns \\spad{[x, n]} if \\spad{p = x**n} and \\spad{n <> 0}.")) (|isTimes| (((|Union| (|List| $) "failed") $) "\\spad{isTimes(p)} returns \\spad{[a1,...,an]} if \\spad{p = a1*...*an} and \\spad{n > 1}.")) (** (($ $ (|NonNegativeInteger|)) "\\spad{x**n} returns \\spad{x} * \\spad{x} * \\spad{x} * ... * \\spad{x} (\\spad{n} times).")) (|eval| (($ $ (|Symbol|) (|NonNegativeInteger|) (|Mapping| $ $)) "\\spad{eval(x, s, n, f)} replaces every \\spad{s(a)**n} in \\spad{x} by \\spad{f(a)} for any \\spad{a}.") (($ $ (|Symbol|) (|NonNegativeInteger|) (|Mapping| $ (|List| $))) "\\spad{eval(x, s, n, f)} replaces every \\spad{s(a1,...,am)**n} in \\spad{x} by \\spad{f(a1,...,am)} for any \\spad{a1},{}...,{}am.") (($ $ (|List| (|Symbol|)) (|List| (|NonNegativeInteger|)) (|List| (|Mapping| $ (|List| $)))) "\\spad{eval(x, [s1,...,sm], [n1,...,nm], [f1,...,fm])} replaces every \\spad{si(a1,...,an)**ni} in \\spad{x} by \\spad{fi(a1,...,an)} for any \\spad{a1},{}...,{}am.") (($ $ (|List| (|Symbol|)) (|List| (|NonNegativeInteger|)) (|List| (|Mapping| $ $))) "\\spad{eval(x, [s1,...,sm], [n1,...,nm], [f1,...,fm])} replaces every \\spad{si(a)**ni} in \\spad{x} by \\spad{fi(a)} for any \\spad{a}.") (($ $ (|List| (|BasicOperator|)) (|List| $) (|Symbol|)) "\\spad{eval(x, [s1,...,sm], [f1,...,fm], y)} replaces every \\spad{si(a)} in \\spad{x} by \\spad{fi(y)} with \\spad{y} replaced by \\spad{a} for any \\spad{a}.") (($ $ (|BasicOperator|) $ (|Symbol|)) "\\spad{eval(x, s, f, y)} replaces every \\spad{s(a)} in \\spad{x} by \\spad{f(y)} with \\spad{y} replaced by \\spad{a} for any \\spad{a}.") (($ $) "\\spad{eval(f)} unquotes all the quoted operators in \\spad{f}.") (($ $ (|List| (|Symbol|))) "\\spad{eval(f, [foo1,...,foon])} unquotes all the \\spad{fooi}'s in \\spad{f}.") (($ $ (|Symbol|)) "\\spad{eval(f, foo)} unquotes all the foo's in \\spad{f}.")) (|applyQuote| (($ (|Symbol|) (|List| $)) "\\spad{applyQuote(foo, [x1,...,xn])} returns \\spad{'foo(x1,...,xn)}.") (($ (|Symbol|) $ $ $ $) "\\spad{applyQuote(foo, x, y, z, t)} returns \\spad{'foo(x,y,z,t)}.") (($ (|Symbol|) $ $ $) "\\spad{applyQuote(foo, x, y, z)} returns \\spad{'foo(x,y,z)}.") (($ (|Symbol|) $ $) "\\spad{applyQuote(foo, x, y)} returns \\spad{'foo(x,y)}.") (($ (|Symbol|) $) "\\spad{applyQuote(foo, x)} returns \\spad{'foo(x)}.")) (|variables| (((|List| (|Symbol|)) $) "\\spad{variables(f)} returns the list of all the variables of \\spad{f}.")) (|ground| ((|#1| $) "\\spad{ground(f)} returns \\spad{f} as an element of \\spad{R}. An error occurs if \\spad{f} is not an element of \\spad{R}.")) (|ground?| (((|Boolean|) $) "\\spad{ground?(f)} tests if \\spad{f} is an element of \\spad{R}."))) 
-((|unitsKnown| OR (|has| |#1| (|Ring|)) (|has| |#1| (|Group|))) (|leftUnitary| |has| |#1| . #1=((|CommutativeRing|))) (|rightUnitary| |has| |#1| . #1#) ((|commutative| "*") |has| |#1| . #2=((|IntegralDomain|))) (|noZeroDivisors| |has| |#1| . #2#) (|canonicalUnitNormal| |has| |#1| . #2#) (|canonicalsClosed| |has| |#1| . #2#)) 
+(((|commutative| "*") |has| |#1| . #1=((|IntegralDomain|))) (|noZeroDivisors| |has| |#1| . #1#) (|canonicalUnitNormal| |has| |#1| . #1#)) 
 NIL 
 (|FunctionSpaceFunctions2| R A S B) 
 ((|constructor| (NIL "This package allows a mapping \\spad{R} -> \\spad{S} to be lifted to a mapping from a function space over \\spad{R} to a function space over \\spad{S}.")) (|map| ((|#4| (|Mapping| |#3| |#1|) |#2|) "\\spad{map(f, a)} applies \\spad{f} to all the constants in \\spad{R} appearing in \\spad{a}."))) 
@@ -1426,7 +1430,7 @@ NIL
 NIL 
 (|FourierSeries| R E) 
 ((|constructor| (NIL "\\indented{1}{Author: James Davenport} Date Created: 17 April 1992 Date Last Updated: Basic Functions: Related Constructors: Also See: AMS Classifications: Keywords: References: Description:")) (|makeCos| (($ |#2| |#1|) "\\spad{makeCos(e,r)} makes a sin expression with given argument and coefficient")) (|makeSin| (($ |#2| |#1|) "\\spad{makeSin(e,r)} makes a sin expression with given argument and coefficient")) (|coerce| (($ (|FourierComponent| |#2|)) "\\spad{coerce(c)} converts sin/cos terms into Fourier Series") (($ |#1|) "\\spad{coerce(r)} converts coefficients into Fourier Series"))) 
-((|canonical| AND (|has| |#1| #1=(ATTRIBUTE |canonical|)) (|has| |#2| #1#)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonical| AND (|has| |#1| #1=(ATTRIBUTE |canonical|)) (|has| |#2| #1#))) 
 ((AND (|HasAttribute| |#1| #1=(QUOTE |canonical|)) (|HasAttribute| |#2| #1#))) 
 (|FunctionSpaceIntegration| R F) 
 ((|constructor| (NIL "\\spadtype{FunctionSpaceIntegration} provides functions for the indefinite integration of real-valued functions.")) (|integrate| (((|Union| |#2| (|List| |#2|)) |#2| (|Symbol|)) "\\spad{integrate(f, x)} returns the integral of \\spad{f(x)dx} where \\spad{x} is viewed as a real variable."))) 
@@ -1445,7 +1449,7 @@ NIL
 NIL 
 NIL 
 (|FortranScalarType|) 
-((|constructor| (NIL "Creates and manipulates objects which correspond to the basic FORTRAN data types: REAL,{} INTEGER,{} COMPLEX,{} LOGICAL and CHARACTER")) (= (((|Boolean|) $ $) "\\spad{x=y} tests for equality")) (|logical?| (((|Boolean|) $) "\\spad{logical?(t)} tests whether \\spad{t} is equivalent to the FORTRAN type LOGICAL.")) (|character?| (((|Boolean|) $) "\\spad{character?(t)} tests whether \\spad{t} is equivalent to the FORTRAN type CHARACTER.")) (|doubleComplex?| (((|Boolean|) $) "\\spad{doubleComplex?(t)} tests whether \\spad{t} is equivalent to the (non-standard) FORTRAN type DOUBLE COMPLEX.")) (|complex?| (((|Boolean|) $) "\\spad{complex?(t)} tests whether \\spad{t} is equivalent to the FORTRAN type COMPLEX.")) (|integer?| (((|Boolean|) $) "\\spad{integer?(t)} tests whether \\spad{t} is equivalent to the FORTRAN type INTEGER.")) (|double?| (((|Boolean|) $) "\\spad{double?(t)} tests whether \\spad{t} is equivalent to the FORTRAN type DOUBLE PRECISION")) (|real?| (((|Boolean|) $) "\\spad{real?(t)} tests whether \\spad{t} is equivalent to the FORTRAN type REAL.")) (|coerce| (((|SExpression|) $) "\\spad{coerce(x)} returns the \\spad{s}-expression associated with \\spad{x}") (((|Symbol|) $) "\\spad{coerce(x)} returns the symbol associated with \\spad{x}") (($ (|Symbol|)) "\\spad{coerce(s)} transforms the symbol \\spad{s} into an element of FortranScalarType provided \\spad{s} is one of real,{} complex,{}double precision,{} logical,{} integer,{} character,{} REAL,{} COMPLEX,{} LOGICAL,{} INTEGER,{} CHARACTER,{} DOUBLE PRECISION") (($ (|String|)) "\\spad{coerce(s)} transforms the string \\spad{s} into an element of FortranScalarType provided \\spad{s} is one of \"real\",{} \"double precision\",{} \"complex\",{} \"logical\",{} \"integer\",{} \"character\",{} \"REAL\",{} \"COMPLEX\",{} \"LOGICAL\",{} \"INTEGER\",{} \"CHARACTER\",{} \"DOUBLE PRECISION\""))) 
+((|constructor| (NIL "Creates and manipulates objects which correspond to the basic FORTRAN data types: REAL,{} INTEGER,{} COMPLEX,{} LOGICAL and CHARACTER")) (= (((|Boolean|) $ $) "\\spad{x=y} tests for equality")) (|logical?| (((|Boolean|) $) "\\spad{logical?(t)} tests whether \\spad{t} is equivalent to the FORTRAN type LOGICAL.")) (|character?| (((|Boolean|) $) "\\spad{character?(t)} tests whether \\spad{t} is equivalent to the FORTRAN type CHARACTER.")) (|doubleComplex?| (((|Boolean|) $) "\\spad{doubleComplex?(t)} tests whether \\spad{t} is equivalent to the (non-standard) FORTRAN type DOUBLE COMPLEX.")) (|complex?| (((|Boolean|) $) "\\spad{complex?(t)} tests whether \\spad{t} is equivalent to the FORTRAN type COMPLEX.")) (|integer?| (((|Boolean|) $) "\\spad{integer?(t)} tests whether \\spad{t} is equivalent to the FORTRAN type INTEGER.")) (|double?| (((|Boolean|) $) "\\spad{double?(t)} tests whether \\spad{t} is equivalent to the FORTRAN type DOUBLE PRECISION")) (|real?| (((|Boolean|) $) "\\spad{real?(t)} tests whether \\spad{t} is equivalent to the FORTRAN type REAL.")) (|coerce| (($ (|Symbol|)) "\\spad{coerce(s)} transforms the symbol \\spad{s} into an element of FortranScalarType provided \\spad{s} is one of real,{} complex,{}double precision,{} logical,{} integer,{} character,{} REAL,{} COMPLEX,{} LOGICAL,{} INTEGER,{} CHARACTER,{} DOUBLE PRECISION") (($ (|String|)) "\\spad{coerce(s)} transforms the string \\spad{s} into an element of FortranScalarType provided \\spad{s} is one of \"real\",{} \"double precision\",{} \"complex\",{} \"logical\",{} \"integer\",{} \"character\",{} \"REAL\",{} \"COMPLEX\",{} \"LOGICAL\",{} \"INTEGER\",{} \"CHARACTER\",{} \"DOUBLE PRECISION\""))) 
 NIL 
 NIL 
 (|FunctionSpaceUnivariatePolynomialFactor| R F UP) 
@@ -1510,16 +1514,16 @@ NIL
 NIL 
 (|GcdDomain|) 
 ((|constructor| (NIL "This category describes domains where \\spadfun{gcd} can be computed but where there is no guarantee of the existence of \\spadfun{factor} operation for factorisation into irreducibles. However,{} if such a \\spadfun{factor} operation exist,{} factorization will be unique up to order and units.")) (|lcm| (($ (|List| $)) "\\spad{lcm(l)} returns the least common multiple of the elements of the list \\spad{l}.") (($ $ $) "\\spad{lcm(x,y)} returns the least common multiple of \\spad{x} and \\spad{y}.")) (|gcd| (($ (|List| $)) "\\spad{gcd(l)} returns the common gcd of the elements in the list \\spad{l}.") (($ $ $) "\\spad{gcd(x,y)} returns the greatest common divisor of \\spad{x} and \\spad{y}."))) 
-((|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|GenericNonAssociativeAlgebra| R |n| |ls| |gamma|) 
 ((|constructor| (NIL "AlgebraGenericElementPackage allows you to create generic elements of an algebra,{} \\spadignore{i.e.} the scalars are extended to include symbolic coefficients")) (|conditionsForIdempotents| (((|List| (|Polynomial| |#1|))) "\\spad{conditionsForIdempotents()} determines a complete list of polynomial equations for the coefficients of idempotents with respect to the fixed \\spad{R}-module basis") (((|List| (|Polynomial| |#1|)) (|Vector| $)) "\\spad{conditionsForIdempotents([v1,...,vn])} determines a complete list of polynomial equations for the coefficients of idempotents with respect to the \\spad{R}-module basis \\spad{v1},{}...,{}\\spad{vn}")) (|genericRightDiscriminant| (((|Fraction| (|Polynomial| |#1|))) "\\spad{genericRightDiscriminant()} is the determinant of the generic left trace forms of all products of basis element,{} if the generic left trace form is associative,{} an algebra is separable if the generic left discriminant is invertible,{} if it is non-zero,{} there is some ring extension which makes the algebra separable")) (|genericRightTraceForm| (((|Fraction| (|Polynomial| |#1|)) $ $) "\\spad{genericRightTraceForm (a,b)} is defined to be \\spadfun{genericRightTrace (a*b)},{} this defines a symmetric bilinear form on the algebra")) (|genericLeftDiscriminant| (((|Fraction| (|Polynomial| |#1|))) "\\spad{genericLeftDiscriminant()} is the determinant of the generic left trace forms of all products of basis element,{} if the generic left trace form is associative,{} an algebra is separable if the generic left discriminant is invertible,{} if it is non-zero,{} there is some ring extension which makes the algebra separable")) (|genericLeftTraceForm| (((|Fraction| (|Polynomial| |#1|)) $ $) "\\spad{genericLeftTraceForm (a,b)} is defined to be \\spad{genericLeftTrace (a*b)},{} this defines a symmetric bilinear form on the algebra")) (|genericRightNorm| (((|Fraction| (|Polynomial| |#1|)) $) "\\spad{genericRightNorm(a)} substitutes the coefficients of \\spad{a} for the generic coefficients into the coefficient of the constant term in \\spadfun{rightRankPolynomial} and changes the sign if the degree of this polynomial is odd")) (|genericRightTrace| (((|Fraction| (|Polynomial| |#1|)) $) "\\spad{genericRightTrace(a)} substitutes the coefficients of \\spad{a} for the generic coefficients into the coefficient of the second highest term in \\spadfun{rightRankPolynomial} and changes the sign")) (|genericRightMinimalPolynomial| (((|SparseUnivariatePolynomial| (|Fraction| (|Polynomial| |#1|))) $) "\\spad{genericRightMinimalPolynomial(a)} substitutes the coefficients of \\spad{a} for the generic coefficients in \\spadfun{rightRankPolynomial}")) (|rightRankPolynomial| (((|SparseUnivariatePolynomial| (|Fraction| (|Polynomial| |#1|)))) "\\spad{rightRankPolynomial()} returns the right minimimal polynomial of the generic element")) (|genericLeftNorm| (((|Fraction| (|Polynomial| |#1|)) $) "\\spad{genericLeftNorm(a)} substitutes the coefficients of \\spad{a} for the generic coefficients into the coefficient of the constant term in \\spadfun{leftRankPolynomial} and changes the sign if the degree of this polynomial is odd. This is a form of degree \\spad{k}")) (|genericLeftTrace| (((|Fraction| (|Polynomial| |#1|)) $) "\\spad{genericLeftTrace(a)} substitutes the coefficients of \\spad{a} for the generic coefficients into the coefficient of the second highest term in \\spadfun{leftRankPolynomial} and changes the sign. \\indented{1}{This is a linear form}")) (|genericLeftMinimalPolynomial| (((|SparseUnivariatePolynomial| (|Fraction| (|Polynomial| |#1|))) $) "\\spad{genericLeftMinimalPolynomial(a)} substitutes the coefficients of {em a} for the generic coefficients in \\spad{leftRankPolynomial()}")) (|leftRankPolynomial| (((|SparseUnivariatePolynomial| (|Fraction| (|Polynomial| |#1|)))) "\\spad{leftRankPolynomial()} returns the left minimimal polynomial of the generic element")) (|generic| (($ (|Vector| (|Symbol|)) (|Vector| $)) "\\spad{generic(vs,ve)} returns a generic element,{} \\spadignore{i.e.} the linear combination of \\spad{ve} with the symbolic coefficients \\spad{vs} error,{} if the vector of symbols is shorter than the vector of elements") (($ (|Symbol|) (|Vector| $)) "\\spad{generic(s,v)} returns a generic element,{} \\spadignore{i.e.} the linear combination of \\spad{v} with the symbolic coefficients \\spad{s1,s2,..}") (($ (|Vector| $)) "\\spad{generic(ve)} returns a generic element,{} \\spadignore{i.e.} the linear combination of \\spad{ve} basis with the symbolic coefficients \\spad{\\%x1,\\%x2,..}") (($ (|Vector| (|Symbol|))) "\\spad{generic(vs)} returns a generic element,{} \\spadignore{i.e.} the linear combination of the fixed basis with the symbolic coefficients \\spad{vs}; error,{} if the vector of symbols is too short") (($ (|Symbol|)) "\\spad{generic(s)} returns a generic element,{} \\spadignore{i.e.} the linear combination of the fixed basis with the symbolic coefficients \\spad{s1,s2,..}") (($) "\\spad{generic()} returns a generic element,{} \\spadignore{i.e.} the linear combination of the fixed basis with the symbolic coefficients \\spad{\\%x1,\\%x2,..}")) (|rightUnits| (((|Union| (|Record| (|:| |particular| $) (|:| |basis| (|List| $))) "failed")) "\\spad{rightUnits()} returns the affine space of all right units of the algebra,{} or \\spad{\"failed\"} if there is none")) (|leftUnits| (((|Union| (|Record| (|:| |particular| $) (|:| |basis| (|List| $))) "failed")) "\\spad{leftUnits()} returns the affine space of all left units of the algebra,{} or \\spad{\"failed\"} if there is none")) (|coerce| (($ (|Vector| (|Fraction| (|Polynomial| |#1|)))) "\\spad{coerce(v)} assumes that it is called with a vector of length equal to the dimension of the algebra,{} then a linear combination with the basis element is formed"))) 
-((|unitsKnown| |has| (|Fraction| (|Polynomial| |#1|)) (|IntegralDomain|)) (|leftUnitary| . T) (|rightUnitary| . T)) 
-((|HasCategory| #1=(|Fraction| (|Polynomial| |#1|)) (QUOTE (|Field|))) (|HasCategory| |#1| #2=(QUOTE (|IntegralDomain|))) (|HasCategory| #1# #2#)) 
+NIL 
+((|HasCategory| #1=(|Fraction| (|Polynomial| |#1|)) #2=(QUOTE (|IntegralDomain|))) (|HasCategory| #1# (QUOTE (|Field|))) (|HasCategory| |#1| #2#)) 
 (|GeneralDistributedMultivariatePolynomial| |vl| R E) 
 ((|constructor| (NIL "\\indented{2}{This type supports distributed multivariate polynomials} whose variables are from a user specified list of symbols. The coefficient ring may be non commutative,{} but the variables are assumed to commute. The term ordering is specified by its third parameter. Suggested types which define term orderings include: \\spadtype{DirectProduct},{} \\spadtype{HomogeneousDirectProduct},{} \\spadtype{SplitHomogeneousDirectProduct} and finally \\spadtype{OrderedDirectProduct} which accepts an arbitrary user function to define a term ordering.")) (|reorder| (($ $ (|List| (|Integer|))) "\\spad{reorder(p, perm)} applies the permutation perm to the variables in a polynomial and returns the new correctly ordered polynomial"))) 
-(((|commutative| "*") |has| |#2| (|CommutativeRing|)) (|noZeroDivisors| |has| |#2| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#2| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#2| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#2| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#2| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|OrderedVariableList| |#1|) #5#)) (AND (|HasCategory| |#2| #8=(QUOTE (|PatternMatchable| #9=(|Integer|)))) (|HasCategory| #7# #8#)) (AND (|HasCategory| |#2| #10=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #10#)) (AND (|HasCategory| |#2| #11=(QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#2| #12=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #12#)) (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #9#))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) #13=(|HasCategory| |#2| #14=(QUOTE (|CharacteristicNonZero|))) #15=(|HasCategory| |#2| (QUOTE (|Algebra| #16=(|Fraction| #9#)))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #9#))) (OR #15# #17=(|HasCategory| |#2| (QUOTE (|RetractableTo| #16#)))) #17# (|HasCategory| |#2| (QUOTE (|Field|))) (|HasAttribute| |#2| (QUOTE |canonicalUnitNormal|)) #3# #18=(AND #1# (|HasCategory| $ #14#)) (OR #18# #13#)) 
+(((|commutative| "*") |has| |#2| (|CommutativeRing|)) (|noZeroDivisors| |has| |#2| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#2| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#2| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#2| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#2| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|OrderedVariableList| |#1|) #5#)) (AND (|HasCategory| |#2| #8=(QUOTE (|PatternMatchable| #9=(|Integer|)))) (|HasCategory| #7# #8#)) (AND (|HasCategory| |#2| #10=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #10#)) (AND (|HasCategory| |#2| #11=(QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#2| #12=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #12#)) (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #9#))) #13=(|HasCategory| |#2| (QUOTE (|Algebra| #14=(|Fraction| #9#)))) #15=(|HasCategory| |#2| #16=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #9#))) (OR #13# #17=(|HasCategory| |#2| (QUOTE (|RetractableTo| #14#)))) #17# (|HasCategory| |#2| (QUOTE (|Field|))) (|HasAttribute| |#2| (QUOTE |canonicalUnitNormal|)) #3# #18=(AND #1# (|HasCategory| $ #16#)) (OR #18# #15#)) 
 (|GenExEuclid| R BP) 
 ((|constructor| (NIL "\\indented{1}{Author : \\spad{P}.Gianni.} January 1990 The equation \\spad{Af+Bg=h} and its generalization to \\spad{n} polynomials is solved for solutions over the \\spad{R},{} euclidean domain. A table containing the solutions of \\spad{Af+Bg=x**k} is used. The operations are performed modulus a prime which are in principle big enough,{} but the solutions are tested and,{} in case of failure,{} a hensel lifting process is used to get to the right solutions. It will be used in the factorization of multivariate polynomials over finite field,{} with \\spad{R=F[x]}.")) (|testModulus| (((|Boolean|) |#1| (|List| |#2|)) "\\spad{testModulus(p,lp)} returns \\spad{true} if the the prime \\spad{p} is valid for the list of polynomials \\spad{lp},{} \\spadignore{i.e.} preserves the degree and they remain relatively prime.")) (|solveid| (((|Union| (|List| |#2|) "failed") |#2| |#1| (|Vector| (|List| |#2|))) "\\spad{solveid(h,table)} computes the coefficients of the extended euclidean algorithm for a list of polynomials whose tablePow is \\spad{table} and with right side \\spad{h}.")) (|tablePow| (((|Union| (|Vector| (|List| |#2|)) "failed") (|NonNegativeInteger|) |#1| (|List| |#2|)) "\\spad{tablePow(maxdeg,prime,lpol)} constructs the table with the coefficients of the Extended Euclidean Algorithm for \\spad{lpol}. Here the right side is \\spad{x**k},{} for \\spad{k} less or equal to \\spad{maxdeg}. The operation returns \"failed\" when the elements are not coprime modulo \\spad{prime}.")) (|compBound| (((|NonNegativeInteger|) |#2| (|List| |#2|)) "\\spad{compBound(p,lp)} computes a bound for the coefficients of the solution polynomials. Given a polynomial right hand side \\spad{p},{} and a list \\spad{lp} of left hand side polynomials. Exported because it depends on the valuation.")) (|reduction| ((|#2| |#2| |#1|) "\\spad{reduction(p,prime)} reduces the polynomial \\spad{p} modulo \\spad{prime} of \\spad{R}. Note: this function is exported only because it's conditional."))) 
 NIL 
@@ -1546,7 +1550,7 @@ NIL
 NIL 
 (|GeneralModulePolynomial| |vl| R IS E |ff| P) 
 ((|constructor| (NIL "This package \\undocumented")) (* (($ |#6| $) "\\spad{p*x} \\undocumented")) (|multMonom| (($ |#2| |#4| $) "\\spad{multMonom(r,e,x)} \\undocumented")) (|build| (($ |#2| |#3| |#4|) "\\spad{build(r,i,e)} \\undocumented")) (|unitVector| (($ |#3|) "\\spad{unitVector(x)} \\undocumented")) (|monomial| (($ |#2| (|ModuleMonomial| |#3| |#4| |#5|)) "\\spad{monomial(r,x)} \\undocumented")) (|reductum| (($ $) "\\spad{reductum(x)} \\undocumented")) (|leadingIndex| ((|#3| $) "\\spad{leadingIndex(x)} \\undocumented")) (|leadingExponent| ((|#4| $) "\\spad{leadingExponent(x)} \\undocumented")) (|leadingMonomial| (((|ModuleMonomial| |#3| |#4| |#5|) $) "\\spad{leadingMonomial(x)} \\undocumented")) (|leadingCoefficient| ((|#2| $) "\\spad{leadingCoefficient(x)} \\undocumented"))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 NIL 
 (|GosperSummationMethod| E V R P Q) 
 ((|constructor| (NIL "Gosper's summation algorithm.")) (|GospersMethod| (((|Union| |#5| "failed") |#5| |#2| (|Mapping| |#2|)) "\\spad{GospersMethod(b, n, new)} returns a rational function \\spad{rf(n)} such that \\spad{a(n) * rf(n)} is the indefinite sum of \\spad{a(n)} with respect to upward difference on \\spad{n},{} \\spadignore{i.e.} \\spad{a(n+1) * rf(n+1) - a(n) * rf(n) = a(n)},{} where \\spad{b(n) = a(n)/a(n-1)} is a rational function. Returns \"failed\" if no such rational function \\spad{rf(n)} exists. Note: \\spad{new} is a nullary function returning a new \\spad{V} every time. The condition on \\spad{a(n)} is that \\spad{a(n)/a(n-1)} is a rational function of \\spad{n}."))) 
@@ -1573,7 +1577,7 @@ NIL
 NIL 
 NIL 
 (|GraphImage|) 
-((|constructor| (NIL "TwoDimensionalGraph creates virtual two dimensional graphs (to be displayed on TwoDimensionalViewports).")) (|putColorInfo| (((|List| (|List| (|Point| (|DoubleFloat|)))) (|List| (|List| (|Point| (|DoubleFloat|)))) (|List| (|Palette|))) "\\spad{putColorInfo(llp,lpal)} takes a list of list of points,{} \\spad{llp},{} and returns the points with their hue and shade components set according to the list of palette colors,{} \\spad{lpal}.")) (|coerce| (((|OutputForm|) $) "\\spad{coerce(gi)} returns the indicated graph,{} \\spad{gi},{} of domain \\spadtype{GraphImage} as output of the domain \\spadtype{OutputForm}.") (($ (|List| (|List| (|Point| (|DoubleFloat|))))) "\\spad{coerce(llp)} component(\\spad{gi},{}pt) creates and returns a graph of the domain \\spadtype{GraphImage} which is composed of the list of list of points given by \\spad{llp},{} and whose point colors,{} line colors and point sizes are determined by the default functions \\spadfun{pointColorDefault},{} \\spadfun{lineColorDefault},{} and \\spadfun{pointSizeDefault}. The graph data is then sent to the viewport manager where it waits to be included in a two-dimensional viewport window.")) (|point| (((|Void|) $ (|Point| (|DoubleFloat|)) (|Palette|)) "\\spad{point(gi,pt,pal)} modifies the graph \\spad{gi} of the domain \\spadtype{GraphImage} to contain one point component,{} \\spad{pt} whose point color is set to be the palette color \\spad{pal},{} and whose line color and point size are determined by the default functions \\spadfun{lineColorDefault} and \\spadfun{pointSizeDefault}.")) (|appendPoint| (((|Void|) $ (|Point| (|DoubleFloat|))) "\\spad{appendPoint(gi,pt)} appends the point \\spad{pt} to the end of the list of points component for the graph,{} \\spad{gi},{} which is of the domain \\spadtype{GraphImage}.")) (|component| (((|Void|) $ (|Point| (|DoubleFloat|)) (|Palette|) (|Palette|) (|PositiveInteger|)) "\\spad{component(gi,pt,pal1,pal2,ps)} modifies the graph \\spad{gi} of the domain \\spadtype{GraphImage} to contain one point component,{} \\spad{pt} whose point color is set to the palette color \\spad{pal1},{} line color is set to the palette color \\spad{pal2},{} and point size is set to the positive integer \\spad{ps}.") (((|Void|) $ (|Point| (|DoubleFloat|))) "\\spad{component(gi,pt)} modifies the graph \\spad{gi} of the domain \\spadtype{GraphImage} to contain one point component,{} \\spad{pt} whose point color,{} line color and point size are determined by the default functions \\spadfun{pointColorDefault},{} \\spadfun{lineColorDefault},{} and \\spadfun{pointSizeDefault}.") (((|Void|) $ (|List| (|Point| (|DoubleFloat|))) (|Palette|) (|Palette|) (|PositiveInteger|)) "\\spad{component(gi,lp,pal1,pal2,p)} sets the components of the graph,{} \\spad{gi} of the domain \\spadtype{GraphImage},{} to the values given. The point list for \\spad{gi} is set to the list \\spad{lp},{} the color of the points in \\spad{lp} is set to the palette color \\spad{pal1},{} the color of the lines which connect the points \\spad{lp} is set to the palette color \\spad{pal2},{} and the size of the points in \\spad{lp} is given by the integer \\spad{p}.")) (|units| (((|List| (|Float|)) $ (|List| (|Float|))) "\\spad{units(gi,lu)} modifies the list of unit increments for the \\spad{x} and \\spad{y} axes of the given graph,{} \\spad{gi} of the domain \\spadtype{GraphImage},{} to be that of the list of unit increments,{} \\spad{lu},{} and returns the new list of units for \\spad{gi}.") (((|List| (|Float|)) $) "\\spad{units(gi)} returns the list of unit increments for the \\spad{x} and \\spad{y} axes of the indicated graph,{} \\spad{gi},{} of the domain \\spadtype{GraphImage}.")) (|ranges| (((|List| (|Segment| (|Float|))) $ (|List| (|Segment| (|Float|)))) "\\spad{ranges(gi,lr)} modifies the list of ranges for the given graph,{} \\spad{gi} of the domain \\spadtype{GraphImage},{} to be that of the list of range segments,{} \\spad{lr},{} and returns the new range list for \\spad{gi}.") (((|List| (|Segment| (|Float|))) $) "\\spad{ranges(gi)} returns the list of ranges of the point components from the indicated graph,{} \\spad{gi},{} of the domain \\spadtype{GraphImage}.")) (|key| (((|Integer|) $) "\\spad{key(gi)} returns the process ID of the given graph,{} \\spad{gi},{} of the domain \\spadtype{GraphImage}.")) (|pointLists| (((|List| (|List| (|Point| (|DoubleFloat|)))) $) "\\spad{pointLists(gi)} returns the list of lists of points which compose the given graph,{} \\spad{gi},{} of the domain \\spadtype{GraphImage}.")) (|makeGraphImage| (($ (|List| (|List| (|Point| (|DoubleFloat|)))) (|List| (|Palette|)) (|List| (|Palette|)) (|List| (|PositiveInteger|)) (|List| (|DrawOption|))) "\\spad{makeGraphImage(llp,lpal1,lpal2,lp,lopt)} returns a graph of the domain \\spadtype{GraphImage} which is composed of the points and lines from the list of lists of points,{} \\spad{llp},{} whose point colors are indicated by the list of palette colors,{} \\spad{lpal1},{} and whose lines are colored according to the list of palette colors,{} \\spad{lpal2}. The paramater \\spad{lp} is a list of integers which denote the size of the data points,{} and \\spad{lopt} is the list of draw command options. The graph data is then sent to the viewport manager where it waits to be included in a two-dimensional viewport window.") (($ (|List| (|List| (|Point| (|DoubleFloat|)))) (|List| (|Palette|)) (|List| (|Palette|)) (|List| (|PositiveInteger|))) "\\spad{makeGraphImage(llp,lpal1,lpal2,lp)} returns a graph of the domain \\spadtype{GraphImage} which is composed of the points and lines from the list of lists of points,{} \\spad{llp},{} whose point colors are indicated by the list of palette colors,{} \\spad{lpal1},{} and whose lines are colored according to the list of palette colors,{} \\spad{lpal2}. The paramater \\spad{lp} is a list of integers which denote the size of the data points. The graph data is then sent to the viewport manager where it waits to be included in a two-dimensional viewport window.") (($ (|List| (|List| (|Point| (|DoubleFloat|))))) "\\spad{makeGraphImage(llp)} returns a graph of the domain \\spadtype{GraphImage} which is composed of the points and lines from the list of lists of points,{} \\spad{llp},{} with default point size and default point and line colours. The graph data is then sent to the viewport manager where it waits to be included in a two-dimensional viewport window.") (($ $) "\\spad{makeGraphImage(gi)} takes the given graph,{} \\spad{gi} of the domain \\spadtype{GraphImage},{} and sends it's data to the viewport manager where it waits to be included in a two-dimensional viewport window. \\spad{gi} cannot be an empty graph,{} and it's elements must have been created using the \\spadfun{point} or \\spadfun{component} functions,{} not by a previous \\spadfun{makeGraphImage}.")) (|graphImage| (($) "\\spad{graphImage()} returns an empty graph with 0 point lists of the domain \\spadtype{GraphImage}. A graph image contains the graph data component of a two dimensional viewport."))) 
+((|constructor| (NIL "TwoDimensionalGraph creates virtual two dimensional graphs (to be displayed on TwoDimensionalViewports).")) (|putColorInfo| (((|List| (|List| (|Point| (|DoubleFloat|)))) (|List| (|List| (|Point| (|DoubleFloat|)))) (|List| (|Palette|))) "\\spad{putColorInfo(llp,lpal)} takes a list of list of points,{} \\spad{llp},{} and returns the points with their hue and shade components set according to the list of palette colors,{} \\spad{lpal}.")) (|coerce| (($ (|List| (|List| (|Point| (|DoubleFloat|))))) "\\spad{coerce(llp)} component(\\spad{gi},{}pt) creates and returns a graph of the domain \\spadtype{GraphImage} which is composed of the list of list of points given by \\spad{llp},{} and whose point colors,{} line colors and point sizes are determined by the default functions \\spadfun{pointColorDefault},{} \\spadfun{lineColorDefault},{} and \\spadfun{pointSizeDefault}. The graph data is then sent to the viewport manager where it waits to be included in a two-dimensional viewport window.")) (|point| (((|Void|) $ (|Point| (|DoubleFloat|)) (|Palette|)) "\\spad{point(gi,pt,pal)} modifies the graph \\spad{gi} of the domain \\spadtype{GraphImage} to contain one point component,{} \\spad{pt} whose point color is set to be the palette color \\spad{pal},{} and whose line color and point size are determined by the default functions \\spadfun{lineColorDefault} and \\spadfun{pointSizeDefault}.")) (|appendPoint| (((|Void|) $ (|Point| (|DoubleFloat|))) "\\spad{appendPoint(gi,pt)} appends the point \\spad{pt} to the end of the list of points component for the graph,{} \\spad{gi},{} which is of the domain \\spadtype{GraphImage}.")) (|component| (((|Void|) $ (|Point| (|DoubleFloat|)) (|Palette|) (|Palette|) (|PositiveInteger|)) "\\spad{component(gi,pt,pal1,pal2,ps)} modifies the graph \\spad{gi} of the domain \\spadtype{GraphImage} to contain one point component,{} \\spad{pt} whose point color is set to the palette color \\spad{pal1},{} line color is set to the palette color \\spad{pal2},{} and point size is set to the positive integer \\spad{ps}.") (((|Void|) $ (|Point| (|DoubleFloat|))) "\\spad{component(gi,pt)} modifies the graph \\spad{gi} of the domain \\spadtype{GraphImage} to contain one point component,{} \\spad{pt} whose point color,{} line color and point size are determined by the default functions \\spadfun{pointColorDefault},{} \\spadfun{lineColorDefault},{} and \\spadfun{pointSizeDefault}.") (((|Void|) $ (|List| (|Point| (|DoubleFloat|))) (|Palette|) (|Palette|) (|PositiveInteger|)) "\\spad{component(gi,lp,pal1,pal2,p)} sets the components of the graph,{} \\spad{gi} of the domain \\spadtype{GraphImage},{} to the values given. The point list for \\spad{gi} is set to the list \\spad{lp},{} the color of the points in \\spad{lp} is set to the palette color \\spad{pal1},{} the color of the lines which connect the points \\spad{lp} is set to the palette color \\spad{pal2},{} and the size of the points in \\spad{lp} is given by the integer \\spad{p}.")) (|units| (((|List| (|Float|)) $ (|List| (|Float|))) "\\spad{units(gi,lu)} modifies the list of unit increments for the \\spad{x} and \\spad{y} axes of the given graph,{} \\spad{gi} of the domain \\spadtype{GraphImage},{} to be that of the list of unit increments,{} \\spad{lu},{} and returns the new list of units for \\spad{gi}.") (((|List| (|Float|)) $) "\\spad{units(gi)} returns the list of unit increments for the \\spad{x} and \\spad{y} axes of the indicated graph,{} \\spad{gi},{} of the domain \\spadtype{GraphImage}.")) (|ranges| (((|List| (|Segment| (|Float|))) $ (|List| (|Segment| (|Float|)))) "\\spad{ranges(gi,lr)} modifies the list of ranges for the given graph,{} \\spad{gi} of the domain \\spadtype{GraphImage},{} to be that of the list of range segments,{} \\spad{lr},{} and returns the new range list for \\spad{gi}.") (((|List| (|Segment| (|Float|))) $) "\\spad{ranges(gi)} returns the list of ranges of the point components from the indicated graph,{} \\spad{gi},{} of the domain \\spadtype{GraphImage}.")) (|key| (((|Integer|) $) "\\spad{key(gi)} returns the process ID of the given graph,{} \\spad{gi},{} of the domain \\spadtype{GraphImage}.")) (|pointLists| (((|List| (|List| (|Point| (|DoubleFloat|)))) $) "\\spad{pointLists(gi)} returns the list of lists of points which compose the given graph,{} \\spad{gi},{} of the domain \\spadtype{GraphImage}.")) (|makeGraphImage| (($ (|List| (|List| (|Point| (|DoubleFloat|)))) (|List| (|Palette|)) (|List| (|Palette|)) (|List| (|PositiveInteger|)) (|List| (|DrawOption|))) "\\spad{makeGraphImage(llp,lpal1,lpal2,lp,lopt)} returns a graph of the domain \\spadtype{GraphImage} which is composed of the points and lines from the list of lists of points,{} \\spad{llp},{} whose point colors are indicated by the list of palette colors,{} \\spad{lpal1},{} and whose lines are colored according to the list of palette colors,{} \\spad{lpal2}. The paramater \\spad{lp} is a list of integers which denote the size of the data points,{} and \\spad{lopt} is the list of draw command options. The graph data is then sent to the viewport manager where it waits to be included in a two-dimensional viewport window.") (($ (|List| (|List| (|Point| (|DoubleFloat|)))) (|List| (|Palette|)) (|List| (|Palette|)) (|List| (|PositiveInteger|))) "\\spad{makeGraphImage(llp,lpal1,lpal2,lp)} returns a graph of the domain \\spadtype{GraphImage} which is composed of the points and lines from the list of lists of points,{} \\spad{llp},{} whose point colors are indicated by the list of palette colors,{} \\spad{lpal1},{} and whose lines are colored according to the list of palette colors,{} \\spad{lpal2}. The paramater \\spad{lp} is a list of integers which denote the size of the data points. The graph data is then sent to the viewport manager where it waits to be included in a two-dimensional viewport window.") (($ (|List| (|List| (|Point| (|DoubleFloat|))))) "\\spad{makeGraphImage(llp)} returns a graph of the domain \\spadtype{GraphImage} which is composed of the points and lines from the list of lists of points,{} \\spad{llp},{} with default point size and default point and line colours. The graph data is then sent to the viewport manager where it waits to be included in a two-dimensional viewport window.") (($ $) "\\spad{makeGraphImage(gi)} takes the given graph,{} \\spad{gi} of the domain \\spadtype{GraphImage},{} and sends it's data to the viewport manager where it waits to be included in a two-dimensional viewport window. \\spad{gi} cannot be an empty graph,{} and it's elements must have been created using the \\spadfun{point} or \\spadfun{component} functions,{} not by a previous \\spadfun{makeGraphImage}.")) (|graphImage| (($) "\\spad{graphImage()} returns an empty graph with 0 point lists of the domain \\spadtype{GraphImage}. A graph image contains the graph data component of a two dimensional viewport."))) 
 NIL 
 NIL 
 (|GradedModule&| S R E) 
@@ -1589,16 +1593,16 @@ NIL
 NIL 
 NIL 
 (|Group&| S) 
-((|constructor| (NIL "The class of multiplicative groups,{} \\spadignore{i.e.} monoids with multiplicative inverses. \\blankline")) (|commutator| (($ $ $) "\\spad{commutator(p,q)} computes \\spad{inv(p) * inv(q) * p * q}.")) (|conjugate| (($ $ $) "\\spad{conjugate(p,q)} computes \\spad{inv(q) * p * q}; this is 'right action by conjugation'.")) (|unitsKnown| ((|attribute|) "unitsKnown asserts that recip only returns \"failed\" for non-units.")) (** (($ $ (|Integer|)) "\\spad{x**n} returns \\spad{x} raised to the integer power \\spad{n}.")) (/ (($ $ $) "\\spad{x/y} is the same as \\spad{x} times the inverse of \\spad{y}.")) (|inv| (($ $) "\\spad{inv(x)} returns the inverse of \\spad{x}."))) 
+((|constructor| (NIL "The class of multiplicative groups,{} \\spadignore{i.e.} monoids with multiplicative inverses. \\blankline")) (|commutator| (($ $ $) "\\spad{commutator(p,q)} computes \\spad{inv(p) * inv(q) * p * q}.")) (|conjugate| (($ $ $) "\\spad{conjugate(p,q)} computes \\spad{inv(q) * p * q}; this is 'right action by conjugation'.")) (** (($ $ (|Integer|)) "\\spad{x**n} returns \\spad{x} raised to the integer power \\spad{n}.")) (/ (($ $ $) "\\spad{x/y} is the same as \\spad{x} times the inverse of \\spad{y}.")) (|inv| (($ $) "\\spad{inv(x)} returns the inverse of \\spad{x}."))) 
 NIL 
 NIL 
 (|Group|) 
-((|constructor| (NIL "The class of multiplicative groups,{} \\spadignore{i.e.} monoids with multiplicative inverses. \\blankline")) (|commutator| (($ $ $) "\\spad{commutator(p,q)} computes \\spad{inv(p) * inv(q) * p * q}.")) (|conjugate| (($ $ $) "\\spad{conjugate(p,q)} computes \\spad{inv(q) * p * q}; this is 'right action by conjugation'.")) (|unitsKnown| ((|attribute|) "unitsKnown asserts that recip only returns \"failed\" for non-units.")) (** (($ $ (|Integer|)) "\\spad{x**n} returns \\spad{x} raised to the integer power \\spad{n}.")) (/ (($ $ $) "\\spad{x/y} is the same as \\spad{x} times the inverse of \\spad{y}.")) (|inv| (($ $) "\\spad{inv(x)} returns the inverse of \\spad{x}."))) 
-((|unitsKnown| . T)) 
+((|constructor| (NIL "The class of multiplicative groups,{} \\spadignore{i.e.} monoids with multiplicative inverses. \\blankline")) (|commutator| (($ $ $) "\\spad{commutator(p,q)} computes \\spad{inv(p) * inv(q) * p * q}.")) (|conjugate| (($ $ $) "\\spad{conjugate(p,q)} computes \\spad{inv(q) * p * q}; this is 'right action by conjugation'.")) (** (($ $ (|Integer|)) "\\spad{x**n} returns \\spad{x} raised to the integer power \\spad{n}.")) (/ (($ $ $) "\\spad{x/y} is the same as \\spad{x} times the inverse of \\spad{y}.")) (|inv| (($ $) "\\spad{inv(x)} returns the inverse of \\spad{x}."))) 
+NIL 
 NIL 
 (|GeneralUnivariatePowerSeries| |Coef| |var| |cen|) 
 ((|constructor| (NIL "This is a category of univariate Puiseux series constructed from univariate Laurent series. A Puiseux series is represented by a pair \\spad{[r,f(x)]},{} where \\spad{r} is a positive rational number and \\spad{f(x)} is a Laurent series. This pair represents the Puiseux series \\spad{f(x\\^r)}.")) (|integrate| (($ $ (|Variable| |#2|)) "\\spad{integrate(f(x))} returns an anti-derivative of the power series \\spad{f(x)} with constant coefficient 0. We may integrate a series when we can divide coefficients by integers.")) (|coerce| (($ (|UnivariatePuiseuxSeries| |#1| |#2| |#3|)) "\\spad{coerce(f)} converts a Puiseux series to a general power series.") (($ (|Variable| |#2|)) "\\spad{coerce(var)} converts the series variable \\spad{var} into a Puiseux series."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| . #1=((|Field|))) (|canonicalsClosed| |has| |#1| . #1#) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (|Field|))) 
 (#1=(|HasCategory| |#1| (QUOTE (|Algebra| #2=(|Fraction| #3=(|Integer|))))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #5=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #5# #4#) (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (AND (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #6=(|Symbol|)))) #7=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #8=(|devaluate| |#1|) #9=(|%list| (QUOTE |Fraction|) (QUOTE #3#)) #8#)))) #7# (|HasCategory| #2# (QUOTE (|SemiGroup|))) #10=(|HasCategory| |#1| (QUOTE (|Field|))) (OR #5# #10# #4#) (OR #10# #4#) (AND #11=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #8# #8# #9#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #8# #12=(QUOTE #6#))))) #11# (OR (AND #1# (|HasCategory| |#1| (QUOTE (|AlgebraicallyClosedFunctionSpace| #3#))) (|HasCategory| |#1| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) (AND #1# (|HasSignature| |#1| (|%list| (QUOTE |integrate|) (|%list| #8# #8# #12#))) (|HasSignature| |#1| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #12#) #8#)))))) 
 (|GeneralSparseTable| |Key| |Entry| |Tbl| |dent|) 
 ((|constructor| (NIL "A sparse table has a default entry,{} which is returned if no other value has been explicitly stored for a key."))) 
@@ -1610,7 +1614,7 @@ NIL
 ((AND #1=(|HasCategory| |#4| (QUOTE (|SetCategory|))) (|HasCategory| |#4| (|%list| (QUOTE |Evalable|) #2=(|devaluate| |#4|)))) (|HasCategory| |#4| (QUOTE (|ConvertibleTo| (|InputForm|)))) #3=(|HasCategory| |#4| (QUOTE (|BasicType|))) (|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (|HasCategory| |#3| (QUOTE (|Finite|))) (|HasCategory| |#4| (QUOTE (|CoercibleTo| (|OutputForm|)))) #1# (AND #3# #4=(|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #2#))) #4#) 
 (|Pi|) 
 ((|constructor| (NIL "\\indented{1}{Symbolic fractions in \\%\\spad{pi} with integer coefficients;} \\indented{1}{The point for using \\spad{Pi} as the default domain for those fractions} \\indented{1}{is that \\spad{Pi} is coercible to the float types,{} and not Expression.} Date Created: 21 Feb 1990 Date Last Updated: 12 Mai 1992")) (|pi| (($) "\\spad{pi()} returns the symbolic \\%\\spad{pi}."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|HasAst|) 
 ((|constructor| (NIL "This domain represents a `has' expression.")) (|rhs| (((|SpadAst|) $) "\\spad{rhs(e)} returns the right hand side of the case expression `e'.")) (|lhs| (((|SpadAst|) $) "\\spad{lhs(e)} returns the left hand side of the has expression `e'."))) 
@@ -1626,12 +1630,12 @@ NIL
 NIL 
 (|HomogeneousDistributedMultivariatePolynomial| |vl| R) 
 ((|constructor| (NIL "\\indented{2}{This type supports distributed multivariate polynomials} whose variables are from a user specified list of symbols. The coefficient ring may be non commutative,{} but the variables are assumed to commute. The term ordering is total degree ordering refined by reverse lexicographic ordering with respect to the position that the variables appear in the list of variables parameter.")) (|reorder| (($ $ (|List| (|Integer|))) "\\spad{reorder(p, perm)} applies the permutation perm to the variables in a polynomial and returns the new correctly ordered polynomial"))) 
-(((|commutative| "*") |has| |#2| (|CommutativeRing|)) (|noZeroDivisors| |has| |#2| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#2| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#2| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#2| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#2| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|OrderedVariableList| |#1|) #5#)) (AND (|HasCategory| |#2| #8=(QUOTE (|PatternMatchable| #9=(|Integer|)))) (|HasCategory| #7# #8#)) (AND (|HasCategory| |#2| #10=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #10#)) (AND (|HasCategory| |#2| #11=(QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#2| #12=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #12#)) (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #9#))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) #13=(|HasCategory| |#2| #14=(QUOTE (|CharacteristicNonZero|))) #15=(|HasCategory| |#2| (QUOTE (|Algebra| #16=(|Fraction| #9#)))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #9#))) (OR #15# #17=(|HasCategory| |#2| (QUOTE (|RetractableTo| #16#)))) #17# (|HasCategory| |#2| (QUOTE (|Field|))) (|HasAttribute| |#2| (QUOTE |canonicalUnitNormal|)) #3# #18=(AND #1# (|HasCategory| $ #14#)) (OR #18# #13#)) 
+(((|commutative| "*") |has| |#2| (|CommutativeRing|)) (|noZeroDivisors| |has| |#2| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#2| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#2| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#2| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#2| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|OrderedVariableList| |#1|) #5#)) (AND (|HasCategory| |#2| #8=(QUOTE (|PatternMatchable| #9=(|Integer|)))) (|HasCategory| #7# #8#)) (AND (|HasCategory| |#2| #10=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #10#)) (AND (|HasCategory| |#2| #11=(QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#2| #12=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #12#)) (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #9#))) #13=(|HasCategory| |#2| (QUOTE (|Algebra| #14=(|Fraction| #9#)))) #15=(|HasCategory| |#2| #16=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #9#))) (OR #13# #17=(|HasCategory| |#2| (QUOTE (|RetractableTo| #14#)))) #17# (|HasCategory| |#2| (QUOTE (|Field|))) (|HasAttribute| |#2| (QUOTE |canonicalUnitNormal|)) #3# #18=(AND #1# (|HasCategory| $ #16#)) (OR #18# #15#)) 
 (|HomogeneousDirectProduct| |dim| S) 
 ((|constructor| (NIL "\\indented{2}{This type represents the finite direct or cartesian product of an} underlying ordered component type. The vectors are ordered first by the sum of their components,{} and then refined using a reverse lexicographic ordering. This type is a suitable third argument for \\spadtype{GeneralDistributedMultivariatePolynomial}."))) 
-((|rightUnitary| |has| |#2| . #1=((|Ring|))) (|leftUnitary| |has| |#2| . #1#) (|unitsKnown| |has| |#2| (ATTRIBUTE |unitsKnown|))) 
-((OR (AND #1=(|HasCategory| |#2| (QUOTE (|AbelianGroup|))) #2=(|HasCategory| |#2| (|%list| (QUOTE |Evalable|) #3=(|devaluate| |#2|)))) (AND #4=(|HasCategory| |#2| (QUOTE (|AbelianMonoid|))) #2#) (AND #5=(|HasCategory| |#2| (QUOTE (|AbelianSemiGroup|))) #2#) (AND #6=(|HasCategory| |#2| (QUOTE (|CancellationAbelianMonoid|))) #2#) (AND #7=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #2#) (AND #8=(|HasCategory| |#2| (QUOTE (|DifferentialRing|))) #2#) (AND #9=(|HasCategory| |#2| (QUOTE (|Field|))) #2#) (AND #10=(|HasCategory| |#2| (QUOTE (|Finite|))) #2#) (AND #11=(|HasCategory| |#2| (QUOTE (|Monoid|))) #2#) (AND #12=(|HasCategory| |#2| (QUOTE (|OrderedAbelianMonoidSup|))) #2#) (AND #13=(|HasCategory| |#2| #14=(QUOTE (|OrderedSet|))) #2#) (AND #15=(|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #16=(|Symbol|)))) #2#) (AND #17=(|HasCategory| |#2| (QUOTE (|Ring|))) #2#) #18=(AND #19=(|HasCategory| |#2| (QUOTE (|SetCategory|))) #2#)) (|HasCategory| |#2| (QUOTE (|CoercibleTo| (|OutputForm|)))) #9# (OR #7# #9# #17#) (OR #7# #9#) #1# #17# #11# #12# (OR #12# #13#) #13# #10# (OR (AND #7# #20=(|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #21=(|Integer|))))) (AND #8# #20#) (AND #9# #20#) (AND #20# #15#) #22=(AND #20# #17#)) #15# (OR #1# #4# #5# #23=(|HasCategory| |#2| (QUOTE (|BasicType|))) #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #15# #17#) (OR #1# #4# #6# #7# #8# #9# #15# #17#) (OR #1# #6# #7# #8# #9# #15# #17#) (OR #1# #7# #8# #9# #15# #17#) (OR #8# #15# #17#) #8# (OR #8# #24=(AND (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) #17#)) (OR #25=(AND (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #16#))) #17#) #15#) #19# (OR (AND #1# #26=(|HasCategory| |#2| (QUOTE (|RetractableTo| (|Fraction| #21#))))) (AND #4# #26#) (AND #5# #26#) (AND #6# #26#) (AND #7# #26#) (AND #8# #26#) (AND #9# #26#) (AND #10# #26#) (AND #11# #26#) (AND #12# #26#) (AND #13# #26#) (AND #15# #26#) (AND #26# #17#) #27=(AND #26# #19#)) (OR #28=(AND #1# #29=(|HasCategory| |#2| (QUOTE (|RetractableTo| #21#)))) #30=(AND #4# #29#) #31=(AND #5# #29#) #32=(AND #6# #29#) #33=(AND #7# #29#) #34=(AND #8# #29#) #35=(AND #12# #29#) #36=(AND #13# #29#) #37=(AND #15# #29#) #38=(AND #29# #19#) #39=(AND #9# #29#) #40=(AND #10# #29#) #41=(AND #11# #29#) #17#) (OR #28# #30# #31# #32# #33# #34# #35# #36# #37# #38# #39# #40# #41# (AND #29# #17#)) #23# (|HasCategory| #21# #14#) #22# #24# #25# (OR #38# #17#) #38# #27# (|HasAttribute| |#2| (QUOTE |unitsKnown|)) (AND #8# #17#) (AND #15# #17#) #7# #4# #6# #5# #18# (AND #23# (|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #3#))) (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #3#))) 
+NIL 
+((OR (AND #1=(|HasCategory| |#2| (QUOTE (|AbelianGroup|))) #2=(|HasCategory| |#2| (|%list| (QUOTE |Evalable|) #3=(|devaluate| |#2|)))) (AND #4=(|HasCategory| |#2| (QUOTE (|AbelianMonoid|))) #2#) (AND #5=(|HasCategory| |#2| (QUOTE (|AbelianSemiGroup|))) #2#) (AND #6=(|HasCategory| |#2| (QUOTE (|CancellationAbelianMonoid|))) #2#) (AND #7=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #2#) (AND #8=(|HasCategory| |#2| (QUOTE (|DifferentialRing|))) #2#) (AND #9=(|HasCategory| |#2| (QUOTE (|Field|))) #2#) (AND #10=(|HasCategory| |#2| (QUOTE (|Finite|))) #2#) (AND #11=(|HasCategory| |#2| (QUOTE (|Monoid|))) #2#) (AND #12=(|HasCategory| |#2| (QUOTE (|OrderedAbelianMonoidSup|))) #2#) (AND #13=(|HasCategory| |#2| #14=(QUOTE (|OrderedSet|))) #2#) (AND #15=(|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #16=(|Symbol|)))) #2#) (AND #17=(|HasCategory| |#2| (QUOTE (|Ring|))) #2#) #18=(AND #19=(|HasCategory| |#2| (QUOTE (|SetCategory|))) #2#)) (|HasCategory| |#2| (QUOTE (|CoercibleTo| (|OutputForm|)))) #9# (OR #7# #9# #17#) (OR #7# #9#) #1# #17# #11# #12# (OR #12# #13#) #13# #10# (OR (AND #7# #20=(|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #21=(|Integer|))))) (AND #8# #20#) (AND #9# #20#) (AND #20# #15#) #22=(AND #20# #17#)) #15# (OR #1# #4# #5# #23=(|HasCategory| |#2| (QUOTE (|BasicType|))) #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #15# #17#) (OR #1# #4# #6# #7# #8# #9# #15# #17#) (OR #1# #6# #7# #8# #9# #15# #17#) (OR #1# #7# #8# #9# #15# #17#) (OR #8# #15# #17#) #8# (OR #8# #24=(AND (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) #17#)) (OR #25=(AND (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #16#))) #17#) #15#) #19# (OR (AND #1# #26=(|HasCategory| |#2| (QUOTE (|RetractableTo| (|Fraction| #21#))))) (AND #4# #26#) (AND #5# #26#) (AND #6# #26#) (AND #7# #26#) (AND #8# #26#) (AND #9# #26#) (AND #10# #26#) (AND #11# #26#) (AND #12# #26#) (AND #13# #26#) (AND #15# #26#) (AND #26# #17#) #27=(AND #26# #19#)) (OR #28=(AND #1# #29=(|HasCategory| |#2| (QUOTE (|RetractableTo| #21#)))) #30=(AND #4# #29#) #31=(AND #5# #29#) #32=(AND #6# #29#) #33=(AND #7# #29#) #34=(AND #8# #29#) #35=(AND #12# #29#) #36=(AND #13# #29#) #37=(AND #15# #29#) #38=(AND #29# #19#) #39=(AND #9# #29#) #40=(AND #10# #29#) #41=(AND #11# #29#) #17#) (OR #28# #30# #31# #32# #33# #34# #35# #36# #37# #38# #39# #40# #41# (AND #29# #17#)) #23# (|HasCategory| #21# #14#) #22# #24# #25# (OR #38# #17#) #38# #27# (AND #8# #17#) (AND #15# #17#) #7# #4# #6# #5# #18# (AND #23# (|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #3#))) (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #3#))) 
 (|HeadAst|) 
 ((|constructor| (NIL "This domain represents the header of a definition.")) (|parameters| (((|List| (|ParameterAst|)) $) "\\spad{parameters(h)} gives the parameters specified in the definition header `h'.")) (|name| (((|Identifier|) $) "\\spad{name(h)} returns the name of the operation defined defined.")) (|headAst| (($ (|Identifier|) (|List| (|ParameterAst|))) "\\spad{headAst(f,[x1,..,xn])} constructs a function definition header."))) 
 NIL 
@@ -1650,8 +1654,8 @@ NIL
 NIL 
 (|HexadecimalExpansion|) 
 ((|constructor| (NIL "This domain allows rational numbers to be presented as repeating hexadecimal expansions.")) (|hex| (($ (|Fraction| (|Integer|))) "\\spad{hex(r)} converts a rational number to a hexadecimal expansion.")) (|fractionPart| (((|Fraction| (|Integer|)) $) "\\spad{fractionPart(h)} returns the fractional part of a hexadecimal expansion."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| #2=(|Integer|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #2#))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #2#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #2#)))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (QUOTE (|InnerEvalable| #3# #2#))) (|HasCategory| #2# (QUOTE (|Evalable| #2#))) (|HasCategory| #2# (QUOTE (|Eltable| #2# #2#))) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #2#))) #9=(AND (|HasCategory| $ #5#) #1#) (OR #9# #4#)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
+(#1=(|HasCategory| #2=(|Integer|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #2#))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #2#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #2#)))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (QUOTE (|InnerEvalable| #3# #2#))) (|HasCategory| #2# (QUOTE (|Evalable| #2#))) (|HasCategory| #2# (QUOTE (|Eltable| #2# #2#))) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #2#))) #9=(AND (|HasCategory| $ #5#) #1#) (OR #9# #4#)) 
 (|HomogeneousAggregate&| A S) 
 ((|constructor| (NIL "\\indented{2}{A homogeneous aggregate is an aggregate of elements all of the} \\indented{2}{same type,{} and is functorial in stored elements..} In the current system,{} all aggregates are homogeneous. Two attributes characterize classes of aggregates."))) 
 NIL 
@@ -1682,7 +1686,7 @@ NIL
 NIL 
 (|InnerAlgebraicNumber|) 
 ((|constructor| (NIL "Algebraic closure of the rational numbers.")) (|norm| (($ $ (|List| (|Kernel| $))) "\\spad{norm(f,l)} computes the norm of the algebraic number \\spad{f} with respect to the extension generated by kernels \\spad{l}") (($ $ (|Kernel| $)) "\\spad{norm(f,k)} computes the norm of the algebraic number \\spad{f} with respect to the extension generated by kernel \\spad{k}") (((|SparseUnivariatePolynomial| $) (|SparseUnivariatePolynomial| $) (|List| (|Kernel| $))) "\\spad{norm(p,l)} computes the norm of the polynomial \\spad{p} with respect to the extension generated by kernels \\spad{l}") (((|SparseUnivariatePolynomial| $) (|SparseUnivariatePolynomial| $) (|Kernel| $)) "\\spad{norm(p,k)} computes the norm of the polynomial \\spad{p} with respect to the extension generated by kernel \\spad{k}")) (|trueEqual| (((|Boolean|) $ $) "\\spad{trueEqual(x,y)} tries to determine if the two numbers are equal")) (|reduce| (($ $) "\\spad{reduce(f)} simplifies all the unreduced algebraic numbers present in \\spad{f} by applying their defining relations.")) (|denom| (((|SparseMultivariatePolynomial| (|Integer|) (|Kernel| $)) $) "\\spad{denom(f)} returns the denominator of \\spad{f} viewed as a polynomial in the kernels over \\spad{Z}.")) (|numer| (((|SparseMultivariatePolynomial| (|Integer|) (|Kernel| $)) $) "\\spad{numer(f)} returns the numerator of \\spad{f} viewed as a polynomial in the kernels over \\spad{Z}."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((|HasCategory| $ (QUOTE (|Ring|))) (|HasCategory| $ (QUOTE (|RetractableTo| (|Integer|))))) 
 (|IndexedOneDimensionalArray| S |mn|) 
 ((|constructor| (NIL "\\indented{1}{Author Micheal Monagan \\spad{Aug/87}} This is the basic one dimensional array data type."))) 
@@ -1782,7 +1786,7 @@ NIL
 NIL 
 (|InnerFiniteField| |p| |n|) 
 ((|constructor| (NIL "InnerFiniteField(\\spad{p},{}\\spad{n}) implements finite fields with \\spad{p**n} elements where \\spad{p} is assumed prime but does not check. For a version which checks that \\spad{p} is prime,{} see \\spadtype{FiniteField}."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((OR #1=(|HasCategory| #2=(|InnerPrimeField| |#1|) (QUOTE (|CharacteristicNonZero|))) #3=(|HasCategory| #2# (QUOTE (|Finite|)))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) #3# #1#) 
 (|InnerMatrixLinearAlgebraFunctions| R |Row| |Col| M) 
 ((|constructor| (NIL "\\spadtype{InnerMatrixLinearAlgebraFunctions} is an internal package which provides standard linear algebra functions on domains in \\spad{MatrixCategory}")) (|inverse| (((|Union| |#4| "failed") |#4|) "\\spad{inverse(m)} returns the inverse of the matrix \\spad{m}. If the matrix is not invertible,{} \"failed\" is returned. Error: if the matrix is not square.")) (|generalizedInverse| ((|#4| |#4|) "\\spad{generalizedInverse(m)} returns the generalized (Moore--Penrose) inverse of the matrix \\spad{m},{} \\spadignore{i.e.} the matrix \\spad{h} such that m*h*m=h,{} h*m*h=m,{} m*h and h*m are both symmetric matrices.")) (|determinant| ((|#1| |#4|) "\\spad{determinant(m)} returns the determinant of the matrix \\spad{m}. an error message is returned if the matrix is not square.")) (|nullSpace| (((|List| |#3|) |#4|) "\\spad{nullSpace(m)} returns a basis for the null space of the matrix \\spad{m}.")) (|nullity| (((|NonNegativeInteger|) |#4|) "\\spad{nullity(m)} returns the mullity of the matrix \\spad{m}. This is the dimension of the null space of the matrix \\spad{m}.")) (|rank| (((|NonNegativeInteger|) |#4|) "\\spad{rank(m)} returns the rank of the matrix \\spad{m}.")) (|rowEchelon| ((|#4| |#4|) "\\spad{rowEchelon(m)} returns the row echelon form of the matrix \\spad{m}."))) 
@@ -1878,11 +1882,11 @@ NIL
 NIL 
 (|IntegerNumberSystem|) 
 ((|constructor| (NIL "An \\spad{IntegerNumberSystem} is a model for the integers.")) (|invmod| (($ $ $) "\\spad{invmod(a,b)},{} \\spad{0<=a<b>1},{} \\spad{(a,b)=1} means \\spad{1/a mod b}.")) (|powmod| (($ $ $ $) "\\spad{powmod(a,b,p)},{} \\spad{0<=a,b<p>1},{} means \\spad{a**b mod p}.")) (|mulmod| (($ $ $ $) "\\spad{mulmod(a,b,p)},{} \\spad{0<=a,b<p>1},{} means \\spad{a*b mod p}.")) (|submod| (($ $ $ $) "\\spad{submod(a,b,p)},{} \\spad{0<=a,b<p>1},{} means \\spad{a-b mod p}.")) (|addmod| (($ $ $ $) "\\spad{addmod(a,b,p)},{} \\spad{0<=a,b<p>1},{} means \\spad{a+b mod p}.")) (|mask| (($ $) "\\spad{mask(n)} returns \\spad{2**n-1} (an \\spad{n} bit mask).")) (|dec| (($ $) "\\spad{dec(x)} returns \\spad{x - 1}.")) (|inc| (($ $) "\\spad{inc(x)} returns \\spad{x + 1}.")) (|copy| (($ $) "\\spad{copy(n)} gives a copy of \\spad{n}.")) (|random| (($ $) "\\spad{random(a)} creates a random element from 0 to \\spad{a-1}.") (($) "\\spad{random()} creates a random element.")) (|rationalIfCan| (((|Union| (|Fraction| (|Integer|)) "failed") $) "\\spad{rationalIfCan(n)} creates a rational number,{} or returns \"failed\" if this is not possible.")) (|rational| (((|Fraction| (|Integer|)) $) "\\spad{rational(n)} creates a rational number (see \\spadtype{Fraction Integer})..")) (|rational?| (((|Boolean|) $) "\\spad{rational?(n)} tests if \\spad{n} is a rational number (see \\spadtype{Fraction Integer}).")) (|symmetricRemainder| (($ $ $) "\\spad{symmetricRemainder(a,b)} (where \\spad{b > 1}) yields \\spad{r} where \\spad{ -b/2 <= r < b/2 }.")) (|positiveRemainder| (($ $ $) "\\spad{positiveRemainder(a,b)} (where \\spad{b > 1}) yields \\spad{r} where \\spad{0 <= r < b} and \\spad{r == a rem b}.")) (|bit?| (((|Boolean|) $ $) "\\spad{bit?(n,i)} returns \\spad{true} if and only if \\spad{i}-th bit of \\spad{n} is a 1.")) (|shift| (($ $ $) "\\spad{shift(a,i)} shift \\spad{a} by \\spad{i} digits.")) (|length| (($ $) "\\spad{length(a)} length of \\spad{a} in digits.")) (|base| (($) "\\spad{base()} returns the base for the operations of \\spad{IntegerNumberSystem}.")) (|multiplicativeValuation| ((|attribute|) "euclideanSize(a*b) returns \\spad{euclideanSize(a)*euclideanSize(b)}.")) (|even?| (((|Boolean|) $) "\\spad{even?(n)} returns \\spad{true} if and only if \\spad{n} is even.")) (|odd?| (((|Boolean|) $) "\\spad{odd?(n)} returns \\spad{true} if and only if \\spad{n} is odd."))) 
-((|canonicalUnitNormal| . T) (|multiplicativeValuation| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|multiplicativeValuation| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|Integer|) 
-((|constructor| (NIL "\\spadtype{Integer} provides the domain of arbitrary precision integers.")) (|noetherian| ((|attribute|) "ascending chain condition on ideals.")) (|canonicalsClosed| ((|attribute|) "two positives multiply to give positive.")) (|canonical| ((|attribute|) "mathematical equality is data structure equality."))) 
-((|noetherian| . T) (|canonicalsClosed| . T) (|canonical| . T) (|canonicalUnitNormal| . T) (|multiplicativeValuation| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|constructor| (NIL "\\spadtype{Integer} provides the domain of arbitrary precision integers.")) (|canonical| ((|attribute|) "mathematical equality is data structure equality."))) 
+((|canonical| . T) (|canonicalUnitNormal| . T) (|multiplicativeValuation| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|Int16|) 
 ((|constructor| (NIL "This domain is a datatype for (signed) integer values of precision 16 bits."))) 
@@ -1918,15 +1922,15 @@ NIL
 NIL 
 (|IntervalCategory| R) 
 ((|constructor| (NIL "\\indented{1}{+ Author: Mike Dewar} + Date Created: November 1996 + Date Last Updated: + Basic Functions: + Related Constructors: + Also See: + AMS Classifications: + Keywords: + References: + Description: + This category implements of interval arithmetic and transcendental + functions over intervals.")) (|contains?| (((|Boolean|) $ |#1|) "\\spad{contains?(i,f)} returns \\spad{true} if \\axiom{\\spad{f}} is contained within the interval \\axiom{\\spad{i}},{} \\spad{false} otherwise.")) (|negative?| (((|Boolean|) $) "\\spad{negative?(u)} returns \\axiom{\\spad{true}} if every element of \\spad{u} is negative,{} \\axiom{\\spad{false}} otherwise.")) (|positive?| (((|Boolean|) $) "\\spad{positive?(u)} returns \\axiom{\\spad{true}} if every element of \\spad{u} is positive,{} \\axiom{\\spad{false}} otherwise.")) (|width| ((|#1| $) "\\spad{width(u)} returns \\axiom{sup(\\spad{u}) - inf(\\spad{u})}.")) (|sup| ((|#1| $) "\\spad{sup(u)} returns the supremum of \\axiom{\\spad{u}}.")) (|inf| ((|#1| $) "\\spad{inf(u)} returns the infinum of \\axiom{\\spad{u}}.")) (|qinterval| (($ |#1| |#1|) "\\spad{qinterval(inf,sup)} creates a new interval \\axiom{[\\spad{inf},{}\\spad{sup}]},{} without checking the ordering on the elements.")) (|interval| (($ (|Fraction| (|Integer|))) "\\spad{interval(f)} creates a new interval around \\spad{f}.") (($ |#1|) "\\spad{interval(f)} creates a new interval around \\spad{f}.") (($ |#1| |#1|) "\\spad{interval(inf,sup)} creates a new interval,{} either \\axiom{[\\spad{inf},{}\\spad{sup}]} if \\axiom{\\spad{inf} <= \\spad{sup}} or \\axiom{[\\spad{sup},{}in]} otherwise."))) 
-((|approximate| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|approximate| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|IntegralDomain&| S) 
-((|constructor| (NIL "The category of commutative integral domains,{} \\spadignore{i.e.} commutative rings with no zero divisors. \\blankline Conditional attributes: \\indented{2}{canonicalUnitNormal\\tab{20}the canonical field is the same for all associates} \\indented{2}{canonicalsClosed\\tab{20}the product of two canonicals is itself canonical}")) (|unit?| (((|Boolean|) $) "\\spad{unit?(x)} tests whether \\spad{x} is a unit,{} \\spadignore{i.e.} is invertible.")) (|associates?| (((|Boolean|) $ $) "\\spad{associates?(x,y)} tests whether \\spad{x} and \\spad{y} are associates,{} \\spadignore{i.e.} differ by a unit factor.")) (|unitCanonical| (($ $) "\\spad{unitCanonical(x)} returns \\spad{unitNormal(x).canonical}.")) (|unitNormal| (((|Record| (|:| |unit| $) (|:| |canonical| $) (|:| |associate| $)) $) "\\spad{unitNormal(x)} tries to choose a canonical element from the associate class of \\spad{x}. The attribute canonicalUnitNormal,{} if asserted,{} means that the \"canonical\" element is the same across all associates of \\spad{x} if \\spad{unitNormal(x) = [u,c,a]} then \\spad{u*c = x},{} \\spad{a*u = 1}.")) (|exquo| (((|Union| $ "failed") $ $) "\\spad{exquo(a,b)} either returns an element \\spad{c} such that \\spad{c*b=a} or \"failed\" if no such element can be found."))) 
+((|constructor| (NIL "The category of commutative integral domains,{} \\spadignore{i.e.} commutative rings with no zero divisors. \\blankline Conditional attributes: \\indented{2}{canonicalUnitNormal\\tab{20}the canonical field is the same for all associates}")) (|unit?| (((|Boolean|) $) "\\spad{unit?(x)} tests whether \\spad{x} is a unit,{} \\spadignore{i.e.} is invertible.")) (|associates?| (((|Boolean|) $ $) "\\spad{associates?(x,y)} tests whether \\spad{x} and \\spad{y} are associates,{} \\spadignore{i.e.} differ by a unit factor.")) (|unitCanonical| (($ $) "\\spad{unitCanonical(x)} returns \\spad{unitNormal(x).canonical}.")) (|unitNormal| (((|Record| (|:| |unit| $) (|:| |canonical| $) (|:| |associate| $)) $) "\\spad{unitNormal(x)} tries to choose a canonical element from the associate class of \\spad{x}. The attribute canonicalUnitNormal,{} if asserted,{} means that the \"canonical\" element is the same across all associates of \\spad{x} if \\spad{unitNormal(x) = [u,c,a]} then \\spad{u*c = x},{} \\spad{a*u = 1}.")) (|exquo| (((|Union| $ "failed") $ $) "\\spad{exquo(a,b)} either returns an element \\spad{c} such that \\spad{c*b=a} or \"failed\" if no such element can be found."))) 
 NIL 
 NIL 
 (|IntegralDomain|) 
-((|constructor| (NIL "The category of commutative integral domains,{} \\spadignore{i.e.} commutative rings with no zero divisors. \\blankline Conditional attributes: \\indented{2}{canonicalUnitNormal\\tab{20}the canonical field is the same for all associates} \\indented{2}{canonicalsClosed\\tab{20}the product of two canonicals is itself canonical}")) (|unit?| (((|Boolean|) $) "\\spad{unit?(x)} tests whether \\spad{x} is a unit,{} \\spadignore{i.e.} is invertible.")) (|associates?| (((|Boolean|) $ $) "\\spad{associates?(x,y)} tests whether \\spad{x} and \\spad{y} are associates,{} \\spadignore{i.e.} differ by a unit factor.")) (|unitCanonical| (($ $) "\\spad{unitCanonical(x)} returns \\spad{unitNormal(x).canonical}.")) (|unitNormal| (((|Record| (|:| |unit| $) (|:| |canonical| $) (|:| |associate| $)) $) "\\spad{unitNormal(x)} tries to choose a canonical element from the associate class of \\spad{x}. The attribute canonicalUnitNormal,{} if asserted,{} means that the \"canonical\" element is the same across all associates of \\spad{x} if \\spad{unitNormal(x) = [u,c,a]} then \\spad{u*c = x},{} \\spad{a*u = 1}.")) (|exquo| (((|Union| $ "failed") $ $) "\\spad{exquo(a,b)} either returns an element \\spad{c} such that \\spad{c*b=a} or \"failed\" if no such element can be found."))) 
-((|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|constructor| (NIL "The category of commutative integral domains,{} \\spadignore{i.e.} commutative rings with no zero divisors. \\blankline Conditional attributes: \\indented{2}{canonicalUnitNormal\\tab{20}the canonical field is the same for all associates}")) (|unit?| (((|Boolean|) $) "\\spad{unit?(x)} tests whether \\spad{x} is a unit,{} \\spadignore{i.e.} is invertible.")) (|associates?| (((|Boolean|) $ $) "\\spad{associates?(x,y)} tests whether \\spad{x} and \\spad{y} are associates,{} \\spadignore{i.e.} differ by a unit factor.")) (|unitCanonical| (($ $) "\\spad{unitCanonical(x)} returns \\spad{unitNormal(x).canonical}.")) (|unitNormal| (((|Record| (|:| |unit| $) (|:| |canonical| $) (|:| |associate| $)) $) "\\spad{unitNormal(x)} tries to choose a canonical element from the associate class of \\spad{x}. The attribute canonicalUnitNormal,{} if asserted,{} means that the \"canonical\" element is the same across all associates of \\spad{x} if \\spad{unitNormal(x) = [u,c,a]} then \\spad{u*c = x},{} \\spad{a*u = 1}.")) (|exquo| (((|Union| $ "failed") $ $) "\\spad{exquo(a,b)} either returns an element \\spad{c} such that \\spad{c*b=a} or \"failed\" if no such element can be found."))) 
+((|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|ElementaryIntegration| R F) 
 ((|constructor| (NIL "This package provides functions for integration,{} limited integration,{} extended integration and the risch differential equation for elemntary functions.")) (|lfextlimint| (((|Union| (|Record| (|:| |ratpart| |#2|) (|:| |coeff| |#2|)) #1="failed") |#2| (|Symbol|) (|Kernel| |#2|) (|List| (|Kernel| |#2|))) "\\spad{lfextlimint(f,x,k,[k1,...,kn])} returns functions \\spad{[h, c]} such that \\spad{dh/dx = f - c dk/dx}. Value \\spad{h} is looked for in a field containing \\spad{f} and \\spad{k1},{}...,{}kn (the \\spad{ki}'s must be logs).")) (|lfintegrate| (((|IntegrationResult| |#2|) |#2| (|Symbol|)) "\\spad{lfintegrate(f, x)} = \\spad{g} such that \\spad{dg/dx = f}.")) (|lfinfieldint| (((|Union| |#2| "failed") |#2| (|Symbol|)) "\\spad{lfinfieldint(f, x)} returns a function \\spad{g} such that \\spad{dg/dx = f} if \\spad{g} exists,{} \"failed\" otherwise.")) (|lflimitedint| (((|Union| (|Record| (|:| |mainpart| |#2|) (|:| |limitedlogs| (|List| (|Record| (|:| |coeff| |#2|) (|:| |logand| |#2|))))) "failed") |#2| (|Symbol|) (|List| |#2|)) "\\spad{lflimitedint(f,x,[g1,...,gn])} returns functions \\spad{[h,[[ci, gi]]]} such that the \\spad{gi}'s are among \\spad{[g1,...,gn]},{} and \\spad{d(h+sum(ci log(gi)))/dx = f},{} if possible,{} \"failed\" otherwise.")) (|lfextendedint| (((|Union| (|Record| (|:| |ratpart| |#2|) (|:| |coeff| |#2|)) #1#) |#2| (|Symbol|) |#2|) "\\spad{lfextendedint(f, x, g)} returns functions \\spad{[h, c]} such that \\spad{dh/dx = f - cg},{} if (\\spad{h},{} \\spad{c}) exist,{} \"failed\" otherwise."))) 
@@ -1974,7 +1978,7 @@ NIL
 NIL 
 (|Interval| R) 
 ((|constructor| (NIL "\\indented{1}{+ Author: Mike Dewar} + Date Created: November 1996 + Date Last Updated: + Basic Functions: + Related Constructors: + Also See: + AMS Classifications: + Keywords: + References: + Description: + This domain is an implementation of interval arithmetic and transcendental + functions over intervals."))) 
-((|approximate| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|approximate| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|IntegerSolveLinearPolynomialEquation|) 
 ((|constructor| (NIL "This package provides the implementation for the \\spadfun{solveLinearPolynomialEquation} operation over the integers. It uses a lifting technique from the package GenExEuclid")) (|solveLinearPolynomialEquation| (((|Union| (|List| (|SparseUnivariatePolynomial| (|Integer|))) "failed") (|List| (|SparseUnivariatePolynomial| (|Integer|))) (|SparseUnivariatePolynomial| (|Integer|))) "\\spad{solveLinearPolynomialEquation([f1, ..., fn], g)} (where the \\spad{fi} are relatively prime to each other) returns a list of \\spad{ai} such that \\spad{g/prod fi = sum ai/fi} or returns \"failed\" if no such list of \\spad{ai}'s exists."))) 
@@ -2010,11 +2014,11 @@ NIL
 NIL 
 (|InnerPAdicInteger| |p| |unBalanced?|) 
 ((|constructor| (NIL "This domain implements Zp,{} the \\spad{p}-adic completion of the integers. This is an internal domain."))) 
-((|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|InnerPrimeField| |p|) 
 ((|constructor| (NIL "InnerPrimeField(\\spad{p}) implements the field with \\spad{p} elements. Note: argument \\spad{p} MUST be a prime (this domain does not check). See \\spadtype{PrimeField} for a domain that does check."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((|HasCategory| $ (QUOTE (|CharacteristicZero|))) (|HasCategory| $ (QUOTE (|CharacteristicNonZero|))) (|HasCategory| $ (QUOTE (|Finite|)))) 
 (|InternalPrintPackage|) 
 ((|constructor| (NIL "A package to print strings without line-feed nor carriage-return.")) (|iprint| (((|Void|) (|String|)) "\\axiom{iprint(\\spad{s})} prints \\axiom{\\spad{s}} at the current position of the cursor."))) 
@@ -2022,7 +2026,7 @@ NIL
 NIL 
 (|IntegrationResult| F) 
 ((|constructor| (NIL "If a function \\spad{f} has an elementary integral \\spad{g},{} then \\spad{g} can be written in the form \\spad{g = h + c1 log(u1) + c2 log(u2) + ... + cn log(un)} where \\spad{h},{} which is in the same field than \\spad{f},{} is called the rational part of the integral,{} and \\spad{c1 log(u1) + ... cn log(un)} is called the logarithmic part of the integral. This domain manipulates integrals represented in that form,{} by keeping both parts separately. The logs are not explicitly computed.")) (|differentiate| ((|#1| $ (|Symbol|)) "\\spad{differentiate(ir,x)} differentiates \\spad{ir} with respect to \\spad{x}") ((|#1| $ (|Mapping| |#1| |#1|)) "\\spad{differentiate(ir,D)} differentiates \\spad{ir} with respect to the derivation \\spad{D}.")) (|integral| (($ |#1| (|Symbol|)) "\\spad{integral(f,x)} returns the formal integral of \\spad{f} with respect to \\spad{x}") (($ |#1| |#1|) "\\spad{integral(f,x)} returns the formal integral of \\spad{f} with respect to \\spad{x}")) (|elem?| (((|Boolean|) $) "\\spad{elem?(ir)} tests if an integration result is elementary over F?")) (|notelem| (((|List| (|Record| (|:| |integrand| |#1|) (|:| |intvar| |#1|))) $) "\\spad{notelem(ir)} returns the non-elementary part of an integration result")) (|logpart| (((|List| (|Record| (|:| |scalar| (|Fraction| (|Integer|))) (|:| |coeff| (|SparseUnivariatePolynomial| |#1|)) (|:| |logand| (|SparseUnivariatePolynomial| |#1|)))) $) "\\spad{logpart(ir)} returns the logarithmic part of an integration result")) (|ratpart| ((|#1| $) "\\spad{ratpart(ir)} returns the rational part of an integration result")) (|mkAnswer| (($ |#1| (|List| (|Record| (|:| |scalar| (|Fraction| (|Integer|))) (|:| |coeff| (|SparseUnivariatePolynomial| |#1|)) (|:| |logand| (|SparseUnivariatePolynomial| |#1|)))) (|List| (|Record| (|:| |integrand| |#1|) (|:| |intvar| |#1|)))) "\\spad{mkAnswer(r,l,ne)} creates an integration result from a rational part \\spad{r},{} a logarithmic part \\spad{l},{} and a non-elementary part \\spad{ne}."))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #1=(|Symbol|)))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #1#)))) 
 (|IntegrationResultFunctions2| E F) 
 ((|constructor| (NIL "\\indented{1}{Internally used by the integration packages} Author: Manuel Bronstein Date Created: 1987 Date Last Updated: 12 August 1992 Keywords: integration.")) (|map| (((|Union| (|Record| (|:| |mainpart| |#2|) (|:| |limitedlogs| (|List| (|Record| (|:| |coeff| |#2|) (|:| |logand| |#2|))))) "failed") (|Mapping| |#2| |#1|) (|Union| (|Record| (|:| |mainpart| |#1|) (|:| |limitedlogs| (|List| (|Record| (|:| |coeff| |#1|) (|:| |logand| |#1|))))) "failed")) "\\spad{map(f,ufe)} \\undocumented") (((|Union| |#2| "failed") (|Mapping| |#2| |#1|) (|Union| |#1| "failed")) "\\spad{map(f,ue)} \\undocumented") (((|Union| (|Record| (|:| |ratpart| |#2|) (|:| |coeff| |#2|)) "failed") (|Mapping| |#2| |#1|) (|Union| (|Record| (|:| |ratpart| |#1|) (|:| |coeff| |#1|)) "failed")) "\\spad{map(f,ure)} \\undocumented") (((|IntegrationResult| |#2|) (|Mapping| |#2| |#1|) (|IntegrationResult| |#1|)) "\\spad{map(f,ire)} \\undocumented"))) 
@@ -2066,11 +2070,11 @@ NIL
 NIL 
 (|InnerSparseUnivariatePowerSeries| |Coef|) 
 ((|constructor| (NIL "InnerSparseUnivariatePowerSeries is an internal domain \\indented{2}{used for creating sparse Taylor and Laurent series.}")) (|cAcsch| (($ $) "\\spad{cAcsch(f)} computes the inverse hyperbolic cosecant of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cAsech| (($ $) "\\spad{cAsech(f)} computes the inverse hyperbolic secant of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cAcoth| (($ $) "\\spad{cAcoth(f)} computes the inverse hyperbolic cotangent of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cAtanh| (($ $) "\\spad{cAtanh(f)} computes the inverse hyperbolic tangent of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cAcosh| (($ $) "\\spad{cAcosh(f)} computes the inverse hyperbolic cosine of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cAsinh| (($ $) "\\spad{cAsinh(f)} computes the inverse hyperbolic sine of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cCsch| (($ $) "\\spad{cCsch(f)} computes the hyperbolic cosecant of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cSech| (($ $) "\\spad{cSech(f)} computes the hyperbolic secant of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cCoth| (($ $) "\\spad{cCoth(f)} computes the hyperbolic cotangent of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cTanh| (($ $) "\\spad{cTanh(f)} computes the hyperbolic tangent of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cCosh| (($ $) "\\spad{cCosh(f)} computes the hyperbolic cosine of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cSinh| (($ $) "\\spad{cSinh(f)} computes the hyperbolic sine of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cAcsc| (($ $) "\\spad{cAcsc(f)} computes the arccosecant of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cAsec| (($ $) "\\spad{cAsec(f)} computes the arcsecant of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cAcot| (($ $) "\\spad{cAcot(f)} computes the arccotangent of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cAtan| (($ $) "\\spad{cAtan(f)} computes the arctangent of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cAcos| (($ $) "\\spad{cAcos(f)} computes the arccosine of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cAsin| (($ $) "\\spad{cAsin(f)} computes the arcsine of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cCsc| (($ $) "\\spad{cCsc(f)} computes the cosecant of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cSec| (($ $) "\\spad{cSec(f)} computes the secant of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cCot| (($ $) "\\spad{cCot(f)} computes the cotangent of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cTan| (($ $) "\\spad{cTan(f)} computes the tangent of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cCos| (($ $) "\\spad{cCos(f)} computes the cosine of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cSin| (($ $) "\\spad{cSin(f)} computes the sine of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cLog| (($ $) "\\spad{cLog(f)} computes the logarithm of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cExp| (($ $) "\\spad{cExp(f)} computes the exponential of the power series \\spad{f}. For use when the coefficient ring is commutative.")) (|cRationalPower| (($ $ (|Fraction| (|Integer|))) "\\spad{cRationalPower(f,r)} computes \\spad{f^r}. For use when the coefficient ring is commutative.")) (|cPower| (($ $ |#1|) "\\spad{cPower(f,r)} computes \\spad{f^r},{} where \\spad{f} has constant coefficient 1. For use when the coefficient ring is commutative.")) (|integrate| (($ $) "\\spad{integrate(f(x))} returns an anti-derivative of the power series \\spad{f(x)} with constant coefficient 0. Warning: function does not check for a term of degree \\spad{-1}.")) (|seriesToOutputForm| (((|OutputForm|) (|Stream| (|Record| (|:| |k| (|Integer|)) (|:| |c| |#1|))) (|Reference| (|OrderedCompletion| (|Integer|))) (|Symbol|) |#1| (|Fraction| (|Integer|))) "\\spad{seriesToOutputForm(st,refer,var,cen,r)} prints the series \\spad{f((var - cen)^r)}.")) (|iCompose| (($ $ $) "\\spad{iCompose(f,g)} returns \\spad{f(g(x))}. This is an internal function which should only be called for Taylor series \\spad{f(x)} and \\spad{g(x)} such that the constant coefficient of \\spad{g(x)} is zero.")) (|taylorQuoByVar| (($ $) "\\spad{taylorQuoByVar(a0 + a1 x + a2 x**2 + ...)} returns \\spad{a1 + a2 x + a3 x**2 + ...}")) (|iExquo| (((|Union| $ "failed") $ $ (|Boolean|)) "\\spad{iExquo(f,g,taylor?)} is the quotient of the power series \\spad{f} and \\spad{g}. If \\spad{taylor?} is \\spad{true},{} then we must have \\spad{order(f) >= order(g)}.")) (|multiplyCoefficients| (($ (|Mapping| |#1| (|Integer|)) $) "\\spad{multiplyCoefficients(fn,f)} returns the series \\spad{sum(fn(n) * an * x^n,n = n0..)},{} where \\spad{f} is the series \\spad{sum(an * x^n,n = n0..)}.")) (|monomial?| (((|Boolean|) $) "\\spad{monomial?(f)} tests if \\spad{f} is a single monomial.")) (|series| (($ (|Stream| (|Record| (|:| |k| (|Integer|)) (|:| |c| |#1|)))) "\\spad{series(st)} creates a series from a stream of non-zero terms,{} where a term is an exponent-coefficient pair. The terms in the stream should be ordered by increasing order of exponents.")) (|getStream| (((|Stream| (|Record| (|:| |k| (|Integer|)) (|:| |c| |#1|))) $) "\\spad{getStream(f)} returns the stream of terms representing the series \\spad{f}.")) (|getRef| (((|Reference| (|OrderedCompletion| (|Integer|))) $) "\\spad{getRef(f)} returns a reference containing the order to which the terms of \\spad{f} have been computed.")) (|makeSeries| (($ (|Reference| (|OrderedCompletion| (|Integer|))) (|Stream| (|Record| (|:| |k| (|Integer|)) (|:| |c| |#1|)))) "\\spad{makeSeries(refer,str)} creates a power series from the reference \\spad{refer} and the stream \\spad{str}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|))) 
 ((|HasCategory| |#1| (QUOTE (|Algebra| (|Fraction| #1=(|Integer|))))) #2=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (OR #3=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #2#) #3# (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (AND (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #4=(|Symbol|)))) #5=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #6=(|devaluate| |#1|) #7=(QUOTE #1#) #6#)))) #5# (|HasCategory| #1# (QUOTE (|SemiGroup|))) (|HasCategory| |#1| (QUOTE (|Field|))) (AND #8=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #6# #6# #7#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #6# (QUOTE #4#))))) #8#) 
 (|InnerTaylorSeries| |Coef|) 
 ((|constructor| (NIL "Internal package for dense Taylor series. This is an internal Taylor series type in which Taylor series are represented by a \\spadtype{Stream} of \\spadtype{Ring} elements. For univariate series,{} the \\spad{Stream} elements are the Taylor coefficients. For multivariate series,{} the \\spad{n}th Stream element is a form of degree \\spad{n} in the power series variables.")) (* (($ $ (|Integer|)) "\\spad{x*i} returns the product of integer \\spad{i} and the series \\spad{x}.")) (|order| (((|NonNegativeInteger|) $ (|NonNegativeInteger|)) "\\spad{order(x,n)} returns the minimum of \\spad{n} and the order of \\spad{x}.") (((|NonNegativeInteger|) $) "\\spad{order(x)} returns the order of a power series \\spad{x},{} \\indented{1}{\\spadignore{i.e.} the degree of the first non-zero term of the series.}")) (|pole?| (((|Boolean|) $) "\\spad{pole?(x)} tests if the series \\spad{x} has a pole. \\indented{1}{Note: this is \\spad{false} when \\spad{x} is a Taylor series.}")) (|series| (($ (|Stream| |#1|)) "\\spad{series(s)} creates a power series from a stream of \\indented{1}{ring elements.} \\indented{1}{For univariate series types,{} the stream \\spad{s} should be a stream} \\indented{1}{of Taylor coefficients. For multivariate series types,{} the} \\indented{1}{stream \\spad{s} should be a stream of forms the \\spad{n}th element} \\indented{1}{of which is a} \\indented{1}{form of degree \\spad{n} in the power series variables.}")) (|coefficients| (((|Stream| |#1|) $) "\\spad{coefficients(x)} returns a stream of ring elements. \\indented{1}{When \\spad{x} is a univariate series,{} this is a stream of Taylor} \\indented{1}{coefficients. When \\spad{x} is a multivariate series,{} the} \\indented{1}{\\spad{n}th element of the stream is a form of} \\indented{1}{degree \\spad{n} in the power series variables.}"))) 
-(((|commutative| "*") |has| |#1| . #1=((|IntegralDomain|))) (|noZeroDivisors| |has| |#1| . #1#) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| . #1=((|IntegralDomain|))) (|noZeroDivisors| |has| |#1| . #1#)) 
 ((|HasCategory| |#1| (QUOTE (|IntegralDomain|)))) 
 (|InternalTypeForm|) 
 ((|constructor| (NIL "This domain provides representations for internal type form.")) (|mappingMode| (($ $ (|List| $)) "\\spad{mappingMode(r,ts)} returns a mapping mode with return mode \\spad{r},{} and parameter modes \\spad{ts}.")) (|categoryMode| (($) "\\spad{categoryMode} is a constant mode denoting Category.")) (|voidMode| (($) "\\spad{voidMode} is a constant mode denoting Void.")) (|noValueMode| (($) "\\spad{noValueMode} is a constant mode that indicates that the value of an expression is to be ignored.")) (|jokerMode| (($) "\\spad{jokerMode} is a constant that stands for any mode in a type inference context"))) 
@@ -2106,7 +2110,7 @@ NIL
 NIL 
 (|AssociatedJordanAlgebra| R A) 
 ((|constructor| (NIL "\\indented{1}{AssociatedJordanAlgebra takes an algebra \\spad{A} and uses \\spadfun{*\\$A}} \\indented{1}{to define the new multiplications \\spad{a*b := (a *\\$A b + b *\\$A a)/2}} \\indented{1}{(anticommutator).} \\indented{1}{The usual notation \\spad{{a,b}_+} cannot be used due to} \\indented{1}{restrictions in the current language.} \\indented{1}{This domain only gives a Jordan algebra if the} \\indented{1}{Jordan-identity \\spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} holds} \\indented{1}{for all \\spad{a},{}\\spad{b},{}\\spad{c} in \\spad{A}.} \\indented{1}{This relation can be checked by} \\indented{1}{\\spadfun{jordanAdmissible?()\\$A}.} \\blankline If the underlying algebra is of type \\spadtype{FramedNonAssociativeAlgebra(R)} (\\spadignore{i.e.} a non associative algebra over \\spad{R} which is a free \\spad{R}-module of finite rank,{} together with a fixed \\spad{R}-module basis),{} then the same is \\spad{true} for the associated Jordan algebra. Moreover,{} if the underlying algebra is of type \\spadtype{FiniteRankNonAssociativeAlgebra(R)} (\\spadignore{i.e.} a non associative algebra over \\spad{R} which is a free \\spad{R}-module of finite rank),{} then the same \\spad{true} for the associated Jordan algebra.")) (|coerce| (($ |#2|) "\\spad{coerce(a)} coerces the element \\spad{a} of the algebra \\spad{A} to an element of the Jordan algebra \\spadtype{AssociatedJordanAlgebra}(\\spad{R},{}A)."))) 
-((|unitsKnown| OR (|and| (|has| |#2| (|FiniteRankNonAssociativeAlgebra| |#1|)) #1=(|has| |#1| (|IntegralDomain|))) (AND (|has| |#2| (|FramedNonAssociativeAlgebra| |#1|)) #1#)) (|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 ((OR #1=(|HasCategory| |#2| (|%list| (QUOTE |FiniteRankNonAssociativeAlgebra|) #2=(|devaluate| |#1|))) #3=(|HasCategory| |#2| (|%list| (QUOTE |FramedNonAssociativeAlgebra|) #2#))) #3# (AND (|HasCategory| |#1| (QUOTE (|Field|))) #3#) (OR (AND #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (AND #4# #3#)) #1#) 
 (|JVMBytecode|) 
 ((|constructor| (NIL "This is the datatype for the JVM bytecodes."))) 
@@ -2178,7 +2182,7 @@ NIL
 NIL 
 (|LocalAlgebra| A R S) 
 ((|constructor| (NIL "LocalAlgebra produces the localization of an algebra,{} \\spadignore{i.e.} fractions whose numerators come from some \\spad{R} algebra.")) (|denom| ((|#3| $) "\\spad{denom x} returns the denominator of \\spad{x}.")) (|numer| ((|#1| $) "\\spad{numer x} returns the numerator of \\spad{x}.")) (/ (($ |#1| |#3|) "\\spad{a / d} divides the element \\spad{a} by \\spad{d}.") (($ $ |#3|) "\\spad{x / d} divides the element \\spad{x} by \\spad{d}."))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|OrderedRing|)))) 
 (|LeftAlgebra&| S R) 
 ((|constructor| (NIL "The category of all left algebras over an arbitrary ring.")) (|coerce| (($ |#2|) "\\spad{coerce(r)} returns \\spad{r} * 1 where 1 is the identity of the left algebra."))) 
@@ -2186,7 +2190,7 @@ NIL
 NIL 
 (|LeftAlgebra| R) 
 ((|constructor| (NIL "The category of all left algebras over an arbitrary ring.")) (|coerce| (($ |#1|) "\\spad{coerce(r)} returns \\spad{r} * 1 where 1 is the identity of the left algebra."))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|LaplaceTransform| R F) 
 ((|constructor| (NIL "This package computes the forward Laplace Transform.")) (|laplace| ((|#2| |#2| (|Symbol|) (|Symbol|)) "\\spad{laplace(f, t, s)} returns the Laplace transform of \\spad{f(t)} using \\spad{s} as the new variable. This is \\spad{integral(exp(-s*t)*f(t), t = 0..\\%plusInfinity)}. Returns the formal object \\spad{laplace(f, t, s)} if it cannot compute the transform."))) 
@@ -2194,7 +2198,7 @@ NIL
 NIL 
 (|LaurentPolynomial| R UP) 
 ((|constructor| (NIL "\\indented{1}{Univariate polynomials with negative and positive exponents.} Author: Manuel Bronstein Date Created: May 1988 Date Last Updated: 26 Apr 1990")) (|separate| (((|Record| (|:| |polyPart| $) (|:| |fracPart| (|Fraction| |#2|))) (|Fraction| |#2|)) "\\spad{separate(x)} \\undocumented")) (|monomial| (($ |#1| (|Integer|)) "\\spad{monomial(x,n)} \\undocumented")) (|coefficient| ((|#1| $ (|Integer|)) "\\spad{coefficient(x,n)} \\undocumented")) (|trailingCoefficient| ((|#1| $) "\\spad{trailingCoefficient }\\undocumented")) (|leadingCoefficient| ((|#1| $) "\\spad{leadingCoefficient }\\undocumented")) (|reductum| (($ $) "\\spad{reductum(x)} \\undocumented")) (|order| (((|Integer|) $) "\\spad{order(x)} \\undocumented")) (|degree| (((|Integer|) $) "\\spad{degree(x)} \\undocumented")) (|monomial?| (((|Boolean|) $) "\\spad{monomial?(x)} \\undocumented"))) 
-((|leftUnitary| . T) (|rightUnitary| . T) ((|commutative| "*") . T) (|noZeroDivisors| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") . T) (|noZeroDivisors| . T)) 
 ((|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #1=(|Symbol|)))) (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #1#))) (|HasCategory| |#2| (QUOTE (|DifferentialRing|))) (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|Field|))) (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #2=(|Integer|))))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #2#)))) 
 (|LazardSetSolvingPackage| R E V P TS ST) 
 ((|constructor| (NIL "A package for solving polynomial systems by means of Lazard triangular sets [1]. This package provides two operations. One for solving in the sense of the regular zeros,{} and the other for solving in the sense of the Zariski closure. Both produce square-free regular sets. Moreover,{} the decompositions do not contain any redundant component. However,{} only zero-dimensional regular sets are normalized,{} since normalization may be time consumming in positive dimension. The decomposition process is that of [2].\\newline References : \\indented{1}{[1] \\spad{D}. LAZARD \"A new method for solving algebraic systems of} \\indented{5}{positive dimension\" Discr. App. Math. 33:147-160,{}1991} \\indented{1}{[2] \\spad{M}. MORENO MAZA \"A new algorithm for computing triangular} \\indented{5}{decomposition of algebraic varieties\" NAG Tech. Rep. 4/98.}")) (|zeroSetSplit| (((|List| |#6|) (|List| |#4|) (|Boolean|)) "\\axiom{zeroSetSplit(lp,{}clos?)} has the same specifications as \\axiomOpFrom{zeroSetSplit(lp,{}clos?)}{RegularTriangularSetCategory}.")) (|normalizeIfCan| ((|#6| |#6|) "\\axiom{normalizeIfCan(ts)} returns \\axiom{ts} in an normalized shape if \\axiom{ts} is zero-dimensional."))) 
@@ -2209,8 +2213,8 @@ NIL
 NIL 
 NIL 
 (|LieExponentials| |VarSet| R |Order|) 
-((|constructor| (NIL "Management of the Lie Group associated with a free nilpotent Lie algebra. Every Lie bracket with length greater than \\axiom{Order} are assumed to be null. The implementation inherits from the \\spadtype{XPBWPolynomial} domain constructor: Lyndon coordinates are exponential coordinates of the second kind. \\newline Author: Michel Petitot (petitot@lifl.fr).")) (|identification| (((|List| (|Equation| |#2|)) $ $) "\\axiom{identification(\\spad{g},{}\\spad{h})} returns the list of equations \\axiom{g_i = h_i},{} where \\axiom{g_i} (resp. \\axiom{h_i}) are exponential coordinates of \\axiom{\\spad{g}} (resp. \\axiom{\\spad{h}}).")) (|LyndonCoordinates| (((|List| (|Record| (|:| |k| (|LyndonWord| |#1|)) (|:| |c| |#2|))) $) "\\axiom{LyndonCoordinates(\\spad{g})} returns the exponential coordinates of \\axiom{\\spad{g}}.")) (|LyndonBasis| (((|List| (|LiePolynomial| |#1| |#2|)) (|List| |#1|)) "\\axiom{LyndonBasis(lv)} returns the Lyndon basis of the nilpotent free Lie algebra.")) (|varList| (((|List| |#1|) $) "\\axiom{varList(\\spad{g})} returns the list of variables of \\axiom{\\spad{g}}.")) (|mirror| (($ $) "\\axiom{mirror(\\spad{g})} is the mirror of the internal representation of \\axiom{\\spad{g}}.")) (|coerce| (((|XPBWPolynomial| |#1| |#2|) $) "\\axiom{coerce(\\spad{g})} returns the internal representation of \\axiom{\\spad{g}}.") (((|XDistributedPolynomial| |#1| |#2|) $) "\\axiom{coerce(\\spad{g})} returns the internal representation of \\axiom{\\spad{g}}.")) (|ListOfTerms| (((|List| (|Record| (|:| |k| (|PoincareBirkhoffWittLyndonBasis| |#1|)) (|:| |c| |#2|))) $) "\\axiom{ListOfTerms(\\spad{p})} returns the internal representation of \\axiom{\\spad{p}}.")) (|log| (((|LiePolynomial| |#1| |#2|) $) "\\axiom{log(\\spad{p})} returns the logarithm of \\axiom{\\spad{p}}.")) (|exp| (($ (|LiePolynomial| |#1| |#2|)) "\\axiom{exp(\\spad{p})} returns the exponential of \\axiom{\\spad{p}}."))) 
-((|unitsKnown| . T)) 
+((|constructor| (NIL "Management of the Lie Group associated with a free nilpotent Lie algebra. Every Lie bracket with length greater than \\axiom{Order} are assumed to be null. The implementation inherits from the \\spadtype{XPBWPolynomial} domain constructor: Lyndon coordinates are exponential coordinates of the second kind. \\newline Author: Michel Petitot (petitot@lifl.fr).")) (|identification| (((|List| (|Equation| |#2|)) $ $) "\\axiom{identification(\\spad{g},{}\\spad{h})} returns the list of equations \\axiom{g_i = h_i},{} where \\axiom{g_i} (resp. \\axiom{h_i}) are exponential coordinates of \\axiom{\\spad{g}} (resp. \\axiom{\\spad{h}}).")) (|LyndonCoordinates| (((|List| (|Record| (|:| |k| (|LyndonWord| |#1|)) (|:| |c| |#2|))) $) "\\axiom{LyndonCoordinates(\\spad{g})} returns the exponential coordinates of \\axiom{\\spad{g}}.")) (|LyndonBasis| (((|List| (|LiePolynomial| |#1| |#2|)) (|List| |#1|)) "\\axiom{LyndonBasis(lv)} returns the Lyndon basis of the nilpotent free Lie algebra.")) (|varList| (((|List| |#1|) $) "\\axiom{varList(\\spad{g})} returns the list of variables of \\axiom{\\spad{g}}.")) (|mirror| (($ $) "\\axiom{mirror(\\spad{g})} is the mirror of the internal representation of \\axiom{\\spad{g}}.")) (|ListOfTerms| (((|List| (|Record| (|:| |k| (|PoincareBirkhoffWittLyndonBasis| |#1|)) (|:| |c| |#2|))) $) "\\axiom{ListOfTerms(\\spad{p})} returns the internal representation of \\axiom{\\spad{p}}.")) (|log| (((|LiePolynomial| |#1| |#2|) $) "\\axiom{log(\\spad{p})} returns the logarithm of \\axiom{\\spad{p}}.")) (|exp| (($ (|LiePolynomial| |#1| |#2|)) "\\axiom{exp(\\spad{p})} returns the exponential of \\axiom{\\spad{p}}."))) 
+NIL 
 NIL 
 (|LexTriangularPackage| R |ls|) 
 ((|constructor| (NIL "A package for solving polynomial systems with finitely many solutions. The decompositions are given by means of regular triangular sets. The computations use lexicographical Groebner bases. The main operations are \\axiomOpFrom{lexTriangular}{LexTriangularPackage} and \\axiomOpFrom{squareFreeLexTriangular}{LexTriangularPackage}. The second one provide decompositions by means of square-free regular triangular sets. Both are based on the {\\em lexTriangular} method described in [1]. They differ from the algorithm described in [2] by the fact that multiciplities of the roots are not kept. With the \\axiomOpFrom{squareFreeLexTriangular}{LexTriangularPackage} operation all multiciplities are removed. With the other operation some multiciplities may remain. Both operations admit an optional argument to produce normalized triangular sets. \\newline")) (|zeroSetSplit| (((|List| (|SquareFreeRegularTriangularSet| |#1| (|IndexedExponents| (|OrderedVariableList| |#2|)) (|OrderedVariableList| |#2|) (|NewSparseMultivariatePolynomial| |#1| (|OrderedVariableList| |#2|)))) (|List| (|NewSparseMultivariatePolynomial| |#1| (|OrderedVariableList| |#2|))) (|Boolean|)) "\\axiom{zeroSetSplit(lp,{} norm?)} decomposes the variety associated with \\axiom{lp} into square-free regular chains. Thus a point belongs to this variety iff it is a regular zero of a regular set in in the output. Note that \\axiom{lp} needs to generate a zero-dimensional ideal. If \\axiom{norm?} is \\axiom{\\spad{true}} then the regular sets are normalized.") (((|List| (|RegularChain| |#1| |#2|)) (|List| (|NewSparseMultivariatePolynomial| |#1| (|OrderedVariableList| |#2|))) (|Boolean|)) "\\axiom{zeroSetSplit(lp,{} norm?)} decomposes the variety associated with \\axiom{lp} into regular chains. Thus a point belongs to this variety iff it is a regular zero of a regular set in in the output. Note that \\axiom{lp} needs to generate a zero-dimensional ideal. If \\axiom{norm?} is \\axiom{\\spad{true}} then the regular sets are normalized.")) (|squareFreeLexTriangular| (((|List| (|SquareFreeRegularTriangularSet| |#1| (|IndexedExponents| (|OrderedVariableList| |#2|)) (|OrderedVariableList| |#2|) (|NewSparseMultivariatePolynomial| |#1| (|OrderedVariableList| |#2|)))) (|List| (|NewSparseMultivariatePolynomial| |#1| (|OrderedVariableList| |#2|))) (|Boolean|)) "\\axiom{squareFreeLexTriangular(base,{} norm?)} decomposes the variety associated with \\axiom{base} into square-free regular chains. Thus a point belongs to this variety iff it is a regular zero of a regular set in in the output. Note that \\axiom{base} needs to be a lexicographical Groebner basis of a zero-dimensional ideal. If \\axiom{norm?} is \\axiom{\\spad{true}} then the regular sets are normalized.")) (|lexTriangular| (((|List| (|RegularChain| |#1| |#2|)) (|List| (|NewSparseMultivariatePolynomial| |#1| (|OrderedVariableList| |#2|))) (|Boolean|)) "\\axiom{lexTriangular(base,{} norm?)} decomposes the variety associated with \\axiom{base} into regular chains. Thus a point belongs to this variety iff it is a regular zero of a regular set in in the output. Note that \\axiom{base} needs to be a lexicographical Groebner basis of a zero-dimensional ideal. If \\axiom{norm?} is \\axiom{\\spad{true}} then the regular sets are normalized.")) (|groebner| (((|List| (|NewSparseMultivariatePolynomial| |#1| (|OrderedVariableList| |#2|))) (|List| (|NewSparseMultivariatePolynomial| |#1| (|OrderedVariableList| |#2|)))) "\\axiom{groebner(lp)} returns the lexicographical Groebner basis of \\axiom{lp}. If \\axiom{lp} generates a zero-dimensional ideal then the {\\em FGLM} strategy is used,{} otherwise the {\\em Sugar} strategy is used.")) (|fglmIfCan| (((|Union| (|List| (|NewSparseMultivariatePolynomial| |#1| (|OrderedVariableList| |#2|))) "failed") (|List| (|NewSparseMultivariatePolynomial| |#1| (|OrderedVariableList| |#2|)))) "\\axiom{fglmIfCan(lp)} returns the lexicographical Groebner basis of \\axiom{lp} by using the {\\em FGLM} strategy,{} if \\axiom{zeroDimensional?(lp)} holds .")) (|zeroDimensional?| (((|Boolean|) (|List| (|NewSparseMultivariatePolynomial| |#1| (|OrderedVariableList| |#2|)))) "\\axiom{zeroDimensional?(lp)} returns \\spad{true} iff \\axiom{lp} generates a zero-dimensional ideal \\spad{w}.\\spad{r}.\\spad{t}. the variables involved in \\axiom{lp}."))) 
@@ -2234,15 +2238,15 @@ NIL
 ((AND (|HasCategory| #1=(|Record| (|:| |key| #2=(|String|)) (|:| |entry| #3=(|Any|))) (QUOTE (|Evalable| #1#))) #4=(|HasCategory| #1# #5=(QUOTE (|SetCategory|)))) (OR #6=(|HasCategory| #3# #5#) #4#) (OR #7=(|HasCategory| #3# #8=(QUOTE (|BasicType|))) #6# #9=(|HasCategory| #1# #8#) #4#) (OR #10=(|HasCategory| #1# #11=(QUOTE (|CoercibleTo| (|OutputForm|)))) #12=(|HasCategory| #3# #11#)) (|HasCategory| #1# (QUOTE (|ConvertibleTo| (|InputForm|)))) (AND (|HasCategory| #3# (QUOTE (|Evalable| #3#))) #6#) #9# (|HasCategory| #2# (QUOTE (|OrderedSet|))) #7# (OR #7# #9#) #6# #12# #10# #4# (AND #13=(|HasCategory| $ (QUOTE (|FiniteAggregate| #1#))) #9#) #13# (AND (|HasCategory| $ (QUOTE (|FiniteAggregate| #3#))) #7#) (|HasCategory| $ (QUOTE (|ShallowlyMutableAggregate| #3#)))) 
 (|AssociatedLieAlgebra| R A) 
 ((|constructor| (NIL "AssociatedLieAlgebra takes an algebra \\spad{A} and uses \\spadfun{*\\$A} to define the Lie bracket \\spad{a*b := (a *\\$A b - b *\\$A a)} (commutator). Note that the notation \\spad{[a,b]} cannot be used due to restrictions of the current compiler. This domain only gives a Lie algebra if the Jacobi-identity \\spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} holds for all \\spad{a},{}\\spad{b},{}\\spad{c} in \\spad{A}. This relation can be checked by \\spad{lieAdmissible?()\\$A}. \\blankline If the underlying algebra is of type \\spadtype{FramedNonAssociativeAlgebra(R)} (\\spadignore{i.e.} a non associative algebra over \\spad{R} which is a free \\spad{R}-module of finite rank,{} together with a fixed \\spad{R}-module basis),{} then the same is \\spad{true} for the associated Lie algebra. Also,{} if the underlying algebra is of type \\spadtype{FiniteRankNonAssociativeAlgebra(R)} (\\spadignore{i.e.} a non associative algebra over \\spad{R} which is a free \\spad{R}-module of finite rank),{} then the same is \\spad{true} for the associated Lie algebra.")) (|coerce| (($ |#2|) "\\spad{coerce(a)} coerces the element \\spad{a} of the algebra \\spad{A} to an element of the Lie algebra \\spadtype{AssociatedLieAlgebra}(\\spad{R},{}A)."))) 
-((|unitsKnown| OR (|and| (|has| |#2| (|FiniteRankNonAssociativeAlgebra| |#1|)) #1=(|has| |#1| (|IntegralDomain|))) (AND (|has| |#2| (|FramedNonAssociativeAlgebra| |#1|)) #1#)) (|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 ((OR #1=(|HasCategory| |#2| (|%list| (QUOTE |FiniteRankNonAssociativeAlgebra|) #2=(|devaluate| |#1|))) #3=(|HasCategory| |#2| (|%list| (QUOTE |FramedNonAssociativeAlgebra|) #2#))) #3# (AND (|HasCategory| |#1| (QUOTE (|Field|))) #3#) (OR (AND #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (AND #4# #3#)) #1#) 
 (|LieAlgebra&| S R) 
-((|constructor| (NIL "\\axiom{JacobiIdentity} means that \\axiom{[\\spad{x},{}[\\spad{y},{}\\spad{z}]]+[\\spad{y},{}[\\spad{z},{}\\spad{x}]]+[\\spad{z},{}[\\spad{x},{}\\spad{y}]] = 0} holds.")) (/ (($ $ |#2|) "\\axiom{x/r} returns the division of \\axiom{\\spad{x}} by \\axiom{\\spad{r}}.")) (|construct| (($ $ $) "\\axiom{construct(\\spad{x},{}\\spad{y})} returns the Lie bracket of \\axiom{\\spad{x}} and \\axiom{\\spad{y}}."))) 
+((|constructor| (NIL "The category of Lie Algebras. It is used by the following domains of non-commutative algebra: \\axiomType{LiePolynomial} and \\axiomType{XPBWPolynomial}. \\newline Author : Michel Petitot (petitot@lifl.fr).")) (/ (($ $ |#2|) "\\axiom{x/r} returns the division of \\axiom{\\spad{x}} by \\axiom{\\spad{r}}.")) (|construct| (($ $ $) "\\axiom{construct(\\spad{x},{}\\spad{y})} returns the Lie bracket of \\axiom{\\spad{x}} and \\axiom{\\spad{y}}."))) 
 NIL 
 ((|HasCategory| |#2| (QUOTE (|Field|)))) 
 (|LieAlgebra| R) 
-((|constructor| (NIL "\\axiom{JacobiIdentity} means that \\axiom{[\\spad{x},{}[\\spad{y},{}\\spad{z}]]+[\\spad{y},{}[\\spad{z},{}\\spad{x}]]+[\\spad{z},{}[\\spad{x},{}\\spad{y}]] = 0} holds.")) (/ (($ $ |#1|) "\\axiom{x/r} returns the division of \\axiom{\\spad{x}} by \\axiom{\\spad{r}}.")) (|construct| (($ $ $) "\\axiom{construct(\\spad{x},{}\\spad{y})} returns the Lie bracket of \\axiom{\\spad{x}} and \\axiom{\\spad{y}}."))) 
-((|JacobiIdentity| . T) (|NullSquare| . T) (|leftUnitary| . T) (|rightUnitary| . T)) 
+((|constructor| (NIL "The category of Lie Algebras. It is used by the following domains of non-commutative algebra: \\axiomType{LiePolynomial} and \\axiomType{XPBWPolynomial}. \\newline Author : Michel Petitot (petitot@lifl.fr).")) (/ (($ $ |#1|) "\\axiom{x/r} returns the division of \\axiom{\\spad{x}} by \\axiom{\\spad{r}}.")) (|construct| (($ $ $) "\\axiom{construct(\\spad{x},{}\\spad{y})} returns the Lie bracket of \\axiom{\\spad{x}} and \\axiom{\\spad{y}}."))) 
+NIL 
 NIL 
 (|PowerSeriesLimitPackage| R FE) 
 ((|constructor| (NIL "PowerSeriesLimitPackage implements limits of expressions in one or more variables as one of the variables approaches a limiting value. Included are two-sided limits,{} left- and right- hand limits,{} and limits at plus or minus infinity.")) (|complexLimit| (((|Union| (|OnePointCompletion| |#2|) "failed") |#2| (|Equation| (|OnePointCompletion| |#2|))) "\\spad{complexLimit(f(x),x = a)} computes the complex limit \\spad{lim(x -> a,f(x))}.")) (|limit| (((|Union| (|OrderedCompletion| |#2|) #1="failed") |#2| (|Equation| |#2|) (|String|)) "\\spad{limit(f(x),x=a,\"left\")} computes the left hand real limit \\spad{lim(x -> a-,f(x))}; \\spad{limit(f(x),x=a,\"right\")} computes the right hand real limit \\spad{lim(x -> a+,f(x))}.") (((|Union| (|OrderedCompletion| |#2|) (|Record| (|:| |leftHandLimit| (|Union| (|OrderedCompletion| |#2|) #1#)) (|:| |rightHandLimit| (|Union| (|OrderedCompletion| |#2|) #1#))) "failed") |#2| (|Equation| (|OrderedCompletion| |#2|))) "\\spad{limit(f(x),x = a)} computes the real limit \\spad{lim(x -> a,f(x))}."))) 
@@ -2262,7 +2266,7 @@ NIL
 ((|not| #1=(|HasCategory| |#1| (QUOTE (|Field|)))) #1#) 
 (|LinearElement| K B) 
 ((|constructor| (NIL "A simple data structure for elements that form a vector space of finite dimension over a given field,{} with a given symbolic basis.")) (|coordinates| (((|Vector| |#1|) $) "\\spad{coordinates x} returns the coordinates of the linear element with respect to the basis \\spad{B}.")) (|linearElement| (($ (|List| |#1|)) "\\spad{linearElement [x1,..,xn]} returns a linear element \\indented{1}{with coordinates \\spad{[x1,..,xn]} with respect to} the basis elements \\spad{B}."))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 ((AND (|HasCategory| |#1| #1=(QUOTE (|SetCategory|))) (|HasCategory| (|LinearBasis| |#2|) #1#))) 
 (|LinearlyExplicitRingOver| R) 
 ((|constructor| (NIL "An extension of left-module with an explicit linear dependence test.")) (|reducedSystem| (((|Record| (|:| |mat| (|Matrix| |#1|)) (|:| |vec| (|Vector| |#1|))) (|Matrix| $) (|Vector| $)) "\\spad{reducedSystem(A, v)} returns a matrix \\spad{B} and a vector \\spad{w} such that \\spad{A x = v} and \\spad{B x = w} have the same solutions in \\spad{R}.") (((|Matrix| |#1|) (|Matrix| $)) "\\spad{reducedSystem(A)} returns a matrix \\spad{B} such that \\spad{A x = 0} and \\spad{B x = 0} have the same solutions in \\spad{R}.")) (|leftReducedSystem| (((|Record| (|:| |mat| (|Matrix| |#1|)) (|:| |vec| (|Vector| |#1|))) (|Vector| $) $) "\\spad{reducedSystem([v1,...,vn],u)} returns a matrix \\spad{M} with coefficients in \\spad{R} and a vector \\spad{w} such that the system of equations \\spad{c1*v1 + ... + cn*vn = u} has the same solution as \\spad{c * M = w} where \\spad{c} is the row vector \\spad{[c1,...cn]}.") (((|Matrix| |#1|) (|Vector| $)) "\\spad{leftReducedSystem [v1,...,vn]} returns a matrix \\spad{M} with coefficients in \\spad{R} such that the system of equations \\spad{c1*v1 + ... + cn*vn = 0\\$\\%} has the same solution as \\spad{c * M = 0} where \\spad{c} is the row vector \\spad{[c1,...cn]}."))) 
@@ -2270,7 +2274,7 @@ NIL
 NIL 
 (|LinearForm| K B) 
 ((|constructor| (NIL "A simple data structure for linear forms on a vector space of finite dimension over a given field,{} with a given symbolic basis.")) (|coordinates| (((|Vector| |#1|) $) "\\spad{coordinates x} returns the coordinates of the linear form with respect to the basis \\spad{DualBasis B}.")) (|linearForm| (($ (|List| |#1|)) "\\spad{linearForm [x1,..,xn]} constructs a linear form with coordinates \\spad{[x1,..,xn]} with respect to the basis elements \\spad{DualBasis B}."))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 NIL 
 (|LinearSet| S) 
 ((|constructor| (NIL "\\indented{2}{A set is an \\spad{S}-linear set if it is stable by dilation} \\indented{2}{by elements in the semigroup \\spad{S}.} See Also: LeftLinearSet,{} RightLinearSet."))) 
@@ -2322,7 +2326,7 @@ NIL
 NIL 
 (|Localize| M R S) 
 ((|constructor| (NIL "Localize(\\spad{M},{}\\spad{R},{}\\spad{S}) produces fractions with numerators from an \\spad{R} module \\spad{M} and denominators from some multiplicative subset \\spad{D} of \\spad{R}.")) (|denom| ((|#3| $) "\\spad{denom x} returns the denominator of \\spad{x}.")) (|numer| ((|#1| $) "\\spad{numer x} returns the numerator of \\spad{x}.")) (/ (($ |#1| |#3|) "\\spad{m / d} divides the element \\spad{m} by \\spad{d}.") (($ $ |#3|) "\\spad{x / d} divides the element \\spad{x} by \\spad{d}."))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|OrderedAbelianGroup|)))) 
 (|ElementaryFunctionLODESolver| R F L) 
 ((|constructor| (NIL "\\spad{ElementaryFunctionLODESolver} provides the top-level functions for finding closed form solutions of linear ordinary differential equations and initial value problems.")) (|solve| (((|Union| |#2| "failed") |#3| |#2| (|Symbol|) |#2| (|List| |#2|)) "\\spad{solve(op, g, x, a, [y0,...,ym])} returns either the solution of the initial value problem \\spad{op y = g, y(a) = y0, y'(a) = y1,...} or \"failed\" if the solution cannot be found; \\spad{x} is the dependent variable.") (((|Union| (|Record| (|:| |particular| |#2|) (|:| |basis| (|List| |#2|))) "failed") |#3| |#2| (|Symbol|)) "\\spad{solve(op, g, x)} returns either a solution of the ordinary differential equation \\spad{op y = g} or \"failed\" if no non-trivial solution can be found; When found,{} the solution is returned in the form \\spad{[h, [b1,...,bm]]} where \\spad{h} is a particular solution and and \\spad{[b1,...bm]} are linearly independent solutions of the associated homogenuous equation \\spad{op y = 0}. A full basis for the solutions of the homogenuous equation is not always returned,{} only the solutions which were found; \\spad{x} is the dependent variable."))) 
@@ -2330,15 +2334,15 @@ NIL
 NIL 
 (|LinearOrdinaryDifferentialOperator| A |diff|) 
 ((|constructor| (NIL "\\spad{LinearOrdinaryDifferentialOperator} defines a ring of differential operators with coefficients in a ring A with a given derivation. Multiplication of operators corresponds to functional composition: \\indented{4}{\\spad{(L1 * L2).(f) = L1 L2 f}}"))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #1=(|Integer|))))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #1#))) (|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (|HasCategory| |#1| (QUOTE (|GcdDomain|))) (|HasCategory| |#1| (QUOTE (|Field|)))) 
 (|LinearOrdinaryDifferentialOperator1| A) 
 ((|constructor| (NIL "\\spad{LinearOrdinaryDifferentialOperator1} defines a ring of differential operators with coefficients in a differential ring A. Multiplication of operators corresponds to functional composition: \\indented{4}{\\spad{(L1 * L2).(f) = L1 L2 f}}"))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #1=(|Integer|))))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #1#))) (|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (|HasCategory| |#1| (QUOTE (|GcdDomain|))) (|HasCategory| |#1| (QUOTE (|Field|)))) 
 (|LinearOrdinaryDifferentialOperator2| A M) 
 ((|constructor| (NIL "\\spad{LinearOrdinaryDifferentialOperator2} defines a ring of differential operators with coefficients in a differential ring A and acting on an A-module \\spad{M}. Multiplication of operators corresponds to functional composition: \\indented{4}{\\spad{(L1 * L2).(f) = L1 L2 f}}")) (|differentiate| (($ $) "\\spad{differentiate(x)} returns the derivative of \\spad{x}"))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #1=(|Integer|))))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #1#))) (|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (|HasCategory| |#1| (QUOTE (|GcdDomain|))) (|HasCategory| |#1| (QUOTE (|Field|)))) 
 (|LinearOrdinaryDifferentialOperatorCategory&| S A) 
 ((|constructor| (NIL "\\spad{LinearOrdinaryDifferentialOperatorCategory} is the category of differential operators with coefficients in a ring A with a given derivation. Multiplication of operators corresponds to functional composition: \\indented{4}{\\spad{(L1 * L2).(f) = L1 L2 f}}")) (|directSum| (($ $ $) "\\spad{directSum(a,b)} computes an operator \\spad{c} of minimal order such that the nullspace of \\spad{c} is generated by all the sums of a solution of \\spad{a} by a solution of \\spad{b}.")) (|symmetricSquare| (($ $) "\\spad{symmetricSquare(a)} computes \\spad{symmetricProduct(a,a)} using a more efficient method.")) (|symmetricPower| (($ $ (|NonNegativeInteger|)) "\\spad{symmetricPower(a,n)} computes an operator \\spad{c} of minimal order such that the nullspace of \\spad{c} is generated by all the products of \\spad{n} solutions of \\spad{a}.")) (|symmetricProduct| (($ $ $) "\\spad{symmetricProduct(a,b)} computes an operator \\spad{c} of minimal order such that the nullspace of \\spad{c} is generated by all the products of a solution of \\spad{a} by a solution of \\spad{b}.")) (|adjoint| (($ $) "\\spad{adjoint(a)} returns the adjoint operator of a.")) (D (($) "\\spad{D()} provides the operator corresponding to a derivation in the ring \\spad{A}."))) 
@@ -2346,7 +2350,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|Field|)))) 
 (|LinearOrdinaryDifferentialOperatorCategory| A) 
 ((|constructor| (NIL "\\spad{LinearOrdinaryDifferentialOperatorCategory} is the category of differential operators with coefficients in a ring A with a given derivation. Multiplication of operators corresponds to functional composition: \\indented{4}{\\spad{(L1 * L2).(f) = L1 L2 f}}")) (|directSum| (($ $ $) "\\spad{directSum(a,b)} computes an operator \\spad{c} of minimal order such that the nullspace of \\spad{c} is generated by all the sums of a solution of \\spad{a} by a solution of \\spad{b}.")) (|symmetricSquare| (($ $) "\\spad{symmetricSquare(a)} computes \\spad{symmetricProduct(a,a)} using a more efficient method.")) (|symmetricPower| (($ $ (|NonNegativeInteger|)) "\\spad{symmetricPower(a,n)} computes an operator \\spad{c} of minimal order such that the nullspace of \\spad{c} is generated by all the products of \\spad{n} solutions of \\spad{a}.")) (|symmetricProduct| (($ $ $) "\\spad{symmetricProduct(a,b)} computes an operator \\spad{c} of minimal order such that the nullspace of \\spad{c} is generated by all the products of a solution of \\spad{a} by a solution of \\spad{b}.")) (|adjoint| (($ $) "\\spad{adjoint(a)} returns the adjoint operator of a.")) (D (($) "\\spad{D()} provides the operator corresponding to a derivation in the ring \\spad{A}."))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 NIL 
 (|LinearOrdinaryDifferentialOperatorFactorizer| F UP) 
 ((|constructor| (NIL "\\spadtype{LinearOrdinaryDifferentialOperatorFactorizer} provides a factorizer for linear ordinary differential operators whose coefficients are rational functions.")) (|factor1| (((|List| (|LinearOrdinaryDifferentialOperator1| (|Fraction| |#2|))) (|LinearOrdinaryDifferentialOperator1| (|Fraction| |#2|))) "\\spad{factor1(a)} returns the factorisation of a,{} assuming that a has no first-order right factor.")) (|factor| (((|List| (|LinearOrdinaryDifferentialOperator1| (|Fraction| |#2|))) (|LinearOrdinaryDifferentialOperator1| (|Fraction| |#2|))) "\\spad{factor(a)} returns the factorisation of a.") (((|List| (|LinearOrdinaryDifferentialOperator1| (|Fraction| |#2|))) (|LinearOrdinaryDifferentialOperator1| (|Fraction| |#2|)) (|Mapping| (|List| |#1|) |#2|)) "\\spad{factor(a, zeros)} returns the factorisation of a. \\spad{zeros} is a zero finder in \\spad{UP}."))) 
@@ -2370,7 +2374,7 @@ NIL
 NIL 
 (|LiePolynomial| |VarSet| R) 
 ((|constructor| (NIL "This type supports Lie polynomials in Lyndon basis see Free Lie Algebras by \\spad{C}. Reutenauer (Oxford science publications). \\newline Author: Michel Petitot (petitot@lifl.fr).")) (|construct| (($ $ (|LyndonWord| |#1|)) "\\axiom{construct(\\spad{x},{}\\spad{y})} returns the Lie bracket \\axiom{[\\spad{x},{}\\spad{y}]}.") (($ (|LyndonWord| |#1|) $) "\\axiom{construct(\\spad{x},{}\\spad{y})} returns the Lie bracket \\axiom{[\\spad{x},{}\\spad{y}]}.") (($ (|LyndonWord| |#1|) (|LyndonWord| |#1|)) "\\axiom{construct(\\spad{x},{}\\spad{y})} returns the Lie bracket \\axiom{[\\spad{x},{}\\spad{y}]}.")) (|LiePolyIfCan| (((|Union| $ "failed") (|XDistributedPolynomial| |#1| |#2|)) "\\axiom{LiePolyIfCan(\\spad{p})} returns \\axiom{\\spad{p}} in Lyndon basis if \\axiom{\\spad{p}} is a Lie polynomial,{} otherwise \\axiom{\"failed\"} is returned."))) 
-((|JacobiIdentity| . T) (|NullSquare| . T) (|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 ((|HasCategory| |#2| (QUOTE (|Field|))) (|HasCategory| |#2| (QUOTE (|CommutativeRing|)))) 
 (|ListAggregate&| A S) 
 ((|constructor| (NIL "A list aggregate is a model for a linked list data structure. A linked list is a versatile data structure. Insertion and deletion are efficient and searching is a linear operation.")) (|list| (($ |#2|) "\\spad{list(x)} returns the list of one element \\spad{x}."))) 
@@ -2394,14 +2398,14 @@ NIL
 NIL 
 (|LieSquareMatrix| |n| R) 
 ((|constructor| (NIL "LieSquareMatrix(\\spad{n},{}\\spad{R}) implements the Lie algebra of the \\spad{n} by \\spad{n} matrices over the commutative ring \\spad{R}. The Lie bracket (commutator) of the algebra is given by \\spad{a*b := (a *\\$SQMATRIX(n,R) b - b *\\$SQMATRIX(n,R) a)},{} where \\spadfun{*\\$SQMATRIX(\\spad{n},{}\\spad{R})} is the usual matrix multiplication."))) 
-((|unitsKnown| . T) (|rightUnitary| . T) (|leftUnitary| . T)) 
-(#1=(|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #2=(|Symbol|)))) (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #2#))) #3=(|HasCategory| |#2| (QUOTE (|DifferentialRing|))) (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) #4=(|HasAttribute| |#2| (QUOTE (|commutative| "*"))) #5=(|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #6=(|Integer|)))) (|HasCategory| |#2| (QUOTE (|RetractableTo| (|Fraction| #6#)))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #6#))) (OR (AND #3# #7=(|HasCategory| |#2| (|%list| (QUOTE |Evalable|) (|devaluate| |#2|)))) (AND #5# #7#) (AND #1# #7#) #8=(AND #9=(|HasCategory| |#2| (QUOTE (|SetCategory|))) #7#)) (|HasCategory| |#2| (QUOTE (|EuclideanDomain|))) (|HasCategory| |#2| (QUOTE (|Field|))) (|HasCategory| |#2| (QUOTE (|IntegralDomain|))) (OR #4# #3# #1#) (|HasCategory| |#2| (QUOTE (|CoercibleTo| (|OutputForm|)))) (|HasCategory| |#2| (QUOTE (|BasicType|))) #9# #8# (|HasCategory| |#2| (QUOTE (|CommutativeRing|)))) 
+NIL 
+(#1=(|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #2=(|Symbol|)))) (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #2#))) #3=(|HasCategory| |#2| (QUOTE (|DifferentialRing|))) (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) (|HasAttribute| |#2| (QUOTE (|commutative| "*"))) #4=(|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #5=(|Integer|)))) (|HasCategory| |#2| (QUOTE (|RetractableTo| (|Fraction| #5#)))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #5#))) (OR (AND #3# #6=(|HasCategory| |#2| (|%list| (QUOTE |Evalable|) (|devaluate| |#2|)))) (AND #4# #6#) (AND #1# #6#) #7=(AND #8=(|HasCategory| |#2| (QUOTE (|SetCategory|))) #6#)) (|HasCategory| |#2| (QUOTE (|EuclideanDomain|))) (|HasCategory| |#2| (QUOTE (|Field|))) (|HasCategory| |#2| (QUOTE (|IntegralDomain|))) #7# #8# (|HasCategory| |#2| (QUOTE (|BasicType|))) (|HasCategory| |#2| (QUOTE (|CoercibleTo| (|OutputForm|)))) (|HasCategory| |#2| (QUOTE (|CommutativeRing|)))) 
 (|ConstructAst|) 
 ((|constructor| (NIL "This domain represents `literal sequence' syntax.")) (|elements| (((|List| (|SpadAst|)) $) "\\spad{elements(e)} returns the list of expressions in the `literal' list `e'."))) 
 NIL 
 NIL 
 (|LyndonWord| |VarSet|) 
-((|constructor| (NIL "Lyndon words over arbitrary (ordered) symbols: see Free Lie Algebras by \\spad{C}. Reutenauer (Oxford science publications). A Lyndon word is a word which is smaller than any of its right factors \\spad{w}.\\spad{r}.\\spad{t}. the pure lexicographical ordering. If \\axiom{a} and \\axiom{\\spad{b}} are two Lyndon words such that \\axiom{a < \\spad{b}} holds \\spad{w}.\\spad{r}.\\spad{t} lexicographical ordering then \\axiom{a*b} is a Lyndon word. Parenthesized Lyndon words can be generated from symbols by using the following rule: \\axiom{[[a,{}\\spad{b}],{}\\spad{c}]} is a Lyndon word iff \\axiom{a*b < \\spad{c} <= \\spad{b}} holds. Lyndon words are internally represented by binary trees using the \\spadtype{Magma} domain constructor. Two ordering are provided: lexicographic and length-lexicographic. \\newline Author : Michel Petitot (petitot@lifl.fr).")) (|LyndonWordsList| (((|List| $) (|List| |#1|) (|PositiveInteger|)) "\\axiom{LyndonWordsList(vl,{} \\spad{n})} returns the list of Lyndon words over the alphabet \\axiom{vl},{} up to order \\axiom{\\spad{n}}.")) (|LyndonWordsList1| (((|OneDimensionalArray| (|List| $)) (|List| |#1|) (|PositiveInteger|)) "\\axiom{\\spad{LyndonWordsList1}(vl,{} \\spad{n})} returns an array of lists of Lyndon words over the alphabet \\axiom{vl},{} up to order \\axiom{\\spad{n}}.")) (|varList| (((|List| |#1|) $) "\\axiom{varList(\\spad{x})} returns the list of distinct entries of \\axiom{\\spad{x}}.")) (|lyndonIfCan| (((|Union| $ "failed") (|OrderedFreeMonoid| |#1|)) "\\axiom{lyndonIfCan(\\spad{w})} convert \\axiom{\\spad{w}} into a Lyndon word.")) (|lyndon| (($ (|OrderedFreeMonoid| |#1|)) "\\axiom{lyndon(\\spad{w})} convert \\axiom{\\spad{w}} into a Lyndon word,{} error if \\axiom{\\spad{w}} is not a Lyndon word.")) (|lyndon?| (((|Boolean|) (|OrderedFreeMonoid| |#1|)) "\\axiom{lyndon?(\\spad{w})} test if \\axiom{\\spad{w}} is a Lyndon word.")) (|factor| (((|List| $) (|OrderedFreeMonoid| |#1|)) "\\axiom{factor(\\spad{x})} returns the decreasing factorization into Lyndon words.")) (|coerce| (((|Magma| |#1|) $) "\\axiom{coerce(\\spad{x})} returns the element of \\axiomType{Magma}(VarSet) corresponding to \\axiom{\\spad{x}}.") (((|OrderedFreeMonoid| |#1|) $) "\\axiom{coerce(\\spad{x})} returns the element of \\axiomType{OrderedFreeMonoid}(VarSet) corresponding to \\axiom{\\spad{x}}.")) (|lexico| (((|Boolean|) $ $) "\\axiom{lexico(\\spad{x},{}\\spad{y})} returns \\axiom{\\spad{true}} iff \\axiom{\\spad{x}} is smaller than \\axiom{\\spad{y}} \\spad{w}.\\spad{r}.\\spad{t}. the lexicographical ordering induced by \\axiom{VarSet}.")) (|length| (((|PositiveInteger|) $) "\\axiom{length(\\spad{x})} returns the number of entries in \\axiom{\\spad{x}}.")) (|right| (($ $) "\\axiom{right(\\spad{x})} returns right subtree of \\axiom{\\spad{x}} or error if \\axiomOpFrom{retractable?}{LyndonWord}(\\axiom{\\spad{x}}) is \\spad{true}.")) (|left| (($ $) "\\axiom{left(\\spad{x})} returns left subtree of \\axiom{\\spad{x}} or error if \\axiomOpFrom{retractable?}{LyndonWord}(\\axiom{\\spad{x}}) is \\spad{true}.")) (|retractable?| (((|Boolean|) $) "\\axiom{retractable?(\\spad{x})} tests if \\axiom{\\spad{x}} is a tree with only one entry."))) 
+((|constructor| (NIL "Lyndon words over arbitrary (ordered) symbols: see Free Lie Algebras by \\spad{C}. Reutenauer (Oxford science publications). A Lyndon word is a word which is smaller than any of its right factors \\spad{w}.\\spad{r}.\\spad{t}. the pure lexicographical ordering. If \\axiom{a} and \\axiom{\\spad{b}} are two Lyndon words such that \\axiom{a < \\spad{b}} holds \\spad{w}.\\spad{r}.\\spad{t} lexicographical ordering then \\axiom{a*b} is a Lyndon word. Parenthesized Lyndon words can be generated from symbols by using the following rule: \\axiom{[[a,{}\\spad{b}],{}\\spad{c}]} is a Lyndon word iff \\axiom{a*b < \\spad{c} <= \\spad{b}} holds. Lyndon words are internally represented by binary trees using the \\spadtype{FreeMagma} domain constructor. Two ordering are provided: lexicographic and length-lexicographic. \\newline Author : Michel Petitot (petitot@lifl.fr).")) (|LyndonWordsList| (((|List| $) (|List| |#1|) (|PositiveInteger|)) "\\axiom{LyndonWordsList(vl,{} \\spad{n})} returns the list of Lyndon words over the alphabet \\axiom{vl},{} up to order \\axiom{\\spad{n}}.")) (|LyndonWordsList1| (((|OneDimensionalArray| (|List| $)) (|List| |#1|) (|PositiveInteger|)) "\\axiom{\\spad{LyndonWordsList1}(vl,{} \\spad{n})} returns an array of lists of Lyndon words over the alphabet \\axiom{vl},{} up to order \\axiom{\\spad{n}}.")) (|varList| (((|List| |#1|) $) "\\axiom{varList(\\spad{x})} returns the list of distinct entries of \\axiom{\\spad{x}}.")) (|lyndonIfCan| (((|Union| $ "failed") (|OrderedFreeMonoid| |#1|)) "\\axiom{lyndonIfCan(\\spad{w})} convert \\axiom{\\spad{w}} into a Lyndon word.")) (|lyndon| (($ (|OrderedFreeMonoid| |#1|)) "\\axiom{lyndon(\\spad{w})} convert \\axiom{\\spad{w}} into a Lyndon word,{} error if \\axiom{\\spad{w}} is not a Lyndon word.")) (|lyndon?| (((|Boolean|) (|OrderedFreeMonoid| |#1|)) "\\axiom{lyndon?(\\spad{w})} test if \\axiom{\\spad{w}} is a Lyndon word.")) (|factor| (((|List| $) (|OrderedFreeMonoid| |#1|)) "\\axiom{factor(\\spad{x})} returns the decreasing factorization into Lyndon words.")) (|lexico| (((|Boolean|) $ $) "\\axiom{lexico(\\spad{x},{}\\spad{y})} returns \\axiom{\\spad{true}} iff \\axiom{\\spad{x}} is smaller than \\axiom{\\spad{y}} \\spad{w}.\\spad{r}.\\spad{t}. the lexicographical ordering induced by \\axiom{VarSet}.")) (|length| (((|PositiveInteger|) $) "\\axiom{length(\\spad{x})} returns the number of entries in \\axiom{\\spad{x}}.")) (|right| (($ $) "\\axiom{right(\\spad{x})} returns right subtree of \\axiom{\\spad{x}} or error if \\axiomOpFrom{retractable?}{LyndonWord}(\\axiom{\\spad{x}}) is \\spad{true}.")) (|left| (($ $) "\\axiom{left(\\spad{x})} returns left subtree of \\axiom{\\spad{x}} or error if \\axiomOpFrom{retractable?}{LyndonWord}(\\axiom{\\spad{x}}) is \\spad{true}.")) (|retractable?| (((|Boolean|) $) "\\axiom{retractable?(\\spad{x})} tests if \\axiom{\\spad{x}} is a tree with only one entry."))) 
 NIL 
 NIL 
 (|LazyStreamAggregate&| A S) 
@@ -2416,10 +2420,6 @@ NIL
 ((|constructor| (NIL "This domain represents the syntax of a macro definition.")) (|body| (((|SpadAst|) $) "\\spad{body(m)} returns the right hand side of the definition `m'.")) (|head| (((|HeadAst|) $) "\\spad{head(m)} returns the head of the macro definition `m'. This is a list of identifiers starting with the name of the macro followed by the name of the parameters,{} if any."))) 
 NIL 
 NIL 
-(|Magma| |VarSet|) 
-((|constructor| (NIL "This type is the basic representation of parenthesized words (binary trees over arbitrary symbols) useful in \\spadtype{LiePolynomial}. \\newline Author: Michel Petitot (petitot@lifl.fr).")) (|varList| (((|List| |#1|) $) "\\axiom{varList(\\spad{x})} returns the list of distinct entries of \\axiom{\\spad{x}}.")) (|right| (($ $) "\\axiom{right(\\spad{x})} returns right subtree of \\axiom{\\spad{x}} or error if \\axiomOpFrom{retractable?}{Magma}(\\axiom{\\spad{x}}) is \\spad{true}.")) (|retractable?| (((|Boolean|) $) "\\axiom{retractable?(\\spad{x})} tests if \\axiom{\\spad{x}} is a tree with only one entry.")) (|rest| (($ $) "\\axiom{rest(\\spad{x})} return \\axiom{\\spad{x}} without the first entry or error if \\axiomOpFrom{retractable?}{Magma}(\\axiom{\\spad{x}}) is \\spad{true}.")) (|mirror| (($ $) "\\axiom{mirror(\\spad{x})} returns the reversed word of \\axiom{\\spad{x}}. That is \\axiom{\\spad{x}} itself if \\axiomOpFrom{retractable?}{Magma}(\\axiom{\\spad{x}}) is \\spad{true} and \\axiom{mirror(\\spad{z}) * mirror(\\spad{y})} if \\axiom{\\spad{x}} is \\axiom{y*z}.")) (|lexico| (((|Boolean|) $ $) "\\axiom{lexico(\\spad{x},{}\\spad{y})} returns \\axiom{\\spad{true}} iff \\axiom{\\spad{x}} is smaller than \\axiom{\\spad{y}} \\spad{w}.\\spad{r}.\\spad{t}. the lexicographical ordering induced by \\axiom{VarSet}. \\spad{N}.\\spad{B}. This operation does not take into account the tree structure of its arguments. Thus this is not a total ordering.")) (|length| (((|PositiveInteger|) $) "\\axiom{length(\\spad{x})} returns the number of entries in \\axiom{\\spad{x}}.")) (|left| (($ $) "\\axiom{left(\\spad{x})} returns left subtree of \\axiom{\\spad{x}} or error if \\axiomOpFrom{retractable?}{Magma}(\\axiom{\\spad{x}}) is \\spad{true}.")) (|first| ((|#1| $) "\\axiom{first(\\spad{x})} returns the first entry of the tree \\axiom{\\spad{x}}.")) (|coerce| (((|OrderedFreeMonoid| |#1|) $) "\\axiom{coerce(\\spad{x})} returns the element of \\axiomType{OrderedFreeMonoid}(VarSet) corresponding to \\axiom{\\spad{x}} by removing parentheses.")) (* (($ $ $) "\\axiom{x*y} returns the tree \\axiom{[\\spad{x},{}\\spad{y}]}."))) 
-NIL 
-NIL 
 (|MappingPackageInternalHacks1| A) 
 ((|constructor| (NIL "various Currying operations.")) (|recur| ((|#1| (|Mapping| |#1| (|NonNegativeInteger|) |#1|) (|NonNegativeInteger|) |#1|) "\\spad{recur(n,g,x)} is \\spad{g(n,g(n-1,..g(1,x)..))}.")) (|iter| ((|#1| (|Mapping| |#1| |#1|) (|NonNegativeInteger|) |#1|) "\\spad{iter(f,n,x)} applies \\spad{f n} times to \\spad{x}."))) 
 NIL 
@@ -2475,7 +2475,7 @@ NIL
 (|Maybe| T$) 
 ((|constructor| (NIL "This domain implements the notion of optional value,{} where a computation may fail to produce expected value.")) (|nothing| (($) "\\spad{nothing} represents failure or absence of value.")) (|autoCoerce| ((|#1| $) "\\spad{autoCoerce} is a courtesy coercion function used by the compiler in case it knows that `x' really is a \\spadtype{T}.")) (|case| (((|Boolean|) $ (|[\|\|]| |nothing|)) "\\spad{x case nothing} holds if the value for \\spad{x} is missing.") (((|Boolean|) $ (|[\|\|]| |#1|)) "\\spad{x case T} returns \\spad{true} if \\spad{x} is actually a data of type \\spad{T}.")) (|just| (($ |#1|) "\\spad{just x} injects the value `x' into \\%."))) 
 NIL 
-NIL 
+((|HasCategory| |#1| (QUOTE (|CoercibleTo| (|OutputForm|))))) 
 (|MatrixCommonDenominator| R Q) 
 ((|constructor| (NIL "MatrixCommonDenominator provides functions to compute the common denominator of a matrix of elements of the quotient field of an integral domain.")) (|splitDenominator| (((|Record| (|:| |num| (|Matrix| |#1|)) (|:| |den| |#1|)) (|Matrix| |#2|)) "\\spad{splitDenominator(q)} returns \\spad{[p, d]} such that \\spad{q = p/d} and \\spad{d} is a common denominator for the elements of \\spad{q}.")) (|clearDenominator| (((|Matrix| |#1|) (|Matrix| |#2|)) "\\spad{clearDenominator(q)} returns \\spad{p} such that \\spad{q = p/d} where \\spad{d} is a common denominator for the elements of \\spad{q}.")) (|commonDenominator| ((|#1| (|Matrix| |#2|)) "\\spad{commonDenominator(q)} returns a common denominator \\spad{d} for the elements of \\spad{q}."))) 
 NIL 
@@ -2526,7 +2526,7 @@ NIL
 NIL 
 (|MonogenicLinearOperator| R) 
 ((|constructor| (NIL "This is the category of linear operator rings with one generator. The generator is not named by the category but can always be constructed as \\spad{monomial(1,1)}. \\blankline For convenience,{} call the generator \\spad{G}. Then each value is equal to \\indented{4}{\\spad{sum(a(i)*G**i, i = 0..n)}} for some unique \\spad{n} and \\spad{a(i)} in \\spad{R}. \\blankline Note that multiplication is not necessarily commutative. In fact,{} if \\spad{a} is in \\spad{R},{} it is quite normal to have \\spad{a*G \\~= G*a}.")) (|monomial| (($ |#1| (|NonNegativeInteger|)) "\\spad{monomial(c,k)} produces \\spad{c} times the \\spad{k}-th power of the generating operator,{} \\spad{monomial(1,1)}.")) (|coefficient| ((|#1| $ (|NonNegativeInteger|)) "\\spad{coefficient(l,k)} is \\spad{a(k)} if \\indented{2}{\\spad{l = sum(monomial(a(i),i), i = 0..n)}.}")) (|reductum| (($ $) "\\spad{reductum(l)} is \\spad{l - monomial(a(n),n)} if \\indented{2}{\\spad{l = sum(monomial(a(i),i), i = 0..n)}.}")) (|leadingCoefficient| ((|#1| $) "\\spad{leadingCoefficient(l)} is \\spad{a(n)} if \\indented{2}{\\spad{l = sum(monomial(a(i),i), i = 0..n)}.}")) (|minimumDegree| (((|NonNegativeInteger|) $) "\\spad{minimumDegree(l)} is the smallest \\spad{k} such that \\spad{a(k) \\~= 0} if \\indented{2}{\\spad{l = sum(monomial(a(i),i), i = 0..n)}.}")) (|degree| (((|NonNegativeInteger|) $) "\\spad{degree(l)} is \\spad{n} if \\indented{2}{\\spad{l = sum(monomial(a(i),i), i = 0..n)}.}"))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 NIL 
 (|MultipleMap| R1 UP1 UPUP1 R2 UP2 UPUP2) 
 ((|constructor| (NIL "Lifting of a map through 2 levels of polynomials.")) (|map| ((|#6| (|Mapping| |#4| |#1|) |#3|) "\\spad{map(f, p)} lifts \\spad{f} to the domain of \\spad{p} then applies it to \\spad{p}."))) 
@@ -2537,24 +2537,24 @@ NIL
 NIL 
 NIL 
 (|ModularField| R |Mod| |reduction| |merge| |exactQuo|) 
-((|constructor| (NIL "\\indented{1}{These domains are used for the factorization and gcds} of univariate polynomials over the integers in order to work modulo different primes. See \\spadtype{ModularRing},{} \\spadtype{EuclideanModularRing}")) (|exQuo| (((|Union| $ "failed") $ $) "\\spad{exQuo(x,y)} \\undocumented")) (|reduce| (($ |#1| |#2|) "\\spad{reduce(r,m)} \\undocumented")) (|coerce| ((|#1| $) "\\spad{coerce(x)} \\undocumented")) (|modulus| ((|#2| $) "\\spad{modulus(x)} \\undocumented"))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|constructor| (NIL "\\indented{1}{These domains are used for the factorization and gcds} of univariate polynomials over the integers in order to work modulo different primes. See \\spadtype{ModularRing},{} \\spadtype{EuclideanModularRing}")) (|exQuo| (((|Union| $ "failed") $ $) "\\spad{exQuo(x,y)} \\undocumented")) (|reduce| (($ |#1| |#2|) "\\spad{reduce(r,m)} \\undocumented")) (|modulus| ((|#2| $) "\\spad{modulus(x)} \\undocumented"))) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|ModMonic| R P) 
 ((|constructor| (NIL "This package \\undocumented")) (|frobenius| (($ $) "\\spad{frobenius(x)} \\undocumented")) (|computePowers| (((|PrimitiveArray| $)) "\\spad{computePowers()} \\undocumented")) (|pow| (((|PrimitiveArray| $)) "\\spad{pow()} \\undocumented")) (|An| (((|Vector| |#1|) $) "\\spad{An(x)} \\undocumented")) (|UnVectorise| (($ (|Vector| |#1|)) "\\spad{UnVectorise(v)} \\undocumented")) (|Vectorise| (((|Vector| |#1|) $) "\\spad{Vectorise(x)} \\undocumented")) (|lift| ((|#2| $) "\\spad{lift(x)} \\undocumented")) (|reduce| (($ |#2|) "\\spad{reduce(x)} \\undocumented")) (|modulus| ((|#2|) "\\spad{modulus()} \\undocumented")) (|setPoly| ((|#2| |#2|) "\\spad{setPoly(x)} \\undocumented"))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|additiveValuation| |has| |#1| (|Field|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) #2=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #3=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #3# #2#) (AND (|HasCategory| |#1| #4=(QUOTE (|PatternMatchable| #5=(|Float|)))) (|HasCategory| #6=(|SingletonAsOrderedSet|) #4#)) (AND (|HasCategory| |#1| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| #6# #7#)) (AND (|HasCategory| |#1| #9=(QUOTE (|ConvertibleTo| (|Pattern| #5#)))) (|HasCategory| #6# #9#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #6# #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #6# #11#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #8#))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #12=(|HasCategory| |#1| #13=(QUOTE (|CharacteristicNonZero|))) #14=(|HasCategory| |#1| (QUOTE (|Algebra| #15=(|Fraction| #8#)))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #8#))) (OR #14# #16=(|HasCategory| |#1| (QUOTE (|RetractableTo| #15#)))) #16# (OR #3# #17=(|HasCategory| |#1| (QUOTE (|Field|))) #18=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #2# #1#) (OR #17# #18# #2# #1#) (OR #17# #18# #1#) #17# (|HasCategory| |#1| (QUOTE (|StepThrough|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #19=(|Symbol|)))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #19#))) (|HasCategory| |#1| (QUOTE (|Finite|))) (|HasCategory| |#1| (QUOTE (|FiniteFieldCategory|))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #18# #20=(AND #1# (|HasCategory| $ #13#)) (OR #20# #12#)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|additiveValuation| |has| |#1| (|Field|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) #2=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #3=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #3# #2#) (AND (|HasCategory| |#1| #4=(QUOTE (|PatternMatchable| #5=(|Float|)))) (|HasCategory| #6=(|SingletonAsOrderedSet|) #4#)) (AND (|HasCategory| |#1| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| #6# #7#)) (AND (|HasCategory| |#1| #9=(QUOTE (|ConvertibleTo| (|Pattern| #5#)))) (|HasCategory| #6# #9#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #6# #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #6# #11#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #8#))) #12=(|HasCategory| |#1| (QUOTE (|Algebra| #13=(|Fraction| #8#)))) #14=(|HasCategory| |#1| #15=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #8#))) (OR #12# #16=(|HasCategory| |#1| (QUOTE (|RetractableTo| #13#)))) #16# (OR #3# #17=(|HasCategory| |#1| (QUOTE (|Field|))) #18=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #2# #1#) (OR #17# #18# #2# #1#) (OR #17# #18# #1#) #17# (|HasCategory| |#1| (QUOTE (|StepThrough|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #19=(|Symbol|)))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #19#))) (|HasCategory| |#1| (QUOTE (|Finite|))) (|HasCategory| |#1| (QUOTE (|FiniteFieldCategory|))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #18# #20=(AND #1# (|HasCategory| $ #15#)) (OR #20# #14#)) 
 (|ModuleMonomial| IS E |ff|) 
 ((|constructor| (NIL "This package \\undocumented")) (|construct| (($ |#1| |#2|) "\\spad{construct(i,e)} \\undocumented")) (|index| ((|#1| $) "\\spad{index(x)} \\undocumented")) (|exponent| ((|#2| $) "\\spad{exponent(x)} \\undocumented"))) 
 NIL 
 NIL 
 (|ModuleOperator| R M) 
 ((|constructor| (NIL "Algebra of ADDITIVE operators on a module.")) (|makeop| (($ |#1| (|FreeGroup| (|BasicOperator|))) "\\spad{makeop should} be local but conditional")) (|opeval| ((|#2| (|BasicOperator|) |#2|) "\\spad{opeval should} be local but conditional")) (** (($ $ (|Integer|)) "\\spad{op**n} \\undocumented") (($ (|BasicOperator|) (|Integer|)) "\\spad{op**n} \\undocumented")) (|evaluateInverse| (($ $ (|Mapping| |#2| |#2|)) "\\spad{evaluateInverse(x,f)} \\undocumented")) (|evaluate| (($ $ (|Mapping| |#2| |#2|)) "\\spad{evaluate(f, u +-> g u)} attaches the map \\spad{g} to \\spad{f}. \\spad{f} must be a basic operator \\spad{g} MUST be additive,{} \\spadignore{i.e.} \\spad{g(a + b) = g(a) + g(b)} for any \\spad{a},{} \\spad{b} in \\spad{M}. This implies that \\spad{g(n a) = n g(a)} for any \\spad{a} in \\spad{M} and integer \\spad{n > 0}.")) (|conjug| ((|#1| |#1|) "\\spad{conjug(x)}should be local but conditional")) (|adjoint| (($ $ $) "\\spad{adjoint(op1, op2)} sets the adjoint of \\spad{op1} to be \\spad{op2}. \\spad{op1} must be a basic operator") (($ $) "\\spad{adjoint(op)} returns the adjoint of the operator \\spad{op}."))) 
-((|leftUnitary| |has| |#1| . #1=((|CommutativeRing|))) (|rightUnitary| |has| |#1| . #1#) (|unitsKnown| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|)))) 
 (|ModularRing| R |Mod| |reduction| |merge| |exactQuo|) 
-((|constructor| (NIL "These domains are used for the factorization and gcds of univariate polynomials over the integers in order to work modulo different primes. See \\spadtype{EuclideanModularRing} ,{}\\spadtype{ModularField}")) (|inv| (($ $) "\\spad{inv(x)} \\undocumented")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(x)} \\undocumented")) (|exQuo| (((|Union| $ "failed") $ $) "\\spad{exQuo(x,y)} \\undocumented")) (|reduce| (($ |#1| |#2|) "\\spad{reduce(r,m)} \\undocumented")) (|coerce| ((|#1| $) "\\spad{coerce(x)} \\undocumented")) (|modulus| ((|#2| $) "\\spad{modulus(x)} \\undocumented"))) 
-((|unitsKnown| . T)) 
+((|constructor| (NIL "These domains are used for the factorization and gcds of univariate polynomials over the integers in order to work modulo different primes. See \\spadtype{EuclideanModularRing} ,{}\\spadtype{ModularField}")) (|inv| (($ $) "\\spad{inv(x)} \\undocumented")) (|exQuo| (((|Union| $ "failed") $ $) "\\spad{exQuo(x,y)} \\undocumented")) (|reduce| (($ |#1| |#2|) "\\spad{reduce(r,m)} \\undocumented")) (|modulus| ((|#2| $) "\\spad{modulus(x)} \\undocumented"))) 
+NIL 
 NIL 
 (|Module&| S R) 
 ((|constructor| (NIL "The category of modules over a commutative ring. \\blankline"))) 
@@ -2562,11 +2562,11 @@ NIL
 NIL 
 (|Module| R) 
 ((|constructor| (NIL "The category of modules over a commutative ring. \\blankline"))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 NIL 
 (|MoebiusTransform| F) 
 ((|constructor| (NIL "\\indented{1}{MoebiusTransform(\\spad{F}) is the domain of fractional linear (Moebius)} transformations over \\spad{F}.")) (|eval| (((|OnePointCompletion| |#1|) $ (|OnePointCompletion| |#1|)) "\\spad{eval(m,x)} returns \\spad{(a*x + b)/(c*x + d)} where \\spad{m = moebius(a,b,c,d)} (see \\spadfunFrom{moebius}{MoebiusTransform}).") ((|#1| $ |#1|) "\\spad{eval(m,x)} returns \\spad{(a*x + b)/(c*x + d)} where \\spad{m = moebius(a,b,c,d)} (see \\spadfunFrom{moebius}{MoebiusTransform}).")) (|recip| (($ $) "\\spad{recip(m)} = recip() * \\spad{m}") (($) "\\spad{recip()} returns \\spad{matrix [[0,1],[1,0]]} representing the map \\spad{x -> 1 / x}.")) (|scale| (($ $ |#1|) "\\spad{scale(m,h)} returns \\spad{scale(h) * m} (see \\spadfunFrom{shift}{MoebiusTransform}).") (($ |#1|) "\\spad{scale(k)} returns \\spad{matrix [[k,0],[0,1]]} representing the map \\spad{x -> k * x}.")) (|shift| (($ $ |#1|) "\\spad{shift(m,h)} returns \\spad{shift(h) * m} (see \\spadfunFrom{shift}{MoebiusTransform}).") (($ |#1|) "\\spad{shift(k)} returns \\spad{matrix [[1,k],[0,1]]} representing the map \\spad{x -> x + k}.")) (|moebius| (($ |#1| |#1| |#1| |#1|) "\\spad{moebius(a,b,c,d)} returns \\spad{matrix [[a,b],[c,d]]}."))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|Monad&| S) 
 ((|constructor| (NIL "Monad is the class of all multiplicative monads,{} \\spadignore{i.e.} sets with a binary operation.")) (** (($ $ (|PositiveInteger|)) "\\spad{a**n} returns the \\spad{n}\\spad{-}th power of \\spad{a},{} defined by repeated squaring.")) (|leftPower| (($ $ (|PositiveInteger|)) "\\spad{leftPower(a,n)} returns the \\spad{n}\\spad{-}th left power of \\spad{a},{} \\spadignore{i.e.} \\spad{leftPower(a,n) := a * leftPower(a,n-1)} and \\spad{leftPower(a,1) := a}.")) (|rightPower| (($ $ (|PositiveInteger|)) "\\spad{rightPower(a,n)} returns the \\spad{n}\\spad{-}th right power of \\spad{a},{} \\spadignore{i.e.} \\spad{rightPower(a,n) := rightPower(a,n-1) * a} and \\spad{rightPower(a,1) := a}.")) (* (($ $ $) "\\spad{a*b} is the product of \\spad{a} and \\spad{b} in a set with a binary operation."))) 
@@ -2577,11 +2577,11 @@ NIL
 NIL 
 NIL 
 (|MonadWithUnit&| S) 
-((|constructor| (NIL "\\indented{1}{MonadWithUnit is the class of multiplicative monads with unit,{}} \\indented{1}{\\spadignore{i.e.} sets with a binary operation and a unit element.} Axioms \\indented{3}{leftIdentity(\"*\":(\\%,{}\\%)->\\%,{}1)\\space{3}\\tab{30} 1*x=x} \\indented{3}{rightIdentity(\"*\":(\\%,{}\\%)->\\%,{}1)\\space{2}\\tab{30} x*1=x} Common Additional Axioms \\indented{3}{unitsKnown---if \"recip\" says \"failed\",{} that PROVES input wasn't a unit}")) (|rightRecip| (((|Union| $ "failed") $) "\\spad{rightRecip(a)} returns an element,{} which is a right inverse of \\spad{a},{} or \\spad{\"failed\"} if such an element doesn't exist or cannot be determined (see unitsKnown).")) (|leftRecip| (((|Union| $ "failed") $) "\\spad{leftRecip(a)} returns an element,{} which is a left inverse of \\spad{a},{} or \\spad{\"failed\"} if such an element doesn't exist or cannot be determined (see unitsKnown).")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(a)} returns an element,{} which is both a left and a right inverse of \\spad{a},{} or \\spad{\"failed\"} if such an element doesn't exist or cannot be determined (see unitsKnown).")) (** (($ $ (|NonNegativeInteger|)) "\\spad{a**n} returns the \\spad{n}\\spad{-}th power of \\spad{a},{} defined by repeated squaring.")) (|leftPower| (($ $ (|NonNegativeInteger|)) "\\spad{leftPower(a,n)} returns the \\spad{n}\\spad{-}th left power of \\spad{a},{} \\spadignore{i.e.} \\spad{leftPower(a,n) := a * leftPower(a,n-1)} and \\spad{leftPower(a,0) := 1}.")) (|rightPower| (($ $ (|NonNegativeInteger|)) "\\spad{rightPower(a,n)} returns the \\spad{n}\\spad{-}th right power of \\spad{a},{} \\spadignore{i.e.} \\spad{rightPower(a,n) := rightPower(a,n-1) * a} and \\spad{rightPower(a,0) := 1}.")) (|one?| (((|Boolean|) $) "\\spad{one?(a)} tests whether \\spad{a} is the unit 1.")) (|One| (($) "1 returns the unit element,{} denoted by 1."))) 
+((|constructor| (NIL "\\indented{1}{MonadWithUnit is the class of multiplicative monads with unit,{}} \\indented{1}{\\spadignore{i.e.} sets with a binary operation and a unit element.} Axioms \\indented{3}{leftIdentity(\"*\":(\\%,{}\\%)->\\%,{}1)\\space{3}\\tab{30} 1*x=x} \\indented{3}{rightIdentity(\"*\":(\\%,{}\\%)->\\%,{}1)\\space{2}\\tab{30} x*1=x}")) (|rightRecip| (((|Union| $ "failed") $) "\\spad{rightRecip(a)} returns an element,{} which is a right inverse of \\spad{a},{} or \\spad{\"failed\"} if such an element doesn't exist or cannot be determined.")) (|leftRecip| (((|Union| $ "failed") $) "\\spad{leftRecip(a)} returns an element,{} which is a left inverse of \\spad{a},{} or \\spad{\"failed\"} if such an element doesn't exist or cannot be determined.")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(a)} returns an element,{} which is both a left and a right inverse of \\spad{a},{} or \\spad{\"failed\"} if such an element doesn't exist or cannot be determined.")) (** (($ $ (|NonNegativeInteger|)) "\\spad{a**n} returns the \\spad{n}\\spad{-}th power of \\spad{a},{} defined by repeated squaring.")) (|leftPower| (($ $ (|NonNegativeInteger|)) "\\spad{leftPower(a,n)} returns the \\spad{n}\\spad{-}th left power of \\spad{a},{} \\spadignore{i.e.} \\spad{leftPower(a,n) := a * leftPower(a,n-1)} and \\spad{leftPower(a,0) := 1}.")) (|rightPower| (($ $ (|NonNegativeInteger|)) "\\spad{rightPower(a,n)} returns the \\spad{n}\\spad{-}th right power of \\spad{a},{} \\spadignore{i.e.} \\spad{rightPower(a,n) := rightPower(a,n-1) * a} and \\spad{rightPower(a,0) := 1}.")) (|one?| (((|Boolean|) $) "\\spad{one?(a)} tests whether \\spad{a} is the unit 1.")) (|One| (($) "1 returns the unit element,{} denoted by 1."))) 
 NIL 
 NIL 
 (|MonadWithUnit|) 
-((|constructor| (NIL "\\indented{1}{MonadWithUnit is the class of multiplicative monads with unit,{}} \\indented{1}{\\spadignore{i.e.} sets with a binary operation and a unit element.} Axioms \\indented{3}{leftIdentity(\"*\":(\\%,{}\\%)->\\%,{}1)\\space{3}\\tab{30} 1*x=x} \\indented{3}{rightIdentity(\"*\":(\\%,{}\\%)->\\%,{}1)\\space{2}\\tab{30} x*1=x} Common Additional Axioms \\indented{3}{unitsKnown---if \"recip\" says \"failed\",{} that PROVES input wasn't a unit}")) (|rightRecip| (((|Union| $ "failed") $) "\\spad{rightRecip(a)} returns an element,{} which is a right inverse of \\spad{a},{} or \\spad{\"failed\"} if such an element doesn't exist or cannot be determined (see unitsKnown).")) (|leftRecip| (((|Union| $ "failed") $) "\\spad{leftRecip(a)} returns an element,{} which is a left inverse of \\spad{a},{} or \\spad{\"failed\"} if such an element doesn't exist or cannot be determined (see unitsKnown).")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(a)} returns an element,{} which is both a left and a right inverse of \\spad{a},{} or \\spad{\"failed\"} if such an element doesn't exist or cannot be determined (see unitsKnown).")) (** (($ $ (|NonNegativeInteger|)) "\\spad{a**n} returns the \\spad{n}\\spad{-}th power of \\spad{a},{} defined by repeated squaring.")) (|leftPower| (($ $ (|NonNegativeInteger|)) "\\spad{leftPower(a,n)} returns the \\spad{n}\\spad{-}th left power of \\spad{a},{} \\spadignore{i.e.} \\spad{leftPower(a,n) := a * leftPower(a,n-1)} and \\spad{leftPower(a,0) := 1}.")) (|rightPower| (($ $ (|NonNegativeInteger|)) "\\spad{rightPower(a,n)} returns the \\spad{n}\\spad{-}th right power of \\spad{a},{} \\spadignore{i.e.} \\spad{rightPower(a,n) := rightPower(a,n-1) * a} and \\spad{rightPower(a,0) := 1}.")) (|one?| (((|Boolean|) $) "\\spad{one?(a)} tests whether \\spad{a} is the unit 1.")) (|One| (($) "1 returns the unit element,{} denoted by 1."))) 
+((|constructor| (NIL "\\indented{1}{MonadWithUnit is the class of multiplicative monads with unit,{}} \\indented{1}{\\spadignore{i.e.} sets with a binary operation and a unit element.} Axioms \\indented{3}{leftIdentity(\"*\":(\\%,{}\\%)->\\%,{}1)\\space{3}\\tab{30} 1*x=x} \\indented{3}{rightIdentity(\"*\":(\\%,{}\\%)->\\%,{}1)\\space{2}\\tab{30} x*1=x}")) (|rightRecip| (((|Union| $ "failed") $) "\\spad{rightRecip(a)} returns an element,{} which is a right inverse of \\spad{a},{} or \\spad{\"failed\"} if such an element doesn't exist or cannot be determined.")) (|leftRecip| (((|Union| $ "failed") $) "\\spad{leftRecip(a)} returns an element,{} which is a left inverse of \\spad{a},{} or \\spad{\"failed\"} if such an element doesn't exist or cannot be determined.")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(a)} returns an element,{} which is both a left and a right inverse of \\spad{a},{} or \\spad{\"failed\"} if such an element doesn't exist or cannot be determined.")) (** (($ $ (|NonNegativeInteger|)) "\\spad{a**n} returns the \\spad{n}\\spad{-}th power of \\spad{a},{} defined by repeated squaring.")) (|leftPower| (($ $ (|NonNegativeInteger|)) "\\spad{leftPower(a,n)} returns the \\spad{n}\\spad{-}th left power of \\spad{a},{} \\spadignore{i.e.} \\spad{leftPower(a,n) := a * leftPower(a,n-1)} and \\spad{leftPower(a,0) := 1}.")) (|rightPower| (($ $ (|NonNegativeInteger|)) "\\spad{rightPower(a,n)} returns the \\spad{n}\\spad{-}th right power of \\spad{a},{} \\spadignore{i.e.} \\spad{rightPower(a,n) := rightPower(a,n-1) * a} and \\spad{rightPower(a,0) := 1}.")) (|one?| (((|Boolean|) $) "\\spad{one?(a)} tests whether \\spad{a} is the unit 1.")) (|One| (($) "1 returns the unit element,{} denoted by 1."))) 
 NIL 
 NIL 
 (|MonogenicAlgebra&| S R UP) 
@@ -2590,14 +2590,14 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|FiniteFieldCategory|))) (|HasCategory| |#2| (QUOTE (|Field|))) (|HasCategory| |#2| (QUOTE (|Finite|)))) 
 (|MonogenicAlgebra| R UP) 
 ((|constructor| (NIL "A \\spadtype{MonogenicAlgebra} is an algebra of finite rank which can be generated by a single element.")) (|derivationCoordinates| (((|Matrix| |#1|) (|Vector| $) (|Mapping| |#1| |#1|)) "\\spad{derivationCoordinates(b, ')} returns \\spad{M} such that \\spad{b' = M b}.")) (|lift| ((|#2| $) "\\spad{lift(z)} returns a minimal degree univariate polynomial up such that \\spad{z=reduce up}.")) (|convert| (($ |#2|) "\\spad{convert(up)} converts the univariate polynomial \\spad{up} to an algebra element,{} reducing by the \\spad{definingPolynomial()} if necessary.")) (|reduce| (((|Union| $ "failed") (|Fraction| |#2|)) "\\spad{reduce(frac)} converts the fraction \\spad{frac} to an algebra element.") (($ |#2|) "\\spad{reduce(up)} converts the univariate polynomial \\spad{up} to an algebra element,{} reducing by the \\spad{definingPolynomial()} if necessary.")) (|definingPolynomial| ((|#2|) "\\spad{definingPolynomial()} returns the minimal polynomial which \\spad{generator()} satisfies.")) (|generator| (($) "\\spad{generator()} returns the generator for this domain."))) 
-((|noZeroDivisors| |has| |#1| . #1=((|Field|))) (|canonicalUnitNormal| |has| |#1| . #1#) (|canonicalsClosed| |has| |#1| . #1#) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| |has| |#1| . #1=((|Field|))) (|canonicalUnitNormal| |has| |#1| . #1#) ((|commutative| "*") . T)) 
 NIL 
 (|Monoid&| S) 
-((|constructor| (NIL "The class of multiplicative monoids,{} \\spadignore{i.e.} semigroups with a multiplicative identity element. \\blankline")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(x)} tries to compute the multiplicative inverse for \\spad{x} or \"failed\" if it cannot find the inverse (see unitsKnown).")) (** (($ $ (|NonNegativeInteger|)) "\\spad{x**n} returns the repeated product of \\spad{x} \\spad{n} times,{} \\spadignore{i.e.} exponentiation.")) (|one?| (((|Boolean|) $) "\\spad{one?(x)} tests if \\spad{x} is equal to 1.")) (|sample| (($) "\\spad{sample yields} a value of type \\%")) (|One| (($) "1 is the multiplicative identity."))) 
+((|constructor| (NIL "The class of multiplicative monoids,{} \\spadignore{i.e.} semigroups with a multiplicative identity element. \\blankline")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(x)} tries to compute the multiplicative inverse for \\spad{x} or \"failed\" if it cannot find the inverse.")) (** (($ $ (|NonNegativeInteger|)) "\\spad{x**n} returns the repeated product of \\spad{x} \\spad{n} times,{} \\spadignore{i.e.} exponentiation.")) (|one?| (((|Boolean|) $) "\\spad{one?(x)} tests if \\spad{x} is equal to 1.")) (|sample| (($) "\\spad{sample yields} a value of type \\%")) (|One| (($) "1 is the multiplicative identity."))) 
 NIL 
 NIL 
 (|Monoid|) 
-((|constructor| (NIL "The class of multiplicative monoids,{} \\spadignore{i.e.} semigroups with a multiplicative identity element. \\blankline")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(x)} tries to compute the multiplicative inverse for \\spad{x} or \"failed\" if it cannot find the inverse (see unitsKnown).")) (** (($ $ (|NonNegativeInteger|)) "\\spad{x**n} returns the repeated product of \\spad{x} \\spad{n} times,{} \\spadignore{i.e.} exponentiation.")) (|one?| (((|Boolean|) $) "\\spad{one?(x)} tests if \\spad{x} is equal to 1.")) (|sample| (($) "\\spad{sample yields} a value of type \\%")) (|One| (($) "1 is the multiplicative identity."))) 
+((|constructor| (NIL "The class of multiplicative monoids,{} \\spadignore{i.e.} semigroups with a multiplicative identity element. \\blankline")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(x)} tries to compute the multiplicative inverse for \\spad{x} or \"failed\" if it cannot find the inverse.")) (** (($ $ (|NonNegativeInteger|)) "\\spad{x**n} returns the repeated product of \\spad{x} \\spad{n} times,{} \\spadignore{i.e.} exponentiation.")) (|one?| (((|Boolean|) $) "\\spad{one?(x)} tests if \\spad{x} is equal to 1.")) (|sample| (($) "\\spad{sample yields} a value of type \\%")) (|One| (($) "1 is the multiplicative identity."))) 
 NIL 
 NIL 
 (|MonoidOperation| T$) 
@@ -2626,8 +2626,8 @@ NIL
 NIL 
 (|MultivariatePolynomial| |vl| R) 
 ((|constructor| (NIL "\\indented{2}{This type is the basic representation of sparse recursive multivariate} polynomials whose variables are from a user specified list of symbols. The ordering is specified by the position of the variable in the list. The coefficient ring may be non commutative,{} but the variables are assumed to commute."))) 
-(((|commutative| "*") |has| |#2| (|CommutativeRing|)) (|noZeroDivisors| |has| |#2| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#2| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#2| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#2| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#2| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|OrderedVariableList| |#1|) #5#)) (AND (|HasCategory| |#2| #8=(QUOTE (|PatternMatchable| #9=(|Integer|)))) (|HasCategory| #7# #8#)) (AND (|HasCategory| |#2| #10=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #10#)) (AND (|HasCategory| |#2| #11=(QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#2| #12=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #12#)) (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #9#))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) #13=(|HasCategory| |#2| #14=(QUOTE (|CharacteristicNonZero|))) #15=(|HasCategory| |#2| (QUOTE (|Algebra| #16=(|Fraction| #9#)))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #9#))) (OR #15# #17=(|HasCategory| |#2| (QUOTE (|RetractableTo| #16#)))) #17# (|HasCategory| |#2| (QUOTE (|Field|))) (|HasAttribute| |#2| (QUOTE |canonicalUnitNormal|)) #3# #18=(AND #1# (|HasCategory| $ #14#)) (OR #18# #13#)) 
+(((|commutative| "*") |has| |#2| (|CommutativeRing|)) (|noZeroDivisors| |has| |#2| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#2| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#2| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#2| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#2| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|OrderedVariableList| |#1|) #5#)) (AND (|HasCategory| |#2| #8=(QUOTE (|PatternMatchable| #9=(|Integer|)))) (|HasCategory| #7# #8#)) (AND (|HasCategory| |#2| #10=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #10#)) (AND (|HasCategory| |#2| #11=(QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#2| #12=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #12#)) (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #9#))) #13=(|HasCategory| |#2| (QUOTE (|Algebra| #14=(|Fraction| #9#)))) #15=(|HasCategory| |#2| #16=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #9#))) (OR #13# #17=(|HasCategory| |#2| (QUOTE (|RetractableTo| #14#)))) #17# (|HasCategory| |#2| (QUOTE (|Field|))) (|HasAttribute| |#2| (QUOTE |canonicalUnitNormal|)) #3# #18=(AND #1# (|HasCategory| $ #16#)) (OR #18# #15#)) 
 (|MPolyCatRationalFunctionFactorizer| E OV R PRF) 
 ((|constructor| (NIL "\\indented{3}{This package exports a factor operation for multivariate polynomials} with coefficients which are rational functions over some ring \\spad{R} over which we can factor. It is used internally by packages such as primary decomposition which need to work with polynomials with rational function coefficients,{} \\spadignore{i.e.} themselves fractions of polynomials.")) (|factor| (((|Factored| |#4|) |#4|) "\\spad{factor(prf)} factors a polynomial with rational function coefficients.")) (|pushuconst| ((|#4| (|Fraction| (|Polynomial| |#3|)) |#2|) "\\spad{pushuconst(r,var)} takes a rational function and raises all occurances of the variable \\spad{var} to the polynomial level.")) (|pushucoef| ((|#4| (|SparseUnivariatePolynomial| (|Polynomial| |#3|)) |#2|) "\\spad{pushucoef(upoly,var)} converts the anonymous univariate polynomial \\spad{upoly} to a polynomial in \\spad{var} over rational functions.")) (|pushup| ((|#4| |#4| |#2|) "\\spad{pushup(prf,var)} raises all occurences of the variable \\spad{var} in the coefficients of the polynomial \\spad{prf} back to the polynomial level.")) (|pushdterm| ((|#4| (|SparseUnivariatePolynomial| |#4|) |#2|) "\\spad{pushdterm(monom,var)} pushes all top level occurences of the variable \\spad{var} into the coefficient domain for the monomial \\spad{monom}.")) (|pushdown| ((|#4| |#4| |#2|) "\\spad{pushdown(prf,var)} pushes all top level occurences of the variable \\spad{var} into the coefficient domain for the polynomial \\spad{prf}.")) (|totalfract| (((|Record| (|:| |sup| (|Polynomial| |#3|)) (|:| |inf| (|Polynomial| |#3|))) |#4|) "\\spad{totalfract(prf)} takes a polynomial whose coefficients are themselves fractions of polynomials and returns a record containing the numerator and denominator resulting from putting \\spad{prf} over a common denominator.")) (|convert| (((|Symbol|) $) "\\spad{convert(x)} converts \\spad{x} to a symbol"))) 
 NIL 
@@ -2642,7 +2642,7 @@ NIL
 NIL 
 (|MonoidRing| R M) 
 ((|constructor| (NIL "\\spadtype{MonoidRing}(\\spad{R},{}\\spad{M}),{} implements the algebra of all maps from the monoid \\spad{M} to the commutative ring \\spad{R} with finite support. Multiplication of two maps \\spad{f} and \\spad{g} is defined to map an element \\spad{c} of \\spad{M} to the (convolution) sum over {\\em f(a)g(b)} such that {\\em ab = c}. Thus \\spad{M} can be identified with a canonical basis and the maps can also be considered as formal linear combinations of the elements in \\spad{M}. Scalar multiples of a basis element are called monomials. A prominent example is the class of polynomials where the monoid is a direct product of the natural numbers with pointwise addition. When \\spad{M} is \\spadtype{FreeMonoid Symbol},{} one gets polynomials in infinitely many non-commuting variables. Another application area is representation theory of finite groups \\spad{G},{} where modules over \\spadtype{MonoidRing}(\\spad{R},{}\\spad{G}) are studied.")) (|reductum| (($ $) "\\spad{reductum(f)} is \\spad{f} minus its leading monomial.")) (|leadingCoefficient| ((|#1| $) "\\spad{leadingCoefficient(f)} gives the coefficient of \\spad{f},{} whose corresponding monoid element is the greatest among all those with non-zero coefficients.")) (|leadingMonomial| ((|#2| $) "\\spad{leadingMonomial(f)} gives the monomial of \\spad{f} whose corresponding monoid element is the greatest among all those with non-zero coefficients.")) (|numberOfMonomials| (((|NonNegativeInteger|) $) "\\spad{numberOfMonomials(f)} is the number of non-zero coefficients with respect to the canonical basis.")) (|monomials| (((|List| $) $) "\\spad{monomials(f)} gives the list of all monomials whose sum is \\spad{f}.")) (|coefficients| (((|List| |#1|) $) "\\spad{coefficients(f)} lists all non-zero coefficients.")) (|monomial?| (((|Boolean|) $) "\\spad{monomial?(f)} tests if \\spad{f} is a single monomial.")) (|terms| (((|List| (|Record| (|:| |coef| |#1|) (|:| |monom| |#2|))) $) "\\spad{terms(f)} gives the list of non-zero coefficients combined with their corresponding basis element as records. This is the internal representation.")) (|coerce| (($ (|List| (|Record| (|:| |coef| |#1|) (|:| |monom| |#2|)))) "\\spad{coerce(lt)} converts a list of terms and coefficients to a member of the domain.")) (|coefficient| ((|#1| $ |#2|) "\\spad{coefficient(f,m)} extracts the coefficient of \\spad{m} in \\spad{f} with respect to the canonical basis \\spad{M}.")) (|monomial| (($ |#1| |#2|) "\\spad{monomial(r,m)} creates a scalar multiple of the basis element \\spad{m}."))) 
-((|leftUnitary| |has| |#1| . #1=((|CommutativeRing|))) (|rightUnitary| |has| |#1| . #1#) (|unitsKnown| . T)) 
+NIL 
 ((AND (|HasCategory| |#1| #1=(QUOTE (|Finite|))) (|HasCategory| |#2| #1#)) (|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|OrderedSet|)))) 
 (|Multiset| S) 
 ((|constructor| (NIL "A multiset is a set with multiplicities.")) (|remove!| (($ (|Mapping| (|Boolean|) |#1|) $ (|Integer|)) "\\spad{remove!(p,ms,number)} removes destructively at most \\spad{number} copies of elements \\spad{x} such that \\spad{p(x)} is \\spadfun{\\spad{true}} if \\spad{number} is positive,{} all of them if \\spad{number} equals zero,{} and all but at most \\spad{-number} if \\spad{number} is negative.") (($ |#1| $ (|Integer|)) "\\spad{remove!(x,ms,number)} removes destructively at most \\spad{number} copies of element \\spad{x} if \\spad{number} is positive,{} all of them if \\spad{number} equals zero,{} and all but at most \\spad{-number} if \\spad{number} is negative.")) (|remove| (($ (|Mapping| (|Boolean|) |#1|) $ (|Integer|)) "\\spad{remove(p,ms,number)} removes at most \\spad{number} copies of elements \\spad{x} such that \\spad{p(x)} is \\spadfun{\\spad{true}} if \\spad{number} is positive,{} all of them if \\spad{number} equals zero,{} and all but at most \\spad{-number} if \\spad{number} is negative.") (($ |#1| $ (|Integer|)) "\\spad{remove(x,ms,number)} removes at most \\spad{number} copies of element \\spad{x} if \\spad{number} is positive,{} all of them if \\spad{number} equals zero,{} and all but at most \\spad{-number} if \\spad{number} is negative.")) (|unique| (((|List| |#1|) $) "\\spad{unique ms} returns a list of the elements of \\spad{ms} {\\em without} their multiplicity. See also \\spadfun{members}.")) (|multiset| (($ (|List| |#1|)) "\\spad{multiset(ls)} creates a multiset with elements from \\spad{ls}.") (($ |#1|) "\\spad{multiset(s)} creates a multiset with singleton \\spad{s}.") (($) "\\spad{multiset()}\\$\\spad{D} creates an empty multiset of domain \\spad{D}."))) 
@@ -2662,7 +2662,7 @@ NIL
 NIL 
 (|MultivariateTaylorSeriesCategory| |Coef| |Var|) 
 ((|constructor| (NIL "\\spadtype{MultivariateTaylorSeriesCategory} is the most general multivariate Taylor series category.")) (|integrate| (($ $ |#2|) "\\spad{integrate(f,x)} returns the anti-derivative of the power series \\spad{f(x)} with respect to the variable \\spad{x} with constant coefficient 1. We may integrate a series when we can divide coefficients by integers.")) (|polynomial| (((|Polynomial| |#1|) $ (|NonNegativeInteger|) (|NonNegativeInteger|)) "\\spad{polynomial(f,k1,k2)} returns a polynomial consisting of the sum of all terms of \\spad{f} of degree \\spad{d} with \\spad{k1 <= d <= k2}.") (((|Polynomial| |#1|) $ (|NonNegativeInteger|)) "\\spad{polynomial(f,k)} returns a polynomial consisting of the sum of all terms of \\spad{f} of degree \\spad{<= k}.")) (|order| (((|NonNegativeInteger|) $ |#2| (|NonNegativeInteger|)) "\\spad{order(f,x,n)} returns \\spad{min(n,order(f,x))}.") (((|NonNegativeInteger|) $ |#2|) "\\spad{order(f,x)} returns the order of \\spad{f} viewed as a series in \\spad{x} may result in an infinite loop if \\spad{f} has no non-zero terms.")) (|monomial| (($ $ (|List| |#2|) (|List| (|NonNegativeInteger|))) "\\spad{monomial(a,[x1,x2,...,xk],[n1,n2,...,nk])} returns \\spad{a * x1^n1 * ... * xk^nk}.") (($ $ |#2| (|NonNegativeInteger|)) "\\spad{monomial(a,x,n)} returns \\spad{a*x^n}.")) (|extend| (($ $ (|NonNegativeInteger|)) "\\spad{extend(f,n)} causes all terms of \\spad{f} of degree \\spad{<= n} to be computed.")) (|coefficient| (($ $ (|List| |#2|) (|List| (|NonNegativeInteger|))) "\\spad{coefficient(f,[x1,x2,...,xk],[n1,n2,...,nk])} returns the coefficient of \\spad{x1^n1 * ... * xk^nk} in \\spad{f}.") (($ $ |#2| (|NonNegativeInteger|)) "\\spad{coefficient(f,x,n)} returns the coefficient of \\spad{x^n} in \\spad{f}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|))) 
 NIL 
 (|MultivariateFactorize| OV E R P) 
 ((|constructor| (NIL "\\indented{2}{This is the top level package for doing multivariate factorization} over basic domains like \\spadtype{Integer} or \\spadtype{Fraction Integer}.")) (|factor| (((|Factored| (|SparseUnivariatePolynomial| |#4|)) (|SparseUnivariatePolynomial| |#4|)) "\\spad{factor(p)} factors the multivariate polynomial \\spad{p} over its coefficient domain where \\spad{p} is represented as a univariate polynomial with multivariate coefficients") (((|Factored| |#4|) |#4|) "\\spad{factor(p)} factors the multivariate polynomial \\spad{p} over its coefficient domain"))) 
@@ -2678,7 +2678,7 @@ NIL
 NIL 
 (|NonAssociativeAlgebra| R) 
 ((|constructor| (NIL "NonAssociativeAlgebra is the category of non associative algebras (modules which are themselves non associative rngs). Axioms \\indented{3}{r*(a*b) = (r*a)*b = a*(r*b)}")) (|plenaryPower| (($ $ (|PositiveInteger|)) "\\spad{plenaryPower(a,n)} is recursively defined to be \\spad{plenaryPower(a,n-1)*plenaryPower(a,n-1)} for \\spad{n>1} and \\spad{a} for \\spad{n=1}."))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 NIL 
 (|NonAssociativeRng&| S) 
 ((|constructor| (NIL "NonAssociativeRng is a basic ring-type structure,{} not necessarily commutative or associative,{} and not necessarily with unit. Axioms \\indented{2}{x*(y+z) = x*y + x*z} \\indented{2}{(x+y)*z = x*z + y*z} Common Additional Axioms \\indented{2}{noZeroDivisors\\space{2}ab = 0 => \\spad{a=0} or \\spad{b=0}}")) (|antiCommutator| (($ $ $) "\\spad{antiCommutator(a,b)} returns \\spad{a*b+b*a}.")) (|commutator| (($ $ $) "\\spad{commutator(a,b)} returns \\spad{a*b-b*a}.")) (|associator| (($ $ $ $) "\\spad{associator(a,b,c)} returns \\spad{(a*b)*c-a*(b*c)}."))) 
@@ -2758,12 +2758,12 @@ NIL
 NIL 
 (|NewSparseMultivariatePolynomial| R |VarSet|) 
 ((|constructor| (NIL "A post-facto extension for \\axiomType{SMP} in order to speed up operations related to pseudo-division and gcd. This domain is based on the \\axiomType{NSUP} constructor which is itself a post-facto extension of the \\axiomType{SUP} constructor."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#1| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| |#2| #5#)) (AND (|HasCategory| |#1| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| |#2| #7#)) (AND (|HasCategory| |#1| #9=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| |#2| #9#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| |#2| #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#2| #11#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #8#))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #12=(|HasCategory| |#1| #13=(QUOTE (|CharacteristicNonZero|))) #14=(|HasCategory| |#1| (QUOTE (|Algebra| #15=(|Fraction| #8#)))) #16=(|HasCategory| |#1| (QUOTE (|RetractableTo| #8#))) (OR #14# #17=(|HasCategory| |#1| (QUOTE (|RetractableTo| #15#)))) #17# (AND #16# #18=(|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Symbol|))))) #18# (|HasCategory| |#1| (QUOTE (|Field|))) #19=(AND #14# #18#) (OR (AND #20=(|HasCategory| |#1| (QUOTE (|Algebra| #8#))) #18# #21=(|not| #14#)) #19#) (OR (AND #18# #21# (|not| #20#)) (AND #20# #18# #21# (|not| (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|))))) (AND #14# #18# (|not| (|HasCategory| |#1| (QUOTE (|QuotientFieldCategory| #8#)))))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #3# #22=(AND #1# (|HasCategory| $ #13#)) (OR #22# #12#)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#1| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| |#2| #5#)) (AND (|HasCategory| |#1| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| |#2| #7#)) (AND (|HasCategory| |#1| #9=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| |#2| #9#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| |#2| #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#2| #11#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #8#))) #12=(|HasCategory| |#1| (QUOTE (|Algebra| #13=(|Fraction| #8#)))) #14=(|HasCategory| |#1| #15=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #16=(|HasCategory| |#1| (QUOTE (|RetractableTo| #8#))) (OR #12# #17=(|HasCategory| |#1| (QUOTE (|RetractableTo| #13#)))) #17# (AND #16# #18=(|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Symbol|))))) #18# (|HasCategory| |#1| (QUOTE (|Field|))) #19=(AND #12# #18#) (OR (AND #20=(|HasCategory| |#1| (QUOTE (|Algebra| #8#))) #18# #21=(|not| #12#)) #19#) (OR (AND #18# #21# (|not| #20#)) (AND #20# #18# #21# (|not| (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|))))) (AND #12# #18# (|not| (|HasCategory| |#1| (QUOTE (|QuotientFieldCategory| #8#)))))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #3# #22=(AND #1# (|HasCategory| $ #15#)) (OR #22# #14#)) 
 (|NewSparseUnivariatePolynomial| R) 
 ((|constructor| (NIL "A post-facto extension for \\axiomType{SUP} in order to speed up operations related to pseudo-division and gcd for both \\axiomType{SUP} and,{} consequently,{} \\axiomType{NSMP}.")) (|halfExtendedResultant2| (((|Record| (|:| |resultant| |#1|) (|:| |coef2| $)) $ $) "\\axiom{\\spad{halfExtendedResultant2}(a,{}\\spad{b})} returns \\axiom{[\\spad{r},{}ca]} such that \\axiom{extendedResultant(a,{}\\spad{b})} returns \\axiom{[\\spad{r},{}ca,{} cb]}")) (|halfExtendedResultant1| (((|Record| (|:| |resultant| |#1|) (|:| |coef1| $)) $ $) "\\axiom{\\spad{halfExtendedResultant1}(a,{}\\spad{b})} returns \\axiom{[\\spad{r},{}ca]} such that \\axiom{extendedResultant(a,{}\\spad{b})} returns \\axiom{[\\spad{r},{}ca,{} cb]}")) (|extendedResultant| (((|Record| (|:| |resultant| |#1|) (|:| |coef1| $) (|:| |coef2| $)) $ $) "\\axiom{extendedResultant(a,{}\\spad{b})} returns \\axiom{[\\spad{r},{}ca,{}cb]} such that \\axiom{\\spad{r}} is the resultant of \\axiom{a} and \\axiom{\\spad{b}} and \\axiom{\\spad{r} = ca * a + cb * \\spad{b}}")) (|halfExtendedSubResultantGcd2| (((|Record| (|:| |gcd| $) (|:| |coef2| $)) $ $) "\\axiom{\\spad{halfExtendedSubResultantGcd2}(a,{}\\spad{b})} returns \\axiom{[\\spad{g},{}cb]} such that \\axiom{extendedSubResultantGcd(a,{}\\spad{b})} returns \\axiom{[\\spad{g},{}ca,{} cb]}")) (|halfExtendedSubResultantGcd1| (((|Record| (|:| |gcd| $) (|:| |coef1| $)) $ $) "\\axiom{\\spad{halfExtendedSubResultantGcd1}(a,{}\\spad{b})} returns \\axiom{[\\spad{g},{}ca]} such that \\axiom{extendedSubResultantGcd(a,{}\\spad{b})} returns \\axiom{[\\spad{g},{}ca,{} cb]}")) (|extendedSubResultantGcd| (((|Record| (|:| |gcd| $) (|:| |coef1| $) (|:| |coef2| $)) $ $) "\\axiom{extendedSubResultantGcd(a,{}\\spad{b})} returns \\axiom{[\\spad{g},{}ca,{} cb]} such that \\axiom{\\spad{g}} is a gcd of \\axiom{a} and \\axiom{\\spad{b}} in \\axiom{R^(\\spad{-1}) \\spad{P}} and \\axiom{\\spad{g} = ca * a + cb * \\spad{b}}")) (|lastSubResultant| (($ $ $) "\\axiom{lastSubResultant(a,{}\\spad{b})} returns \\axiom{resultant(a,{}\\spad{b})} if \\axiom{a} and \\axiom{\\spad{b}} has no non-trivial gcd in \\axiom{R^(\\spad{-1}) \\spad{P}} otherwise the non-zero sub-resultant with smallest index.")) (|subResultantsChain| (((|List| $) $ $) "\\axiom{subResultantsChain(a,{}\\spad{b})} returns the list of the non-zero sub-resultants of \\axiom{a} and \\axiom{\\spad{b}} sorted by increasing degree.")) (|lazyPseudoQuotient| (($ $ $) "\\axiom{lazyPseudoQuotient(a,{}\\spad{b})} returns \\axiom{\\spad{q}} if \\axiom{lazyPseudoDivide(a,{}\\spad{b})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{q},{}\\spad{r}]}")) (|lazyPseudoDivide| (((|Record| (|:| |coef| |#1|) (|:| |gap| (|NonNegativeInteger|)) (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\axiom{lazyPseudoDivide(a,{}\\spad{b})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{q},{}\\spad{r}]} such that \\axiom{c^n * a = q*b +r} and \\axiom{lazyResidueClass(a,{}\\spad{b})} returns \\axiom{[\\spad{r},{}\\spad{c},{}\\spad{n}]} where \\axiom{\\spad{n} + \\spad{g} = max(0,{} degree(\\spad{b}) - degree(a) + 1)}.")) (|lazyPseudoRemainder| (($ $ $) "\\axiom{lazyPseudoRemainder(a,{}\\spad{b})} returns \\axiom{\\spad{r}} if \\axiom{lazyResidueClass(a,{}\\spad{b})} returns \\axiom{[\\spad{r},{}\\spad{c},{}\\spad{n}]}. This lazy pseudo-remainder is computed by means of the \\axiomOpFrom{fmecg}{NewSparseUnivariatePolynomial} operation.")) (|lazyResidueClass| (((|Record| (|:| |polnum| $) (|:| |polden| |#1|) (|:| |power| (|NonNegativeInteger|))) $ $) "\\axiom{lazyResidueClass(a,{}\\spad{b})} returns \\axiom{[\\spad{r},{}\\spad{c},{}\\spad{n}]} such that \\axiom{\\spad{r}} is reduced \\spad{w}.\\spad{r}.\\spad{t}. \\axiom{\\spad{b}} and \\axiom{\\spad{b}} divides \\axiom{c^n * a - \\spad{r}} where \\axiom{\\spad{c}} is \\axiom{leadingCoefficient(\\spad{b})} and \\axiom{\\spad{n}} is as small as possible with the previous properties.")) (|monicModulo| (($ $ $) "\\axiom{monicModulo(a,{}\\spad{b})} returns \\axiom{\\spad{r}} such that \\axiom{\\spad{r}} is reduced \\spad{w}.\\spad{r}.\\spad{t}. \\axiom{\\spad{b}} and \\axiom{\\spad{b}} divides \\axiom{a -r} where \\axiom{\\spad{b}} is monic.")) (|fmecg| (($ $ (|NonNegativeInteger|) |#1| $) "\\axiom{fmecg(\\spad{p1},{}\\spad{e},{}\\spad{r},{}\\spad{p2})} returns \\axiom{\\spad{p1} - \\spad{r} * X**e * \\spad{p2}} where \\axiom{\\spad{X}} is \\axiom{monomial(1,{}1)}"))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|additiveValuation| |has| |#1| (|Field|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) #2=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #3=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #3# #2#) (AND (|HasCategory| |#1| #4=(QUOTE (|PatternMatchable| #5=(|Float|)))) (|HasCategory| #6=(|SingletonAsOrderedSet|) #4#)) (AND (|HasCategory| |#1| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| #6# #7#)) (AND (|HasCategory| |#1| #9=(QUOTE (|ConvertibleTo| (|Pattern| #5#)))) (|HasCategory| #6# #9#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #6# #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #6# #11#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #8#))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #12=(|HasCategory| |#1| #13=(QUOTE (|CharacteristicNonZero|))) #14=(|HasCategory| |#1| (QUOTE (|Algebra| #15=(|Fraction| #8#)))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #8#))) (OR #14# #16=(|HasCategory| |#1| (QUOTE (|RetractableTo| #15#)))) #16# (OR #3# #17=(|HasCategory| |#1| (QUOTE (|Field|))) #18=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #2# #1#) (OR #17# #18# #2# #1#) (OR #17# #18# #1#) #17# (|HasCategory| |#1| (QUOTE (|StepThrough|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #19=(|Symbol|)))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #19#))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #18# #20=(AND #1# (|HasCategory| $ #13#)) (OR #20# #12#)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|additiveValuation| |has| |#1| (|Field|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) #2=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #3=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #3# #2#) (AND (|HasCategory| |#1| #4=(QUOTE (|PatternMatchable| #5=(|Float|)))) (|HasCategory| #6=(|SingletonAsOrderedSet|) #4#)) (AND (|HasCategory| |#1| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| #6# #7#)) (AND (|HasCategory| |#1| #9=(QUOTE (|ConvertibleTo| (|Pattern| #5#)))) (|HasCategory| #6# #9#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #6# #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #6# #11#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #8#))) #12=(|HasCategory| |#1| (QUOTE (|Algebra| #13=(|Fraction| #8#)))) #14=(|HasCategory| |#1| #15=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #8#))) (OR #12# #16=(|HasCategory| |#1| (QUOTE (|RetractableTo| #13#)))) #16# (OR #3# #17=(|HasCategory| |#1| (QUOTE (|Field|))) #18=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #2# #1#) (OR #17# #18# #2# #1#) (OR #17# #18# #1#) #17# (|HasCategory| |#1| (QUOTE (|StepThrough|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #19=(|Symbol|)))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #19#))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #18# #20=(AND #1# (|HasCategory| $ #15#)) (OR #20# #14#)) 
 (|NewSparseUnivariatePolynomialFunctions2| R S) 
 ((|constructor| (NIL "This package lifts a mapping from coefficient rings \\spad{R} to \\spad{S} to a mapping from sparse univariate polynomial over \\spad{R} to a sparse univariate polynomial over \\spad{S}. Note that the mapping is assumed to send zero to zero,{} since it will only be applied to the non-zero coefficients of the polynomial.")) (|map| (((|NewSparseUnivariatePolynomial| |#2|) (|Mapping| |#2| |#1|) (|NewSparseUnivariatePolynomial| |#1|)) "\\axiom{map(func,{} poly)} creates a new polynomial by applying func to every non-zero coefficient of the polynomial poly."))) 
 NIL 
@@ -2826,7 +2826,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|Field|))) (|HasCategory| |#2| (QUOTE (|IntegerNumberSystem|))) (|HasCategory| |#2| (QUOTE (|RealNumberSystem|))) (|HasCategory| |#2| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#2| (QUOTE (|OrderedSet|))) (|HasCategory| |#2| (QUOTE (|Finite|)))) 
 (|OctonionCategory| R) 
 ((|constructor| (NIL "OctonionCategory gives the categorial frame for the octonions,{} and eight-dimensional non-associative algebra,{} doubling the the quaternions in the same way as doubling the Complex numbers to get the quaternions.")) (|inv| (($ $) "\\spad{inv(o)} returns the inverse of \\spad{o} if it exists.")) (|rationalIfCan| (((|Union| (|Fraction| (|Integer|)) "failed") $) "\\spad{rationalIfCan(o)} returns the real part if all seven imaginary parts are 0,{} and \"failed\" otherwise.")) (|rational| (((|Fraction| (|Integer|)) $) "\\spad{rational(o)} returns the real part if all seven imaginary parts are 0. Error: if \\spad{o} is not rational.")) (|rational?| (((|Boolean|) $) "\\spad{rational?(o)} tests if \\spad{o} is rational,{} \\spadignore{i.e.} that all seven imaginary parts are 0.")) (|abs| ((|#1| $) "\\spad{abs(o)} computes the absolute value of an octonion,{} equal to the square root of the \\spadfunFrom{norm}{Octonion}.")) (|octon| (($ |#1| |#1| |#1| |#1| |#1| |#1| |#1| |#1|) "\\spad{octon(re,ri,rj,rk,rE,rI,rJ,rK)} constructs an octonion from scalars.")) (|norm| ((|#1| $) "\\spad{norm(o)} returns the norm of an octonion,{} equal to the sum of the squares of its coefficients.")) (|imagK| ((|#1| $) "\\spad{imagK(o)} extracts the imaginary \\spad{K} part of octonion \\spad{o}.")) (|imagJ| ((|#1| $) "\\spad{imagJ(o)} extracts the imaginary \\spad{J} part of octonion \\spad{o}.")) (|imagI| ((|#1| $) "\\spad{imagI(o)} extracts the imaginary \\spad{I} part of octonion \\spad{o}.")) (|imagE| ((|#1| $) "\\spad{imagE(o)} extracts the imaginary \\spad{E} part of octonion \\spad{o}.")) (|imagk| ((|#1| $) "\\spad{imagk(o)} extracts the \\spad{k} part of octonion \\spad{o}.")) (|imagj| ((|#1| $) "\\spad{imagj(o)} extracts the \\spad{j} part of octonion \\spad{o}.")) (|imagi| ((|#1| $) "\\spad{imagi(o)} extracts the \\spad{i} part of octonion \\spad{o}.")) (|real| ((|#1| $) "\\spad{real(o)} extracts real part of octonion \\spad{o}.")) (|conjugate| (($ $) "\\spad{conjugate(o)} negates the imaginary parts \\spad{i},{}\\spad{j},{}\\spad{k},{}\\spad{E},{}\\spad{I},{}\\spad{J},{}\\spad{K} of octonian \\spad{o}."))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 NIL 
 (|OrderedCancellationAbelianMonoid|) 
 ((|constructor| (NIL "Ordered sets which are also abelian cancellation monoids,{} such that the addition preserves the ordering."))) 
@@ -2834,8 +2834,8 @@ NIL
 NIL 
 (|Octonion| R) 
 ((|constructor| (NIL "Octonion implements octonions (Cayley-Dixon algebra) over a commutative ring,{} an eight-dimensional non-associative algebra,{} doubling the quaternions in the same way as doubling the complex numbers to get the quaternions the main constructor function is {\\em octon} which takes 8 arguments: the real part,{} the \\spad{i} imaginary part,{} the \\spad{j} imaginary part,{} the \\spad{k} imaginary part,{} (as with quaternions) and in addition the imaginary parts \\spad{E},{} \\spad{I},{} \\spad{J},{} \\spad{K}.")) (|octon| (($ (|Quaternion| |#1|) (|Quaternion| |#1|)) "\\spad{octon(qe,qE)} constructs an octonion from two quaternions using the relation {\\em O = Q + QE}."))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-((|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#1| (QUOTE (|OrderedSet|))) (|HasCategory| |#1| (QUOTE (|Finite|))) (|HasCategory| |#1| (|%list| (QUOTE |InnerEvalable|) (QUOTE (|Symbol|)) #1=(|devaluate| |#1|))) (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) #1#)) (|HasCategory| |#1| (|%list| (QUOTE |Eltable|) #1# #1#)) (OR #2=(|HasCategory| |#1| #3=(QUOTE (|RetractableTo| (|Fraction| #4=(|Integer|))))) #5=(|HasCategory| #6=(|Quaternion| |#1|) #3#)) (OR #7=(|HasCategory| |#1| #8=(QUOTE (|RetractableTo| #4#))) #9=(|HasCategory| #6# #8#)) (|HasCategory| |#1| (QUOTE (|RealNumberSystem|))) (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|))) (|HasCategory| |#1| (QUOTE (|Field|))) #5# #9# #2# #7#) 
+NIL 
+((|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#1| (QUOTE (|OrderedSet|))) (|HasCategory| |#1| (QUOTE (|Finite|))) (|HasCategory| |#1| (|%list| (QUOTE |InnerEvalable|) (QUOTE (|Symbol|)) #1=(|devaluate| |#1|))) (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) #1#)) (|HasCategory| |#1| (|%list| (QUOTE |Eltable|) #1# #1#)) (OR #2=(|HasCategory| |#1| #3=(QUOTE (|RetractableTo| (|Fraction| #4=(|Integer|))))) #5=(|HasCategory| #6=(|Quaternion| |#1|) #3#)) (OR #7=(|HasCategory| |#1| #8=(QUOTE (|RetractableTo| #4#))) #9=(|HasCategory| #6# #8#)) (|HasCategory| |#1| (QUOTE (|RealNumberSystem|))) (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|))) (|HasCategory| |#1| (QUOTE (|Field|))) #5# #9# #7# #2#) 
 (|OctonionCategoryFunctions2| OR R OS S) 
 ((|constructor| (NIL "\\spad{OctonionCategoryFunctions2} implements functions between two octonion domains defined over different rings. The function map is used to coerce between octonion types.")) (|map| ((|#3| (|Mapping| |#4| |#2|) |#1|) "\\spad{map(f,u)} maps \\spad{f} onto the component parts of the octonion \\spad{u}."))) 
 NIL 
@@ -2886,15 +2886,15 @@ NIL
 NIL 
 (|OrderedDirectProduct| |dim| S |f|) 
 ((|constructor| (NIL "\\indented{2}{This type represents the finite direct or cartesian product of an} underlying ordered component type. The ordering on the type is determined by its third argument which represents the less than function on vectors. This type is a suitable third argument for \\spadtype{GeneralDistributedMultivariatePolynomial}."))) 
-((|rightUnitary| |has| |#2| . #1=((|Ring|))) (|leftUnitary| |has| |#2| . #1#) (|unitsKnown| |has| |#2| (ATTRIBUTE |unitsKnown|))) 
-((OR (AND #1=(|HasCategory| |#2| (QUOTE (|AbelianGroup|))) #2=(|HasCategory| |#2| (|%list| (QUOTE |Evalable|) #3=(|devaluate| |#2|)))) (AND #4=(|HasCategory| |#2| (QUOTE (|AbelianMonoid|))) #2#) (AND #5=(|HasCategory| |#2| (QUOTE (|AbelianSemiGroup|))) #2#) (AND #6=(|HasCategory| |#2| (QUOTE (|CancellationAbelianMonoid|))) #2#) (AND #7=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #2#) (AND #8=(|HasCategory| |#2| (QUOTE (|DifferentialRing|))) #2#) (AND #9=(|HasCategory| |#2| (QUOTE (|Field|))) #2#) (AND #10=(|HasCategory| |#2| (QUOTE (|Finite|))) #2#) (AND #11=(|HasCategory| |#2| (QUOTE (|Monoid|))) #2#) (AND #12=(|HasCategory| |#2| (QUOTE (|OrderedAbelianMonoidSup|))) #2#) (AND #13=(|HasCategory| |#2| #14=(QUOTE (|OrderedSet|))) #2#) (AND #15=(|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #16=(|Symbol|)))) #2#) (AND #17=(|HasCategory| |#2| (QUOTE (|Ring|))) #2#) #18=(AND #19=(|HasCategory| |#2| (QUOTE (|SetCategory|))) #2#)) (|HasCategory| |#2| (QUOTE (|CoercibleTo| (|OutputForm|)))) #9# (OR #7# #9# #17#) (OR #7# #9#) #1# #17# #11# #12# (OR #12# #13#) #13# #10# (OR (AND #7# #20=(|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #21=(|Integer|))))) (AND #8# #20#) (AND #9# #20#) (AND #20# #15#) #22=(AND #20# #17#)) #15# (OR #1# #4# #5# #23=(|HasCategory| |#2| (QUOTE (|BasicType|))) #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #15# #17#) (OR #1# #4# #6# #7# #8# #9# #15# #17#) (OR #1# #6# #7# #8# #9# #15# #17#) (OR #1# #7# #8# #9# #15# #17#) (OR #8# #15# #17#) #8# (OR #8# #24=(AND (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) #17#)) (OR #25=(AND (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #16#))) #17#) #15#) #19# (OR (AND #1# #26=(|HasCategory| |#2| (QUOTE (|RetractableTo| (|Fraction| #21#))))) (AND #4# #26#) (AND #5# #26#) (AND #6# #26#) (AND #7# #26#) (AND #8# #26#) (AND #9# #26#) (AND #10# #26#) (AND #11# #26#) (AND #12# #26#) (AND #13# #26#) (AND #15# #26#) (AND #26# #17#) #27=(AND #26# #19#)) (OR #28=(AND #1# #29=(|HasCategory| |#2| (QUOTE (|RetractableTo| #21#)))) #30=(AND #4# #29#) #31=(AND #5# #29#) #32=(AND #6# #29#) #33=(AND #7# #29#) #34=(AND #8# #29#) #35=(AND #12# #29#) #36=(AND #13# #29#) #37=(AND #15# #29#) #38=(AND #29# #19#) #39=(AND #9# #29#) #40=(AND #10# #29#) #41=(AND #11# #29#) #17#) (OR #28# #30# #31# #32# #33# #34# #35# #36# #37# #38# #39# #40# #41# (AND #29# #17#)) #23# (|HasCategory| #21# #14#) #22# #24# #25# (OR #38# #17#) #38# #27# (|HasAttribute| |#2| (QUOTE |unitsKnown|)) (AND #8# #17#) (AND #15# #17#) #7# #4# #6# #5# #18# (AND #23# (|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #3#))) (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #3#))) 
+NIL 
+((OR (AND #1=(|HasCategory| |#2| (QUOTE (|AbelianGroup|))) #2=(|HasCategory| |#2| (|%list| (QUOTE |Evalable|) #3=(|devaluate| |#2|)))) (AND #4=(|HasCategory| |#2| (QUOTE (|AbelianMonoid|))) #2#) (AND #5=(|HasCategory| |#2| (QUOTE (|AbelianSemiGroup|))) #2#) (AND #6=(|HasCategory| |#2| (QUOTE (|CancellationAbelianMonoid|))) #2#) (AND #7=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) #2#) (AND #8=(|HasCategory| |#2| (QUOTE (|DifferentialRing|))) #2#) (AND #9=(|HasCategory| |#2| (QUOTE (|Field|))) #2#) (AND #10=(|HasCategory| |#2| (QUOTE (|Finite|))) #2#) (AND #11=(|HasCategory| |#2| (QUOTE (|Monoid|))) #2#) (AND #12=(|HasCategory| |#2| (QUOTE (|OrderedAbelianMonoidSup|))) #2#) (AND #13=(|HasCategory| |#2| #14=(QUOTE (|OrderedSet|))) #2#) (AND #15=(|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #16=(|Symbol|)))) #2#) (AND #17=(|HasCategory| |#2| (QUOTE (|Ring|))) #2#) #18=(AND #19=(|HasCategory| |#2| (QUOTE (|SetCategory|))) #2#)) (|HasCategory| |#2| (QUOTE (|CoercibleTo| (|OutputForm|)))) #9# (OR #7# #9# #17#) (OR #7# #9#) #1# #17# #11# #12# (OR #12# #13#) #13# #10# (OR (AND #7# #20=(|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #21=(|Integer|))))) (AND #8# #20#) (AND #9# #20#) (AND #20# #15#) #22=(AND #20# #17#)) #15# (OR #1# #4# #5# #23=(|HasCategory| |#2| (QUOTE (|BasicType|))) #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #15# #17#) (OR #1# #4# #6# #7# #8# #9# #15# #17#) (OR #1# #6# #7# #8# #9# #15# #17#) (OR #1# #7# #8# #9# #15# #17#) (OR #8# #15# #17#) #8# (OR #8# #24=(AND (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) #17#)) (OR #25=(AND (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #16#))) #17#) #15#) #19# (OR (AND #1# #26=(|HasCategory| |#2| (QUOTE (|RetractableTo| (|Fraction| #21#))))) (AND #4# #26#) (AND #5# #26#) (AND #6# #26#) (AND #7# #26#) (AND #8# #26#) (AND #9# #26#) (AND #10# #26#) (AND #11# #26#) (AND #12# #26#) (AND #13# #26#) (AND #15# #26#) (AND #26# #17#) #27=(AND #26# #19#)) (OR #28=(AND #1# #29=(|HasCategory| |#2| (QUOTE (|RetractableTo| #21#)))) #30=(AND #4# #29#) #31=(AND #5# #29#) #32=(AND #6# #29#) #33=(AND #7# #29#) #34=(AND #8# #29#) #35=(AND #12# #29#) #36=(AND #13# #29#) #37=(AND #15# #29#) #38=(AND #29# #19#) #39=(AND #9# #29#) #40=(AND #10# #29#) #41=(AND #11# #29#) #17#) (OR #28# #30# #31# #32# #33# #34# #35# #36# #37# #38# #39# #40# #41# (AND #29# #17#)) #23# (|HasCategory| #21# #14#) #22# #24# #25# (OR #38# #17#) #38# #27# (AND #8# #17#) (AND #15# #17#) #7# #4# #6# #5# #18# (AND #23# (|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #3#))) (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #3#))) 
 (|OrderlyDifferentialPolynomial| R) 
 ((|constructor| (NIL "\\spadtype{OrderlyDifferentialPolynomial} implements an ordinary differential polynomial ring in arbitrary number of differential indeterminates,{} with coefficients in a ring. The ranking on the differential indeterminate is orderly. This is analogous to the domain \\spadtype{Polynomial}. \\blankline"))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#1| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|OrderlyDifferentialVariable| #8=(|Symbol|)) #5#)) (AND (|HasCategory| |#1| #9=(QUOTE (|PatternMatchable| #10=(|Integer|)))) (|HasCategory| #7# #9#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#1| #12=(QUOTE (|ConvertibleTo| (|Pattern| #10#)))) (|HasCategory| #7# #12#)) (AND (|HasCategory| |#1| #13=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #13#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #10#))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #14=(|HasCategory| |#1| #15=(QUOTE (|CharacteristicNonZero|))) #16=(|HasCategory| |#1| (QUOTE (|Algebra| #17=(|Fraction| #10#)))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #10#))) (OR #16# #18=(|HasCategory| |#1| (QUOTE (|RetractableTo| #17#)))) #18# (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #8#))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #8#))) (|HasCategory| |#1| (QUOTE (|Field|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #3# #19=(AND #1# (|HasCategory| $ #15#)) (OR #19# #14#)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#1| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|OrderlyDifferentialVariable| #8=(|Symbol|)) #5#)) (AND (|HasCategory| |#1| #9=(QUOTE (|PatternMatchable| #10=(|Integer|)))) (|HasCategory| #7# #9#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#1| #12=(QUOTE (|ConvertibleTo| (|Pattern| #10#)))) (|HasCategory| #7# #12#)) (AND (|HasCategory| |#1| #13=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #13#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #10#))) #14=(|HasCategory| |#1| (QUOTE (|Algebra| #15=(|Fraction| #10#)))) #16=(|HasCategory| |#1| #17=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #10#))) (OR #14# #18=(|HasCategory| |#1| (QUOTE (|RetractableTo| #15#)))) #18# (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #8#))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #8#))) (|HasCategory| |#1| (QUOTE (|Field|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #3# #19=(AND #1# (|HasCategory| $ #17#)) (OR #19# #16#)) 
 (|OrdinaryDifferentialRing| |Kernels| R |var|) 
 ((|constructor| (NIL "This constructor produces an ordinary differential ring from a partial differential ring by specifying a variable."))) 
-(((|commutative| "*") |has| |#2| . #1=((|Field|))) (|noZeroDivisors| |has| |#2| . #1#) (|canonicalUnitNormal| |has| |#2| . #1#) (|canonicalsClosed| |has| |#2| . #1#) (|unitsKnown| . T) (|leftUnitary| . T) (|rightUnitary| . T)) 
+(((|commutative| "*") |has| |#2| . #1=((|Field|))) (|noZeroDivisors| |has| |#2| . #1#) (|canonicalUnitNormal| |has| |#2| . #1#)) 
 ((|HasCategory| |#2| (QUOTE (|Field|)))) 
 (|OrderlyDifferentialVariable| S) 
 ((|constructor| (NIL "\\spadtype{OrderlyDifferentialVariable} adds a commonly used orderly ranking to the set of derivatives of an ordered list of differential indeterminates. An orderly ranking is a ranking \\spadfun{<} of the derivatives with the property that for two derivatives \\spad{u} and \\spad{v},{} \\spad{u} \\spadfun{<} \\spad{v} if the \\spadfun{order} of \\spad{u} is less than that of \\spad{v}. This domain belongs to \\spadtype{DifferentialVariableCategory}. It defines \\spadfun{weight} to be just \\spadfun{order},{} and it defines an orderly ranking \\spadfun{<} on derivatives \\spad{u} via the lexicographic order on the pair (\\spadfun{order}(\\spad{u}),{} \\spadfun{variable}(\\spad{u}))."))) 
@@ -2906,11 +2906,11 @@ NIL
 ((|HasCategory| |#1| (QUOTE (|OrderedSet|)))) 
 (|OrderedIntegralDomain|) 
 ((|constructor| (NIL "The category of ordered commutative integral domains,{} where ordering and the arithmetic operations are compatible \\blankline"))) 
-((|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|OppositeMonogenicLinearOperator| P R) 
 ((|constructor| (NIL "This constructor creates the \\spadtype{MonogenicLinearOperator} domain which is ``opposite'' in the ring sense to \\spad{P}. That is,{} as sets \\spad{P = \\$} but \\spad{a * b} in \\spad{\\$} is equal to \\spad{b * a} in \\spad{P}.")) (|po| ((|#1| $) "\\spad{po(q)} creates a value in \\spad{P} equal to \\spad{q} in \\$.")) (|op| (($ |#1|) "\\spad{op(p)} creates a value in \\$ equal to \\spad{p} in \\spad{P}."))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 ((|HasCategory| |#2| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|DifferentialRing|)))) 
 (|OrderedMultisetAggregate| S) 
 ((|constructor| (NIL "to become an in order iterator")) (|min| ((|#1| $) "\\spad{min(u)} returns the smallest entry in the multiset aggregate \\spad{u}."))) 
@@ -2918,7 +2918,7 @@ NIL
 NIL 
 (|OnePointCompletion| R) 
 ((|constructor| (NIL "Adjunction of a complex infinity to a set. Date Created: 4 Oct 1989 Date Last Updated: 1 Nov 1989")) (|rationalIfCan| (((|Union| (|Fraction| (|Integer|)) "failed") $) "\\spad{rationalIfCan(x)} returns \\spad{x} as a finite rational number if it is one,{} \"failed\" otherwise.")) (|rational| (((|Fraction| (|Integer|)) $) "\\spad{rational(x)} returns \\spad{x} as a finite rational number. Error: if \\spad{x} is not a rational number.")) (|rational?| (((|Boolean|) $) "\\spad{rational?(x)} tests if \\spad{x} is a finite rational number.")) (|infinite?| (((|Boolean|) $) "\\spad{infinite?(x)} tests if \\spad{x} is infinite.")) (|finite?| (((|Boolean|) $) "\\spad{finite?(x)} tests if \\spad{x} is finite.")) (|infinity| (($) "\\spad{infinity()} returns infinity."))) 
-((|unitsKnown| |has| |#1| (|OrderedRing|))) 
+NIL 
 (#1=(|HasCategory| |#1| (QUOTE (|OrderedRing|))) #2=(|HasCategory| |#1| (QUOTE (|AbelianGroup|))) (OR #2# #1#) (|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #3=(|Integer|))))) (OR #1# #4=(|HasCategory| |#1| (QUOTE (|RetractableTo| #3#)))) #4# (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|)))) 
 (|OnePointCompletionFunctions2| R S) 
 ((|constructor| (NIL "Lifting of maps to one-point completions. Date Created: 4 Oct 1989 Date Last Updated: 4 Oct 1989")) (|map| (((|OnePointCompletion| |#2|) (|Mapping| |#2| |#1|) (|OnePointCompletion| |#1|) (|OnePointCompletion| |#2|)) "\\spad{map(f, r, i)} lifts \\spad{f} and applies it to \\spad{r},{} assuming that \\spad{f}(infinity) = \\spad{i}.") (((|OnePointCompletion| |#2|) (|Mapping| |#2| |#1|) (|OnePointCompletion| |#1|)) "\\spad{map(f, r)} lifts \\spad{f} and applies it to \\spad{r},{} assuming that \\spad{f}(infinity) = infinity."))) 
@@ -2926,7 +2926,7 @@ NIL
 NIL 
 (|Operator| R) 
 ((|constructor| (NIL "Algebra of ADDITIVE operators over a ring."))) 
-((|leftUnitary| |has| |#1| . #1=((|CommutativeRing|))) (|rightUnitary| |has| |#1| . #1#) (|unitsKnown| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|)))) 
 (|OperatorCategory&| A S) 
 ((|constructor| (NIL "This category specifies the interface for operators used to build terms,{} in the sense of Universal Algebra. The domain parameter \\spad{S} provides representation for the `external name' of an operator.")) (|is?| (((|Boolean|) $ |#2|) "\\spad{is?(op,n)} holds if the name of the operator \\spad{op} is \\spad{n}.")) (|arity| (((|Arity|) $) "\\spad{arity(op)} returns the arity of the operator \\spad{op}.")) (|name| ((|#2| $) "\\spad{name(op)} returns the externam name of \\spad{op}."))) 
@@ -2946,7 +2946,7 @@ NIL
 NIL 
 (|OrderedCompletion| R) 
 ((|constructor| (NIL "Adjunction of two real infinites quantities to a set. Date Created: 4 Oct 1989 Date Last Updated: 1 Nov 1989")) (|rationalIfCan| (((|Union| (|Fraction| (|Integer|)) "failed") $) "\\spad{rationalIfCan(x)} returns \\spad{x} as a finite rational number if it is one and \"failed\" otherwise.")) (|rational| (((|Fraction| (|Integer|)) $) "\\spad{rational(x)} returns \\spad{x} as a finite rational number. Error: if \\spad{x} cannot be so converted.")) (|rational?| (((|Boolean|) $) "\\spad{rational?(x)} tests if \\spad{x} is a finite rational number.")) (|whatInfinity| (((|SingleInteger|) $) "\\spad{whatInfinity(x)} returns 0 if \\spad{x} is finite,{} 1 if \\spad{x} is +infinity,{} and \\spad{-1} if \\spad{x} is -infinity.")) (|infinite?| (((|Boolean|) $) "\\spad{infinite?(x)} tests if \\spad{x} is +infinity or -infinity,{}")) (|finite?| (((|Boolean|) $) "\\spad{finite?(x)} tests if \\spad{x} is finite.")) (|minusInfinity| (($) "\\spad{minusInfinity()} returns -infinity.")) (|plusInfinity| (($) "\\spad{plusInfinity()} returns +infinity."))) 
-((|unitsKnown| |has| |#1| (|OrderedRing|))) 
+NIL 
 (#1=(|HasCategory| |#1| (QUOTE (|OrderedRing|))) #2=(|HasCategory| |#1| (QUOTE (|AbelianGroup|))) (OR #2# #1#) (|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #3=(|Integer|))))) (OR #1# #4=(|HasCategory| |#1| (QUOTE (|RetractableTo| #3#)))) #4# (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|)))) 
 (|OrderedCompletionFunctions2| R S) 
 ((|constructor| (NIL "Lifting of maps to ordered completions. Date Created: 4 Oct 1989 Date Last Updated: 4 Oct 1989")) (|map| (((|OrderedCompletion| |#2|) (|Mapping| |#2| |#1|) (|OrderedCompletion| |#1|) (|OrderedCompletion| |#2|) (|OrderedCompletion| |#2|)) "\\spad{map(f, r, p, m)} lifts \\spad{f} and applies it to \\spad{r},{} assuming that \\spad{f}(plusInfinity) = \\spad{p} and that \\spad{f}(minusInfinity) = \\spad{m}.") (((|OrderedCompletion| |#2|) (|Mapping| |#2| |#1|) (|OrderedCompletion| |#1|)) "\\spad{map(f, r)} lifts \\spad{f} and applies it to \\spad{r},{} assuming that \\spad{f}(plusInfinity) = plusInfinity and that \\spad{f}(minusInfinity) = minusInfinity."))) 
@@ -2966,7 +2966,7 @@ NIL
 NIL 
 (|OrderedRing|) 
 ((|constructor| (NIL "Ordered sets which are also rings,{} that is,{} domains where the ring operations are compatible with the ordering. \\blankline"))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|OrderedSet|) 
 ((|constructor| (NIL "The class of totally ordered sets,{} that is,{} sets such that for each pair of elements \\spad{(a,b)} exactly one of the following relations holds \\spad{a<b or a=b or b<a} and the relation is transitive,{} \\spadignore{i.e.} \\spad{a<b and b<c => a<c}."))) 
@@ -2990,7 +2990,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|Field|))) (|HasCategory| |#2| (QUOTE (|GcdDomain|))) (|HasCategory| |#2| (QUOTE (|IntegralDomain|))) (|HasCategory| |#2| (QUOTE (|CommutativeRing|)))) 
 (|UnivariateSkewPolynomialCategory| R) 
 ((|constructor| (NIL "This is the category of univariate skew polynomials over an Ore coefficient ring. The multiplication is given by \\spad{x a = \\sigma(a) x + \\delta a}. This category is an evolution of the types \\indented{2}{MonogenicLinearOperator,{} OppositeMonogenicLinearOperator,{} and} \\indented{2}{NonCommutativeOperatorDivision} developped by Jean Della Dora and Stephen \\spad{M}. Watt.")) (|leftLcm| (($ $ $) "\\spad{leftLcm(a,b)} computes the value \\spad{m} of lowest degree such that \\spad{m = aa*a = bb*b} for some values \\spad{aa} and \\spad{bb}. The value \\spad{m} is computed using right-division.")) (|rightExtendedGcd| (((|Record| (|:| |coef1| $) (|:| |coef2| $) (|:| |generator| $)) $ $) "\\spad{rightExtendedGcd(a,b)} returns \\spad{[c,d]} such that \\spad{g = c * a + d * b = rightGcd(a, b)}.")) (|rightGcd| (($ $ $) "\\spad{rightGcd(a,b)} computes the value \\spad{g} of highest degree such that \\indented{3}{\\spad{a = aa*g}} \\indented{3}{\\spad{b = bb*g}} for some values \\spad{aa} and \\spad{bb}. The value \\spad{g} is computed using right-division.")) (|rightExactQuotient| (((|Union| $ "failed") $ $) "\\spad{rightExactQuotient(a,b)} computes the value \\spad{q},{} if it exists such that \\spad{a = q*b}.")) (|rightRemainder| (($ $ $) "\\spad{rightRemainder(a,b)} computes the pair \\spad{[q,r]} such that \\spad{a = q*b + r} and the degree of \\spad{r} is less than the degree of \\spad{b}. The value \\spad{r} is returned.")) (|rightQuotient| (($ $ $) "\\spad{rightQuotient(a,b)} computes the pair \\spad{[q,r]} such that \\spad{a = q*b + r} and the degree of \\spad{r} is less than the degree of \\spad{b}. The value \\spad{q} is returned.")) (|rightDivide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\spad{rightDivide(a,b)} returns the pair \\spad{[q,r]} such that \\spad{a = q*b + r} and the degree of \\spad{r} is less than the degree of \\spad{b}. This process is called ``right division''.")) (|rightLcm| (($ $ $) "\\spad{rightLcm(a,b)} computes the value \\spad{m} of lowest degree such that \\spad{m = a*aa = b*bb} for some values \\spad{aa} and \\spad{bb}. The value \\spad{m} is computed using left-division.")) (|leftExtendedGcd| (((|Record| (|:| |coef1| $) (|:| |coef2| $) (|:| |generator| $)) $ $) "\\spad{leftExtendedGcd(a,b)} returns \\spad{[c,d]} such that \\spad{g = a * c + b * d = leftGcd(a, b)}.")) (|leftGcd| (($ $ $) "\\spad{leftGcd(a,b)} computes the value \\spad{g} of highest degree such that \\indented{3}{\\spad{a = g*aa}} \\indented{3}{\\spad{b = g*bb}} for some values \\spad{aa} and \\spad{bb}. The value \\spad{g} is computed using left-division.")) (|leftExactQuotient| (((|Union| $ "failed") $ $) "\\spad{leftExactQuotient(a,b)} computes the value \\spad{q},{} if it exists,{} \\indented{1}{such that \\spad{a = b*q}.}")) (|leftRemainder| (($ $ $) "\\spad{leftRemainder(a,b)} computes the pair \\spad{[q,r]} such that \\spad{a = b*q + r} and the degree of \\spad{r} is less than the degree of \\spad{b}. The value \\spad{r} is returned.")) (|leftQuotient| (($ $ $) "\\spad{leftQuotient(a,b)} computes the pair \\spad{[q,r]} such that \\spad{a = b*q + r} and the degree of \\spad{r} is less than the degree of \\spad{b}. The value \\spad{q} is returned.")) (|leftDivide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\spad{leftDivide(a,b)} returns the pair \\spad{[q,r]} such that \\spad{a = b*q + r} and the degree of \\spad{r} is less than the degree of \\spad{b}. This process is called ``left division''.")) (|primitivePart| (($ $) "\\spad{primitivePart(l)} returns \\spad{l0} such that \\spad{l = a * l0} for some a in \\spad{R},{} and \\spad{content(l0) = 1}.")) (|content| ((|#1| $) "\\spad{content(l)} returns the gcd of all the coefficients of \\spad{l}.")) (|monicRightDivide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\spad{monicRightDivide(a,b)} returns the pair \\spad{[q,r]} such that \\spad{a = q*b + r} and the degree of \\spad{r} is less than the degree of \\spad{b}. \\spad{b} must be monic. This process is called ``right division''.")) (|monicLeftDivide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\spad{monicLeftDivide(a,b)} returns the pair \\spad{[q,r]} such that \\spad{a = b*q + r} and the degree of \\spad{r} is less than the degree of \\spad{b}. \\spad{b} must be monic. This process is called ``left division''.")) (|exquo| (((|Union| $ "failed") $ |#1|) "\\spad{exquo(l, a)} returns the exact quotient of \\spad{l} by a,{} returning \\axiom{\"failed\"} if this is not possible.")) (|apply| ((|#1| $ |#1| |#1|) "\\spad{apply(p, c, m)} returns \\spad{p(m)} where the action is given by \\spad{x m = c sigma(m) + delta(m)}.")) (|coefficients| (((|List| |#1|) $) "\\spad{coefficients(l)} returns the list of all the nonzero coefficients of \\spad{l}.")) (|monomial| (($ |#1| (|NonNegativeInteger|)) "\\spad{monomial(c,k)} produces \\spad{c} times the \\spad{k}-th power of the generating operator,{} \\spad{monomial(1,1)}.")) (|coefficient| ((|#1| $ (|NonNegativeInteger|)) "\\spad{coefficient(l,k)} is \\spad{a(k)} if \\indented{2}{\\spad{l = sum(monomial(a(i),i), i = 0..n)}.}")) (|reductum| (($ $) "\\spad{reductum(l)} is \\spad{l - monomial(a(n),n)} if \\indented{2}{\\spad{l = sum(monomial(a(i),i), i = 0..n)}.}")) (|leadingCoefficient| ((|#1| $) "\\spad{leadingCoefficient(l)} is \\spad{a(n)} if \\indented{2}{\\spad{l = sum(monomial(a(i),i), i = 0..n)}.}")) (|minimumDegree| (((|NonNegativeInteger|) $) "\\spad{minimumDegree(l)} is the smallest \\spad{k} such that \\spad{a(k) ~= 0} if \\indented{2}{\\spad{l = sum(monomial(a(i),i), i = 0..n)}.}")) (|degree| (((|NonNegativeInteger|) $) "\\spad{degree(l)} is \\spad{n} if \\indented{2}{\\spad{l = sum(monomial(a(i),i), i = 0..n)}.}"))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 NIL 
 (|UnivariateSkewPolynomialCategoryOps| R C) 
 ((|constructor| (NIL "\\spad{UnivariateSkewPolynomialCategoryOps} provides products and \\indented{1}{divisions of univariate skew polynomials.}")) (|rightDivide| (((|Record| (|:| |quotient| |#2|) (|:| |remainder| |#2|)) |#2| |#2| (|Automorphism| |#1|)) "\\spad{rightDivide(a, b, sigma)} returns the pair \\spad{[q,r]} such that \\spad{a = q*b + r} and the degree of \\spad{r} is less than the degree of \\spad{b}. This process is called ``right division''. \\spad{\\sigma} is the morphism to use.")) (|leftDivide| (((|Record| (|:| |quotient| |#2|) (|:| |remainder| |#2|)) |#2| |#2| (|Automorphism| |#1|)) "\\spad{leftDivide(a, b, sigma)} returns the pair \\spad{[q,r]} such that \\spad{a = b*q + r} and the degree of \\spad{r} is less than the degree of \\spad{b}. This process is called ``left division''. \\spad{\\sigma} is the morphism to use.")) (|monicRightDivide| (((|Record| (|:| |quotient| |#2|) (|:| |remainder| |#2|)) |#2| |#2| (|Automorphism| |#1|)) "\\spad{monicRightDivide(a, b, sigma)} returns the pair \\spad{[q,r]} such that \\spad{a = q*b + r} and the degree of \\spad{r} is less than the degree of \\spad{b}. \\spad{b} must be monic. This process is called ``right division''. \\spad{\\sigma} is the morphism to use.")) (|monicLeftDivide| (((|Record| (|:| |quotient| |#2|) (|:| |remainder| |#2|)) |#2| |#2| (|Automorphism| |#1|)) "\\spad{monicLeftDivide(a, b, sigma)} returns the pair \\spad{[q,r]} such that \\spad{a = b*q + r} and the degree of \\spad{r} is less than the degree of \\spad{b}. \\spad{b} must be monic. This process is called ``left division''. \\spad{\\sigma} is the morphism to use.")) (|apply| ((|#1| |#2| |#1| |#1| (|Automorphism| |#1|) (|Mapping| |#1| |#1|)) "\\spad{apply(p, c, m, sigma, delta)} returns \\spad{p(m)} where the action is given by \\spad{x m = c sigma(m) + delta(m)}.")) (|times| ((|#2| |#2| |#2| (|Automorphism| |#1|) (|Mapping| |#1| |#1|)) "\\spad{times(p, q, sigma, delta)} returns \\spad{p * q}. \\spad{\\sigma} and \\spad{\\delta} are the maps to use."))) 
@@ -2998,11 +2998,11 @@ NIL
 ((|HasCategory| |#1| (QUOTE (|Field|))) (|HasCategory| |#1| (QUOTE (|IntegralDomain|)))) 
 (|SparseUnivariateSkewPolynomial| R |sigma| |delta|) 
 ((|constructor| (NIL "This is the domain of sparse univariate skew polynomials over an Ore coefficient field. The multiplication is given by \\spad{x a = \\sigma(a) x + \\delta a}.")) (|outputForm| (((|OutputForm|) $ (|OutputForm|)) "\\spad{outputForm(p, x)} returns the output form of \\spad{p} using \\spad{x} for the otherwise anonymous variable."))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #1=(|Integer|))))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #1#))) (|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (|HasCategory| |#1| (QUOTE (|GcdDomain|))) (|HasCategory| |#1| (QUOTE (|Field|)))) 
 (|UnivariateSkewPolynomial| |x| R |sigma| |delta|) 
 ((|constructor| (NIL "This is the domain of univariate skew polynomials over an Ore coefficient field in a named variable. The multiplication is given by \\spad{x a = \\sigma(a) x + \\delta a}."))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 ((|HasCategory| |#2| (QUOTE (|CommutativeRing|))) (|HasCategory| |#2| (QUOTE (|RetractableTo| (|Fraction| #1=(|Integer|))))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #1#))) (|HasCategory| |#2| (QUOTE (|IntegralDomain|))) (|HasCategory| |#2| (QUOTE (|GcdDomain|))) (|HasCategory| |#2| (QUOTE (|Field|)))) 
 (|OrthogonalPolynomialFunctions| R) 
 ((|constructor| (NIL "This package provides orthogonal polynomials as functions on a ring.")) (|legendreP| ((|#1| (|NonNegativeInteger|) |#1|) "\\spad{legendreP(n,x)} is the \\spad{n}-th Legendre polynomial,{} \\spad{P[n](x)}. These are defined by \\spad{1/sqrt(1-2*x*t+t**2) = sum(P[n](x)*t**n, n = 0..)}.")) (|laguerreL| ((|#1| (|NonNegativeInteger|) (|NonNegativeInteger|) |#1|) "\\spad{laguerreL(m,n,x)} is the associated Laguerre polynomial,{} \\spad{L<m>[n](x)}. This is the \\spad{m}-th derivative of \\spad{L[n](x)}.") ((|#1| (|NonNegativeInteger|) |#1|) "\\spad{laguerreL(n,x)} is the \\spad{n}-th Laguerre polynomial,{} \\spad{L[n](x)}. These are defined by \\spad{exp(-t*x/(1-t))/(1-t) = sum(L[n](x)*t**n/n!, n = 0..)}.")) (|hermiteH| ((|#1| (|NonNegativeInteger|) |#1|) "\\spad{hermiteH(n,x)} is the \\spad{n}-th Hermite polynomial,{} \\spad{H[n](x)}. These are defined by \\spad{exp(2*t*x-t**2) = sum(H[n](x)*t**n/n!, n = 0..)}.")) (|chebyshevU| ((|#1| (|NonNegativeInteger|) |#1|) "\\spad{chebyshevU(n,x)} is the \\spad{n}-th Chebyshev polynomial of the second kind,{} \\spad{U[n](x)}. These are defined by \\spad{1/(1-2*t*x+t**2) = sum(T[n](x) *t**n, n = 0..)}.")) (|chebyshevT| ((|#1| (|NonNegativeInteger|) |#1|) "\\spad{chebyshevT(n,x)} is the \\spad{n}-th Chebyshev polynomial of the first kind,{} \\spad{T[n](x)}. These are defined by \\spad{(1-t*x)/(1-2*t*x+t**2) = sum(T[n](x) *t**n, n = 0..)}."))) 
@@ -3046,7 +3046,7 @@ NIL
 NIL 
 (|OrdinaryWeightedPolynomials| R |vl| |wl| |wtlevel|) 
 ((|constructor| (NIL "This domain represents truncated weighted polynomials over the \"Polynomial\" type. The variables must be specified,{} as must the weights. The representation is sparse in the sense that only non-zero terms are represented.")) (|changeWeightLevel| (((|Void|) (|NonNegativeInteger|)) "\\spad{changeWeightLevel(n)} This changes the weight level to the new value given: NB: previously calculated terms are not affected")) (/ (((|Union| $ "failed") $ $) "\\spad{x/y} division (only works if minimum weight of divisor is zero,{} and if \\spad{R} is a Field)"))) 
-((|leftUnitary| |has| |#1| . #1=((|CommutativeRing|))) (|rightUnitary| |has| |#1| . #1#) (|unitsKnown| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|Field|)))) 
 (|PadeApproximants| R PS UP) 
 ((|constructor| (NIL "\\indented{1}{This package computes reliable Pad&ea. approximants using} a generalized Viskovatov continued fraction algorithm. Authors: Burge,{} Hassner & Watt. Date Created: April 1987 Date Last Updated: 12 April 1990 Keywords: Pade,{} series Examples: References: \\indented{2}{\"Pade Approximants,{} Part I: Basic Theory\",{} Baker & Graves-Morris.}")) (|padecf| (((|Union| (|ContinuedFraction| |#3|) "failed") (|NonNegativeInteger|) (|NonNegativeInteger|) |#2| |#2|) "\\spad{padecf(nd,dd,ns,ds)} computes the approximant as a continued fraction of polynomials (if it exists) for arguments \\spad{nd} (numerator degree of approximant),{} \\spad{dd} (denominator degree of approximant),{} \\spad{ns} (numerator series of function),{} and \\spad{ds} (denominator series of function).")) (|pade| (((|Union| (|Fraction| |#3|) "failed") (|NonNegativeInteger|) (|NonNegativeInteger|) |#2| |#2|) "\\spad{pade(nd,dd,ns,ds)} computes the approximant as a quotient of polynomials (if it exists) for arguments \\spad{nd} (numerator degree of approximant),{} \\spad{dd} (denominator degree of approximant),{} \\spad{ns} (numerator series of function),{} and \\spad{ds} (denominator series of function)."))) 
@@ -3058,20 +3058,20 @@ NIL
 NIL 
 (|PAdicInteger| |p|) 
 ((|constructor| (NIL "Stream-based implementation of Zp: \\spad{p}-adic numbers are represented as sum(\\spad{i} = 0..,{} a[\\spad{i}] * p^i),{} where the a[\\spad{i}] lie in 0,{}1,{}...,{}(\\spad{p} - 1)."))) 
-((|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|PAdicIntegerCategory| |p|) 
 ((|constructor| (NIL "This is the catefory of stream-based representations of \\indented{2}{the \\spad{p}-adic integers.}")) (|root| (($ (|SparseUnivariatePolynomial| (|Integer|)) (|Integer|)) "\\spad{root(f,a)} returns a root of the polynomial \\spad{f}. Argument \\spad{a} must be a root of \\spad{f} \\spad{(mod p)}.")) (|sqrt| (($ $ (|Integer|)) "\\spad{sqrt(b,a)} returns a square root of \\spad{b}. Argument \\spad{a} is a square root of \\spad{b} \\spad{(mod p)}.")) (|approximate| (((|Integer|) $ (|Integer|)) "\\spad{approximate(x,n)} returns an integer \\spad{y} such that \\spad{y = x (mod p^n)} when \\spad{n} is positive,{} and 0 otherwise.")) (|quotientByP| (($ $) "\\spad{quotientByP(x)} returns \\spad{b},{} where \\spad{x = a + b p}.")) (|moduloP| (((|Integer|) $) "\\spad{modulo(x)} returns a,{} where \\spad{x = a + b p}.")) (|modulus| (((|Integer|)) "\\spad{modulus()} returns the value of \\spad{p}.")) (|complete| (($ $) "\\spad{complete(x)} forces the computation of all digits.")) (|extend| (($ $ (|Integer|)) "\\spad{extend(x,n)} forces the computation of digits up to order \\spad{n}.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(x)} returns the exponent of the highest power of \\spad{p} dividing \\spad{x}.")) (|digits| (((|Stream| (|Integer|)) $) "\\spad{digits(x)} returns a stream of \\spad{p}-adic digits of \\spad{x}."))) 
-((|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|PAdicRational| |p|) 
 ((|constructor| (NIL "Stream-based implementation of Qp: numbers are represented as sum(\\spad{i} = \\spad{k}..,{} a[\\spad{i}] * p^i) where the a[\\spad{i}] lie in 0,{}1,{}...,{}(\\spad{p} - 1)."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| #2=(|PAdicInteger| |#1|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #8=(|Integer|)))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #9=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #8#))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (|%list| (QUOTE |InnerEvalable|) (QUOTE #3#) #10=(|%list| (QUOTE |PAdicInteger|) (|devaluate| |#1|)))) (|HasCategory| #2# (|%list| (QUOTE |Evalable|) #10#)) (|HasCategory| #2# (|%list| (QUOTE |Eltable|) #10# #10#)) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) #11=(AND (|HasCategory| $ #5#) #1#) (OR #11# #4#)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
+(#1=(|HasCategory| #2=(|PAdicInteger| |#1|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #8=(|Integer|)))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #9=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #8#))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (|%list| (QUOTE |InnerEvalable|) (QUOTE #3#) #10=(|%list| (QUOTE |PAdicInteger|) (|devaluate| |#1|)))) (|HasCategory| #2# (|%list| (QUOTE |Evalable|) #10#)) (|HasCategory| #2# (|%list| (QUOTE |Eltable|) #10# #10#)) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) #11=(AND (|HasCategory| $ #5#) #1#) (OR #11# #4#)) 
 (|PAdicRationalConstructor| |p| PADIC) 
 ((|constructor| (NIL "This is the category of stream-based representations of Qp.")) (|removeZeroes| (($ (|Integer|) $) "\\spad{removeZeroes(n,x)} removes up to \\spad{n} leading zeroes from the \\spad{p}-adic rational \\spad{x}.") (($ $) "\\spad{removeZeroes(x)} removes leading zeroes from the representation of the \\spad{p}-adic rational \\spad{x}. A \\spad{p}-adic rational is represented by (1) an exponent and (2) a \\spad{p}-adic integer which may have leading zero digits. When the \\spad{p}-adic integer has a leading zero digit,{} a 'leading zero' is removed from the \\spad{p}-adic rational as follows: the number is rewritten by increasing the exponent by 1 and dividing the \\spad{p}-adic integer by \\spad{p}. Note: \\spad{removeZeroes(f)} removes all leading zeroes from \\spad{f}.")) (|continuedFraction| (((|ContinuedFraction| (|Fraction| (|Integer|))) $) "\\spad{continuedFraction(x)} converts the \\spad{p}-adic rational number \\spad{x} to a continued fraction.")) (|approximate| (((|Fraction| (|Integer|)) $ (|Integer|)) "\\spad{approximate(x,n)} returns a rational number \\spad{y} such that \\spad{y = x (mod p^n)}."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #2=(|Symbol|)))) #3=(|HasCategory| |#2| #4=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#2| (QUOTE (|RealConstant|))) #5=(|HasCategory| |#2| (QUOTE (|OrderedIntegralDomain|))) #6=(|HasCategory| |#2| (QUOTE (|OrderedSet|))) (OR #5# #6#) (|HasCategory| |#2| (QUOTE (|RetractableTo| #7=(|Integer|)))) (|HasCategory| |#2| (QUOTE (|StepThrough|))) (|HasCategory| |#2| (QUOTE (|PatternMatchable| #8=(|Float|)))) (|HasCategory| |#2| (QUOTE (|PatternMatchable| #7#))) (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Pattern| #7#)))) (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #7#))) (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #2#))) (|HasCategory| |#2| (QUOTE (|DifferentialRing|))) (|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #2#))) (|HasCategory| |#2| (|%list| (QUOTE |InnerEvalable|) (QUOTE #2#) #9=(|devaluate| |#2|))) (|HasCategory| |#2| (|%list| (QUOTE |Evalable|) #9#)) (|HasCategory| |#2| (|%list| (QUOTE |Eltable|) #9# #9#)) (|HasCategory| |#2| (QUOTE (|EuclideanDomain|))) (|HasCategory| |#2| (QUOTE (|IntegerNumberSystem|))) #10=(AND #1# (|HasCategory| $ #4#)) (OR #10# #3#)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
+(#1=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #2=(|Symbol|)))) #3=(|HasCategory| |#2| #4=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#2| (QUOTE (|RealConstant|))) #5=(|HasCategory| |#2| (QUOTE (|OrderedIntegralDomain|))) #6=(|HasCategory| |#2| (QUOTE (|OrderedSet|))) (OR #5# #6#) (|HasCategory| |#2| (QUOTE (|RetractableTo| #7=(|Integer|)))) (|HasCategory| |#2| (QUOTE (|StepThrough|))) (|HasCategory| |#2| (QUOTE (|PatternMatchable| #8=(|Float|)))) (|HasCategory| |#2| (QUOTE (|PatternMatchable| #7#))) (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Pattern| #7#)))) (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #7#))) (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #2#))) (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#2| (QUOTE (|DifferentialRing|))) (|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #2#))) (|HasCategory| |#2| (|%list| (QUOTE |InnerEvalable|) (QUOTE #2#) #9=(|devaluate| |#2|))) (|HasCategory| |#2| (|%list| (QUOTE |Evalable|) #9#)) (|HasCategory| |#2| (|%list| (QUOTE |Eltable|) #9# #9#)) (|HasCategory| |#2| (QUOTE (|EuclideanDomain|))) (|HasCategory| |#2| (QUOTE (|IntegerNumberSystem|))) #10=(AND #1# (|HasCategory| $ #4#)) (OR #10# #3#)) 
 (|Pair| S T$) 
 ((|constructor| (NIL "\\indented{1}{This domain provides a very simple representation} of the notion of `pair of objects'. It does not try to achieve all possible imaginable things.")) (|second| ((|#2| $) "\\spad{second(p)} extracts the second components of `p'.")) (|first| ((|#1| $) "\\spad{first(p)} extracts the first component of `p'.")) (|construct| (($ |#1| |#2|) "\\spad{construct(s,t)} is same as pair(\\spad{s},{}\\spad{t}),{} with syntactic sugar.")) (|pair| (($ |#1| |#2|) "\\spad{pair(s,t)} returns a pair object composed of `s' and `t'."))) 
 NIL 
@@ -3157,7 +3157,7 @@ NIL
 NIL 
 NIL 
 (|PoincareBirkhoffWittLyndonBasis| |VarSet|) 
-((|constructor| (NIL "This domain provides the internal representation of polynomials in non-commutative variables written over the Poincare-Birkhoff-Witt basis. See the \\spadtype{XPBWPolynomial} domain constructor. See Free Lie Algebras by \\spad{C}. Reutenauer (Oxford science publications). \\newline Author: Michel Petitot (petitot@lifl.fr).")) (|varList| (((|List| |#1|) $) "\\spad{varList([l1]*[l2]*...[ln])} returns the list of variables in the word \\spad{l1*l2*...*ln}.")) (|retractable?| (((|Boolean|) $) "\\spad{retractable?([l1]*[l2]*...[ln])} returns \\spad{true} iff \\spad{n} equals \\spad{1}.")) (|rest| (($ $) "\\spad{rest([l1]*[l2]*...[ln])} returns the list \\spad{l2, .... ln}.")) (|ListOfTerms| (((|List| (|LyndonWord| |#1|)) $) "\\spad{ListOfTerms([l1]*[l2]*...[ln])} returns the list of words \\spad{l1, l2, .... ln}.")) (|length| (((|NonNegativeInteger|) $) "\\spad{length([l1]*[l2]*...[ln])} returns the length of the word \\spad{l1*l2*...*ln}.")) (|first| (((|LyndonWord| |#1|) $) "\\spad{first([l1]*[l2]*...[ln])} returns the Lyndon word \\spad{l1}.")) (|coerce| (($ |#1|) "\\spad{coerce(v)} return \\spad{v}") (((|OrderedFreeMonoid| |#1|) $) "\\spad{coerce([l1]*[l2]*...[ln])} returns the word \\spad{l1*l2*...*ln},{} where \\spad{[l_i]} is the backeted form of the Lyndon word \\spad{l_i}.")) (|One| (($) "\\spad{1} returns the empty list."))) 
+((|constructor| (NIL "This domain provides the internal representation of polynomials in non-commutative variables written over the Poincare-Birkhoff-Witt basis. See the \\spadtype{XPBWPolynomial} domain constructor. See Free Lie Algebras by \\spad{C}. Reutenauer (Oxford science publications). \\newline Author: Michel Petitot (petitot@lifl.fr).")) (|varList| (((|List| |#1|) $) "\\spad{varList([l1]*[l2]*...[ln])} returns the list of variables in the word \\spad{l1*l2*...*ln}.")) (|retractable?| (((|Boolean|) $) "\\spad{retractable?([l1]*[l2]*...[ln])} returns \\spad{true} iff \\spad{n} equals \\spad{1}.")) (|rest| (($ $) "\\spad{rest([l1]*[l2]*...[ln])} returns the list \\spad{l2, .... ln}.")) (|ListOfTerms| (((|List| (|LyndonWord| |#1|)) $) "\\spad{ListOfTerms([l1]*[l2]*...[ln])} returns the list of words \\spad{l1, l2, .... ln}.")) (|length| (((|NonNegativeInteger|) $) "\\spad{length([l1]*[l2]*...[ln])} returns the length of the word \\spad{l1*l2*...*ln}.")) (|first| (((|LyndonWord| |#1|) $) "\\spad{first([l1]*[l2]*...[ln])} returns the Lyndon word \\spad{l1}.")) (|coerce| (($ |#1|) "\\spad{coerce(v)} return \\spad{v}")) (|One| (($) "\\spad{1} returns the empty list."))) 
 NIL 
 NIL 
 (|PolynomialComposition| UP R) 
@@ -3178,11 +3178,11 @@ NIL
 NIL 
 (|PartialDifferentialModule| R S) 
 ((|constructor| (NIL "A partial differential \\spad{R}-module with differentiations indexed by a parameter type \\spad{S}. \\blankline"))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 NIL 
 (|PartialDifferentialRing| S) 
 ((|constructor| (NIL "A partial differential ring with differentiations indexed by a parameter type \\spad{S}. \\blankline"))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|PartialDifferentialSpace&| A S) 
 ((|constructor| (NIL "\\indented{2}{This category captures the interface of domains stable by partial} \\indented{2}{differentiation with respect to variables from some domain.} See Also: \\indented{2}{PartialDifferentialDomain}")) (D (($ $ (|List| |#2|) (|List| (|NonNegativeInteger|))) "\\spad{D(x,[s1,...,sn],[n1,...,nn])} is a shorthand for \\spad{differentiate(x,[s1,...,sn],[n1,...,nn])}.") (($ $ |#2| (|NonNegativeInteger|)) "\\spad{D(x,s,n)} is a shorthand for \\spad{differentiate(x,s,n)}.") (($ $ (|List| |#2|)) "\\spad{D(x,[s1,...sn])} is a shorthand for \\spad{differentiate(x,[s1,...sn])}.")) (|differentiate| (($ $ (|List| |#2|) (|List| (|NonNegativeInteger|))) "\\spad{differentiate(x,[s1,...,sn],[n1,...,nn])} computes multiple partial derivatives,{} \\spadignore{i.e.}") (($ $ |#2| (|NonNegativeInteger|)) "\\spad{differentiate(x,s,n)} computes multiple partial derivatives,{} \\spadignore{i.e.} \\spad{n}\\spad{-}th derivative of \\spad{x} with respect to \\spad{s}.") (($ $ (|List| |#2|)) "\\spad{differentiate(x,[s1,...sn])} computes successive partial derivatives,{} \\spadignore{i.e.} \\spad{differentiate(...differentiate(x, s1)..., sn)}."))) 
@@ -3198,23 +3198,23 @@ NIL
 ((AND #1=(|HasCategory| |#1| (QUOTE (|SetCategory|))) (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) #2=(|devaluate| |#1|)))) #1# (OR #3=(|HasCategory| |#1| (QUOTE (|BasicType|))) #1#) (|HasCategory| |#1| (QUOTE (|CoercibleTo| (|OutputForm|)))) #3# (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #2#))) 
 (|Permutation| S) 
 ((|constructor| (NIL "Permutation(\\spad{S}) implements the group of all bijections \\indented{2}{on a set \\spad{S},{} which move only a finite number of points.} \\indented{2}{A permutation is considered as a map from \\spad{S} into \\spad{S}. In particular} \\indented{2}{multiplication is defined as composition of maps:} \\indented{2}{{\\em pi1 * pi2 = pi1 o pi2}.} \\indented{2}{The internal representation of permuatations are two lists} \\indented{2}{of equal length representing preimages and images.}")) (|coerceImages| (($ (|List| |#1|)) "\\spad{coerceImages(ls)} coerces the list {\\em ls} to a permutation whose image is given by {\\em ls} and the preimage is fixed to be {\\em [1,...,n]}. Note: {coerceImages(\\spad{ls})=coercePreimagesImages([1,{}...,{}\\spad{n}],{}\\spad{ls})}. We assume that both preimage and image do not contain repetitions.")) (|fixedPoints| (((|Set| |#1|) $) "\\spad{fixedPoints(p)} returns the points fixed by the permutation \\spad{p}.")) (|sort| (((|List| $) (|List| $)) "\\spad{sort(lp)} sorts a list of permutations {\\em lp} according to cycle structure first according to length of cycles,{} second,{} if \\spad{S} has \\spadtype{Finite} or \\spad{S} has \\spadtype{OrderedSet} according to lexicographical order of entries in cycles of equal length.")) (|odd?| (((|Boolean|) $) "\\spad{odd?(p)} returns \\spad{true} if and only if \\spad{p} is an odd permutation \\spadignore{i.e.} {\\em sign(p)} is {\\em -1}.")) (|even?| (((|Boolean|) $) "\\spad{even?(p)} returns \\spad{true} if and only if \\spad{p} is an even permutation,{} \\spadignore{i.e.} {\\em sign(p)} is 1.")) (|sign| (((|Integer|) $) "\\spad{sign(p)} returns the signum of the permutation \\spad{p},{} \\spad{+1} or \\spad{-1}.")) (|numberOfCycles| (((|NonNegativeInteger|) $) "\\spad{numberOfCycles(p)} returns the number of non-trivial cycles of the permutation \\spad{p}.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(p)} returns the order of a permutation \\spad{p} as a group element.")) (|cyclePartition| (((|Partition|) $) "\\spad{cyclePartition(p)} returns the cycle structure of a permutation \\spad{p} including cycles of length 1 only if \\spad{S} is finite.")) (|degree| (((|NonNegativeInteger|) $) "\\spad{degree(p)} retuns the number of points moved by the permutation \\spad{p}.")) (|coerceListOfPairs| (($ (|List| (|List| |#1|))) "\\spad{coerceListOfPairs(lls)} coerces a list of pairs {\\em lls} to a permutation. Error: if not consistent,{} \\spadignore{i.e.} the set of the first elements coincides with the set of second elements. coerce(\\spad{p}) generates output of the permutation \\spad{p} with domain OutputForm.")) (|coerce| (($ (|List| |#1|)) "\\spad{coerce(ls)} coerces a cycle {\\em ls},{} \\spadignore{i.e.} a list with not repetitions to a permutation,{} which maps {\\em ls.i} to {\\em ls.i+1},{} indices modulo the length of the list. Error: if repetitions occur.") (($ (|List| (|List| |#1|))) "\\spad{coerce(lls)} coerces a list of cycles {\\em lls} to a permutation,{} each cycle being a list with no repetitions,{} is coerced to the permutation,{} which maps {\\em ls.i} to {\\em ls.i+1},{} indices modulo the length of the list,{} then these permutations are mutiplied. Error: if repetitions occur in one cycle.")) (|coercePreimagesImages| (($ (|List| (|List| |#1|))) "\\spad{coercePreimagesImages(lls)} coerces the representation {\\em lls} of a permutation as a list of preimages and images to a permutation. We assume that both preimage and image do not contain repetitions.")) (|listRepresentation| (((|Record| (|:| |preimage| (|List| |#1|)) (|:| |image| (|List| |#1|))) $) "\\spad{listRepresentation(p)} produces a representation {\\em rep} of the permutation \\spad{p} as a list of preimages and images,{} \\spad{i}.\\spad{e} \\spad{p} maps {\\em (rep.preimage).k} to {\\em (rep.image).k} for all indices \\spad{k}. Elements of \\spad{S} not in {\\em (rep.preimage).k} are fixed points,{} and these are the only fixed points of the permutation."))) 
-((|unitsKnown| . T)) 
-((OR #1=(|HasCategory| |#1| (QUOTE (|Finite|))) #2=(|HasCategory| |#1| (QUOTE (|OrderedSet|)))) #1# #2#) 
+NIL 
+((OR #1=(|HasCategory| |#1| (QUOTE (|Finite|))) #2=(|HasCategory| |#1| (QUOTE (|OrderedSet|)))) #2# #1#) 
 (|Permanent| |n| R) 
 ((|constructor| (NIL "Permanent implements the functions {\\em permanent},{} the permanent for square matrices.")) (|permanent| ((|#2| (|SquareMatrix| |#1| |#2|)) "\\spad{permanent(x)} computes the permanent of a square matrix \\spad{x}. The {\\em permanent} is equivalent to the \\spadfun{determinant} except that coefficients have no change of sign. This function is much more difficult to compute than the {\\em determinant}. The formula used is by \\spad{H}.\\spad{J}. Ryser,{} improved by [Nijenhuis and Wilf,{} Ch. 19]. Note: permanent(\\spad{x}) choose one of three algorithms,{} depending on the underlying ring \\spad{R} and on \\spad{n},{} the number of rows (and columns) of x:\\begin{items} \\item 1. if 2 has an inverse in \\spad{R} we can use the algorithm of \\indented{3}{[Nijenhuis and Wilf,{} ch.19,{}\\spad{p}.158]; if 2 has no inverse,{}} \\indented{3}{some modifications are necessary:} \\item 2. if {\\em n > 6} and \\spad{R} is an integral domain with characteristic \\indented{3}{different from 2 (the algorithm works if and only 2 is not a} \\indented{3}{zero-divisor of \\spad{R} and {\\em characteristic()\\$R ~= 2},{}} \\indented{3}{but how to check that for any given \\spad{R} ?),{}} \\indented{3}{the local function {\\em permanent2} is called;} \\item 3. else,{} the local function {\\em permanent3} is called \\indented{3}{(works for all commutative rings \\spad{R}).} \\end{items}"))) 
 NIL 
 NIL 
 (|PermutationCategory| S) 
 ((|constructor| (NIL "PermutationCategory provides a categorial environment \\indented{1}{for subgroups of bijections of a set (\\spadignore{i.e.} permutations)}")) (< (((|Boolean|) $ $) "\\spad{p < q} is an order relation on permutations. Note: this order is only total if and only if \\spad{S} is totally ordered or \\spad{S} is finite.")) (|orbit| (((|Set| |#1|) $ |#1|) "\\spad{orbit(p, el)} returns the orbit of {\\em el} under the permutation \\spad{p},{} \\spadignore{i.e.} the set which is given by applications of the powers of \\spad{p} to {\\em el}.")) (|support| (((|Set| |#1|) $) "\\spad{support p} returns the set of points not fixed by the permutation \\spad{p}.")) (|cycles| (($ (|List| (|List| |#1|))) "\\spad{cycles(lls)} coerces a list list of cycles {\\em lls} to a permutation,{} each cycle being a list with not repetitions,{} is coerced to the permutation,{} which maps {\\em ls.i} to {\\em ls.i+1},{} indices modulo the length of the list,{} then these permutations are mutiplied. Error: if repetitions occur in one cycle.")) (|cycle| (($ (|List| |#1|)) "\\spad{cycle(ls)} coerces a cycle {\\em ls},{} \\spadignore{i.e.} a list with not repetitions to a permutation,{} which maps {\\em ls.i} to {\\em ls.i+1},{} indices modulo the length of the list. Error: if repetitions occur."))) 
-((|unitsKnown| . T)) 
+NIL 
 NIL 
 (|PermutationGroup| S) 
-((|constructor| (NIL "PermutationGroup implements permutation groups acting on a set \\spad{S},{} \\spadignore{i.e.} all subgroups of the symmetric group of \\spad{S},{} represented as a list of permutations (generators). Note that therefore the objects are not members of the \\Language category \\spadtype{Group}. Using the idea of base and strong generators by Sims,{} basic routines and algorithms are implemented so that the word problem for permutation groups can be solved.")) (|initializeGroupForWordProblem| (((|Void|) $ (|Integer|) (|Integer|)) "\\spad{initializeGroupForWordProblem(gp,m,n)} initializes the group {\\em gp} for the word problem. Notes: (1) with a small integer you get shorter words,{} but the routine takes longer than the standard routine for longer words. (2) be careful: invoking this routine will destroy the possibly stored information about your group (but will recompute it again). (3) users need not call this function normally for the soultion of the word problem.") (((|Void|) $) "\\spad{initializeGroupForWordProblem(gp)} initializes the group {\\em gp} for the word problem. Notes: it calls the other function of this name with parameters 0 and 1: {\\em initializeGroupForWordProblem(gp,0,1)}. Notes: (1) be careful: invoking this routine will destroy the possibly information about your group (but will recompute it again) (2) users need not call this function normally for the soultion of the word problem.")) (<= (((|Boolean|) $ $) "\\spad{gp1 <= gp2} returns \\spad{true} if and only if {\\em gp1} is a subgroup of {\\em gp2}. Note: because of a bug in the parser you have to call this function explicitly by {\\em gp1 <=\\$(PERMGRP S) gp2}.")) (< (((|Boolean|) $ $) "\\spad{gp1 < gp2} returns \\spad{true} if and only if {\\em gp1} is a proper subgroup of {\\em gp2}.")) (|support| (((|Set| |#1|) $) "\\spad{support(gp)} returns the points moved by the group {\\em gp}.")) (|wordInGenerators| (((|List| (|NonNegativeInteger|)) (|Permutation| |#1|) $) "\\spad{wordInGenerators(p,gp)} returns the word for the permutation \\spad{p} in the original generators of the group {\\em gp},{} represented by the indices of the list,{} given by {\\em generators}.")) (|wordInStrongGenerators| (((|List| (|NonNegativeInteger|)) (|Permutation| |#1|) $) "\\spad{wordInStrongGenerators(p,gp)} returns the word for the permutation \\spad{p} in the strong generators of the group {\\em gp},{} represented by the indices of the list,{} given by {\\em strongGenerators}.")) (|member?| (((|Boolean|) (|Permutation| |#1|) $) "\\spad{member?(pp,gp)} answers the question,{} whether the permutation {\\em pp} is in the group {\\em gp} or not.")) (|orbits| (((|Set| (|Set| |#1|)) $) "\\spad{orbits(gp)} returns the orbits of the group {\\em gp},{} \\spadignore{i.e.} it partitions the (finite) of all moved points.")) (|orbit| (((|Set| (|List| |#1|)) $ (|List| |#1|)) "\\spad{orbit(gp,ls)} returns the orbit of the ordered list {\\em ls} under the group {\\em gp}. Note: return type is \\spad{L} \\spad{L} \\spad{S} temporarily because FSET \\spad{L} \\spad{S} has an error.") (((|Set| (|Set| |#1|)) $ (|Set| |#1|)) "\\spad{orbit(gp,els)} returns the orbit of the unordered set {\\em els} under the group {\\em gp}.") (((|Set| |#1|) $ |#1|) "\\spad{orbit(gp,el)} returns the orbit of the element {\\em el} under the group {\\em gp},{} \\spadignore{i.e.} the set of all points gained by applying each group element to {\\em el}.")) (|permutationGroup| (($ (|List| (|Permutation| |#1|))) "\\spad{permutationGroup(ls)} coerces a list of permutations {\\em ls} to the group generated by this list.")) (|wordsForStrongGenerators| (((|List| (|List| (|NonNegativeInteger|))) $) "\\spad{wordsForStrongGenerators(gp)} returns the words for the strong generators of the group {\\em gp} in the original generators of {\\em gp},{} represented by their indices in the list,{} given by {\\em generators}.")) (|strongGenerators| (((|List| (|Permutation| |#1|)) $) "\\spad{strongGenerators(gp)} returns strong generators for the group {\\em gp}.")) (|base| (((|List| |#1|) $) "\\spad{base(gp)} returns a base for the group {\\em gp}.")) (|degree| (((|NonNegativeInteger|) $) "\\spad{degree(gp)} returns the number of points moved by all permutations of the group {\\em gp}.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(gp)} returns the order of the group {\\em gp}.")) (|random| (((|Permutation| |#1|) $) "\\spad{random(gp)} returns a random product of maximal 20 generators of the group {\\em gp}. Note: {\\em random(gp)=random(gp,20)}.") (((|Permutation| |#1|) $ (|Integer|)) "\\spad{random(gp,i)} returns a random product of maximal \\spad{i} generators of the group {\\em gp}.")) (|elt| (((|Permutation| |#1|) $ (|NonNegativeInteger|)) "\\spad{elt(gp,i)} returns the \\spad{i}-th generator of the group {\\em gp}.")) (|generators| (((|List| (|Permutation| |#1|)) $) "\\spad{generators(gp)} returns the generators of the group {\\em gp}.")) (|coerce| (($ (|List| (|Permutation| |#1|))) "\\spad{coerce(ls)} coerces a list of permutations {\\em ls} to the group generated by this list.") (((|List| (|Permutation| |#1|)) $) "\\spad{coerce(gp)} returns the generators of the group {\\em gp}."))) 
+((|constructor| (NIL "PermutationGroup implements permutation groups acting on a set \\spad{S},{} \\spadignore{i.e.} all subgroups of the symmetric group of \\spad{S},{} represented as a list of permutations (generators). Note that therefore the objects are not members of the \\Language category \\spadtype{Group}. Using the idea of base and strong generators by Sims,{} basic routines and algorithms are implemented so that the word problem for permutation groups can be solved.")) (|initializeGroupForWordProblem| (((|Void|) $ (|Integer|) (|Integer|)) "\\spad{initializeGroupForWordProblem(gp,m,n)} initializes the group {\\em gp} for the word problem. Notes: (1) with a small integer you get shorter words,{} but the routine takes longer than the standard routine for longer words. (2) be careful: invoking this routine will destroy the possibly stored information about your group (but will recompute it again). (3) users need not call this function normally for the soultion of the word problem.") (((|Void|) $) "\\spad{initializeGroupForWordProblem(gp)} initializes the group {\\em gp} for the word problem. Notes: it calls the other function of this name with parameters 0 and 1: {\\em initializeGroupForWordProblem(gp,0,1)}. Notes: (1) be careful: invoking this routine will destroy the possibly information about your group (but will recompute it again) (2) users need not call this function normally for the soultion of the word problem.")) (<= (((|Boolean|) $ $) "\\spad{gp1 <= gp2} returns \\spad{true} if and only if {\\em gp1} is a subgroup of {\\em gp2}. Note: because of a bug in the parser you have to call this function explicitly by {\\em gp1 <=\\$(PERMGRP S) gp2}.")) (< (((|Boolean|) $ $) "\\spad{gp1 < gp2} returns \\spad{true} if and only if {\\em gp1} is a proper subgroup of {\\em gp2}.")) (|support| (((|Set| |#1|) $) "\\spad{support(gp)} returns the points moved by the group {\\em gp}.")) (|wordInGenerators| (((|List| (|NonNegativeInteger|)) (|Permutation| |#1|) $) "\\spad{wordInGenerators(p,gp)} returns the word for the permutation \\spad{p} in the original generators of the group {\\em gp},{} represented by the indices of the list,{} given by {\\em generators}.")) (|wordInStrongGenerators| (((|List| (|NonNegativeInteger|)) (|Permutation| |#1|) $) "\\spad{wordInStrongGenerators(p,gp)} returns the word for the permutation \\spad{p} in the strong generators of the group {\\em gp},{} represented by the indices of the list,{} given by {\\em strongGenerators}.")) (|member?| (((|Boolean|) (|Permutation| |#1|) $) "\\spad{member?(pp,gp)} answers the question,{} whether the permutation {\\em pp} is in the group {\\em gp} or not.")) (|orbits| (((|Set| (|Set| |#1|)) $) "\\spad{orbits(gp)} returns the orbits of the group {\\em gp},{} \\spadignore{i.e.} it partitions the (finite) of all moved points.")) (|orbit| (((|Set| (|List| |#1|)) $ (|List| |#1|)) "\\spad{orbit(gp,ls)} returns the orbit of the ordered list {\\em ls} under the group {\\em gp}. Note: return type is \\spad{L} \\spad{L} \\spad{S} temporarily because FSET \\spad{L} \\spad{S} has an error.") (((|Set| (|Set| |#1|)) $ (|Set| |#1|)) "\\spad{orbit(gp,els)} returns the orbit of the unordered set {\\em els} under the group {\\em gp}.") (((|Set| |#1|) $ |#1|) "\\spad{orbit(gp,el)} returns the orbit of the element {\\em el} under the group {\\em gp},{} \\spadignore{i.e.} the set of all points gained by applying each group element to {\\em el}.")) (|permutationGroup| (($ (|List| (|Permutation| |#1|))) "\\spad{permutationGroup(ls)} coerces a list of permutations {\\em ls} to the group generated by this list.")) (|wordsForStrongGenerators| (((|List| (|List| (|NonNegativeInteger|))) $) "\\spad{wordsForStrongGenerators(gp)} returns the words for the strong generators of the group {\\em gp} in the original generators of {\\em gp},{} represented by their indices in the list,{} given by {\\em generators}.")) (|strongGenerators| (((|List| (|Permutation| |#1|)) $) "\\spad{strongGenerators(gp)} returns strong generators for the group {\\em gp}.")) (|base| (((|List| |#1|) $) "\\spad{base(gp)} returns a base for the group {\\em gp}.")) (|degree| (((|NonNegativeInteger|) $) "\\spad{degree(gp)} returns the number of points moved by all permutations of the group {\\em gp}.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(gp)} returns the order of the group {\\em gp}.")) (|random| (((|Permutation| |#1|) $) "\\spad{random(gp)} returns a random product of maximal 20 generators of the group {\\em gp}. Note: {\\em random(gp)=random(gp,20)}.") (((|Permutation| |#1|) $ (|Integer|)) "\\spad{random(gp,i)} returns a random product of maximal \\spad{i} generators of the group {\\em gp}.")) (|elt| (((|Permutation| |#1|) $ (|NonNegativeInteger|)) "\\spad{elt(gp,i)} returns the \\spad{i}-th generator of the group {\\em gp}.")) (|generators| (((|List| (|Permutation| |#1|)) $) "\\spad{generators(gp)} returns the generators of the group {\\em gp}."))) 
 NIL 
 NIL 
 (|PrimeField| |p|) 
 ((|constructor| (NIL "PrimeField(\\spad{p}) implements the field with \\spad{p} elements if \\spad{p} is a prime number. Error: if \\spad{p} is not prime. Note: this domain does not check that argument is a prime."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 ((|HasCategory| $ (QUOTE (|CharacteristicZero|))) (|HasCategory| $ (QUOTE (|CharacteristicNonZero|))) (|HasCategory| $ (QUOTE (|Finite|)))) 
 (|PolynomialFactorizationByRecursion| R E |VarSet| S) 
 ((|constructor| (NIL "PolynomialFactorizationByRecursion(\\spad{R},{}\\spad{E},{}\\spad{VarSet},{}\\spad{S}) is used for factorization of sparse univariate polynomials over a domain \\spad{S} of multivariate polynomials over \\spad{R}.")) (|factorSFBRlcUnit| (((|Factored| (|SparseUnivariatePolynomial| |#4|)) (|List| |#3|) (|SparseUnivariatePolynomial| |#4|)) "\\spad{factorSFBRlcUnit(p)} returns the square free factorization of polynomial \\spad{p} (see \\spadfun{factorSquareFreeByRecursion}{PolynomialFactorizationByRecursionUnivariate}) in the case where the leading coefficient of \\spad{p} is a unit.")) (|bivariateSLPEBR| (((|Union| (|List| (|SparseUnivariatePolynomial| |#4|)) "failed") (|List| (|SparseUnivariatePolynomial| |#4|)) (|SparseUnivariatePolynomial| |#4|) |#3|) "\\spad{bivariateSLPEBR(lp,p,v)} implements the bivariate case of \\spadfunFrom{solveLinearPolynomialEquationByRecursion}{PolynomialFactorizationByRecursionUnivariate}; its implementation depends on \\spad{R}")) (|randomR| ((|#1|) "\\spad{randomR produces} a random element of \\spad{R}")) (|factorSquareFreeByRecursion| (((|Factored| (|SparseUnivariatePolynomial| |#4|)) (|SparseUnivariatePolynomial| |#4|)) "\\spad{factorSquareFreeByRecursion(p)} returns the square free factorization of \\spad{p}. This functions performs the recursion step for factorSquareFreePolynomial,{} as defined in \\spadfun{PolynomialFactorizationExplicit} category (see \\spadfun{factorSquareFreePolynomial}).")) (|factorByRecursion| (((|Factored| (|SparseUnivariatePolynomial| |#4|)) (|SparseUnivariatePolynomial| |#4|)) "\\spad{factorByRecursion(p)} factors polynomial \\spad{p}. This function performs the recursion step for factorPolynomial,{} as defined in \\spadfun{PolynomialFactorizationExplicit} category (see \\spadfun{factorPolynomial})")) (|solveLinearPolynomialEquationByRecursion| (((|Union| (|List| (|SparseUnivariatePolynomial| |#4|)) "failed") (|List| (|SparseUnivariatePolynomial| |#4|)) (|SparseUnivariatePolynomial| |#4|)) "\\spad{solveLinearPolynomialEquationByRecursion([p1,...,pn],p)} returns the list of polynomials \\spad{[q1,...,qn]} such that \\spad{sum qi/pi = p / prod pi},{} a recursion step for solveLinearPolynomialEquation as defined in \\spadfun{PolynomialFactorizationExplicit} category (see \\spadfun{solveLinearPolynomialEquation}). If no such list of \\spad{qi} exists,{} then \"failed\" is returned."))) 
@@ -3230,7 +3230,7 @@ NIL
 ((|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|)))) 
 (|PolynomialFactorizationExplicit|) 
 ((|constructor| (NIL "This is the category of domains that know \"enough\" about themselves in order to factor univariate polynomials over themselves. This will be used in future releases for supporting factorization over finitely generated coefficient fields,{} it is not yet available in the current release of axiom.")) (|charthRoot| (((|Maybe| $) $) "\\spad{charthRoot(r)} returns the \\spad{p}\\spad{-}th root of \\spad{r},{} or \\spad{nothing} if none exists in the domain.")) (|conditionP| (((|Union| (|Vector| $) "failed") (|Matrix| $)) "\\spad{conditionP(m)} returns a vector of elements,{} not all zero,{} whose \\spad{p}\\spad{-}th powers (\\spad{p} is the characteristic of the domain) are a solution of the homogenous linear system represented by \\spad{m},{} or \"failed\" is there is no such vector.")) (|solveLinearPolynomialEquation| (((|Union| (|List| (|SparseUnivariatePolynomial| $)) "failed") (|List| (|SparseUnivariatePolynomial| $)) (|SparseUnivariatePolynomial| $)) "\\spad{solveLinearPolynomialEquation([f1, ..., fn], g)} (where the \\spad{fi} are relatively prime to each other) returns a list of \\spad{ai} such that \\spad{g/prod fi = sum ai/fi} or returns \"failed\" if no such list of \\spad{ai}'s exists.")) (|gcdPolynomial| (((|SparseUnivariatePolynomial| $) (|SparseUnivariatePolynomial| $) (|SparseUnivariatePolynomial| $)) "\\spad{gcdPolynomial(p,q)} returns the gcd of the univariate polynomials \\spad{p} qnd \\spad{q}.")) (|factorSquareFreePolynomial| (((|Factored| (|SparseUnivariatePolynomial| $)) (|SparseUnivariatePolynomial| $)) "\\spad{factorSquareFreePolynomial(p)} factors the univariate polynomial \\spad{p} into irreducibles where \\spad{p} is known to be square free and primitive with respect to its main variable.")) (|factorPolynomial| (((|Factored| (|SparseUnivariatePolynomial| $)) (|SparseUnivariatePolynomial| $)) "\\spad{factorPolynomial(p)} returns the factorization into irreducibles of the univariate polynomial \\spad{p}.")) (|squareFreePolynomial| (((|Factored| (|SparseUnivariatePolynomial| $)) (|SparseUnivariatePolynomial| $)) "\\spad{squareFreePolynomial(p)} returns the square-free factorization of the univariate polynomial \\spad{p}."))) 
-((|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|PointsOfFiniteOrder| R0 F UP UPUP R) 
 ((|constructor| (NIL "This package provides function for testing whether a divisor on a curve is a torsion divisor.")) (|torsionIfCan| (((|Union| (|Record| (|:| |order| (|NonNegativeInteger|)) (|:| |function| |#5|)) "failed") (|FiniteDivisor| |#2| |#3| |#4| |#5|)) "\\spad{torsionIfCan(f)}\\\\ undocumented")) (|torsion?| (((|Boolean|) (|FiniteDivisor| |#2| |#3| |#4| |#5|)) "\\spad{torsion?(f)} \\undocumented")) (|order| (((|Union| (|NonNegativeInteger|) "failed") (|FiniteDivisor| |#2| |#3| |#4| |#5|)) "\\spad{order(f)} \\undocumented"))) 
@@ -3245,8 +3245,8 @@ NIL
 NIL 
 NIL 
 (|PartialFraction| R) 
-((|constructor| (NIL "The domain \\spadtype{PartialFraction} implements partial fractions over a euclidean domain \\spad{R}. This requirement on the argument domain allows us to normalize the fractions. Of particular interest are the 2 forms for these fractions. The ``compact'' form has only one fractional term per prime in the denominator,{} while the ``p-adic'' form expands each numerator \\spad{p}-adically via the prime \\spad{p} in the denominator. For computational efficiency,{} the compact form is used,{} though the \\spad{p}-adic form may be gotten by calling the function \\spadfunFrom{padicFraction}{PartialFraction}. For a general euclidean domain,{} it is not known how to factor the denominator. Thus the function \\spadfunFrom{partialFraction}{PartialFraction} takes as its second argument an element of \\spadtype{Factored(R)}.")) (|wholePart| ((|#1| $) "\\spad{wholePart(p)} extracts the whole part of the partial fraction \\spad{p}.")) (|partialFraction| (($ |#1| (|Factored| |#1|)) "\\spad{partialFraction(numer,denom)} is the main function for constructing partial fractions. The second argument is the denominator and should be factored.")) (|padicFraction| (($ $) "\\spad{padicFraction(q)} expands the fraction \\spad{p}-adically in the primes \\spad{p} in the denominator of \\spad{q}. For example,{} \\spad{padicFraction(3/(2**2)) = 1/2 + 1/(2**2)}. Use \\spadfunFrom{compactFraction}{PartialFraction} to return to compact form.")) (|padicallyExpand| (((|SparseUnivariatePolynomial| |#1|) |#1| |#1|) "\\spad{padicallyExpand(p,x)} is a utility function that expands the second argument \\spad{x} ``p-adically'' in the first.")) (|numberOfFractionalTerms| (((|Integer|) $) "\\spad{numberOfFractionalTerms(p)} computes the number of fractional terms in \\spad{p}. This returns 0 if there is no fractional part.")) (|nthFractionalTerm| (($ $ (|Integer|)) "\\spad{nthFractionalTerm(p,n)} extracts the \\spad{n}th fractional term from the partial fraction \\spad{p}. This returns 0 if the index \\spad{n} is out of range.")) (|firstNumer| ((|#1| $) "\\spad{firstNumer(p)} extracts the numerator of the first fractional term. This returns 0 if there is no fractional part (use \\spadfunFrom{wholePart}{PartialFraction} to get the whole part).")) (|firstDenom| (((|Factored| |#1|) $) "\\spad{firstDenom(p)} extracts the denominator of the first fractional term. This returns 1 if there is no fractional part (use \\spadfunFrom{wholePart}{PartialFraction} to get the whole part).")) (|compactFraction| (($ $) "\\spad{compactFraction(p)} normalizes the partial fraction \\spad{p} to the compact representation. In this form,{} the partial fraction has only one fractional term per prime in the denominator.")) (|coerce| (($ (|Fraction| (|Factored| |#1|))) "\\spad{coerce(f)} takes a fraction with numerator and denominator in factored form and creates a partial fraction. It is necessary for the parts to be factored because it is not known in general how to factor elements of \\spad{R} and this is needed to decompose into partial fractions.") (((|Fraction| |#1|) $) "\\spad{coerce(p)} sums up the components of the partial fraction and returns a single fraction."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|constructor| (NIL "The domain \\spadtype{PartialFraction} implements partial fractions over a euclidean domain \\spad{R}. This requirement on the argument domain allows us to normalize the fractions. Of particular interest are the 2 forms for these fractions. The ``compact'' form has only one fractional term per prime in the denominator,{} while the ``p-adic'' form expands each numerator \\spad{p}-adically via the prime \\spad{p} in the denominator. For computational efficiency,{} the compact form is used,{} though the \\spad{p}-adic form may be gotten by calling the function \\spadfunFrom{padicFraction}{PartialFraction}. For a general euclidean domain,{} it is not known how to factor the denominator. Thus the function \\spadfunFrom{partialFraction}{PartialFraction} takes as its second argument an element of \\spadtype{Factored(R)}.")) (|wholePart| ((|#1| $) "\\spad{wholePart(p)} extracts the whole part of the partial fraction \\spad{p}.")) (|partialFraction| (($ |#1| (|Factored| |#1|)) "\\spad{partialFraction(numer,denom)} is the main function for constructing partial fractions. The second argument is the denominator and should be factored.")) (|padicFraction| (($ $) "\\spad{padicFraction(q)} expands the fraction \\spad{p}-adically in the primes \\spad{p} in the denominator of \\spad{q}. For example,{} \\spad{padicFraction(3/(2**2)) = 1/2 + 1/(2**2)}. Use \\spadfunFrom{compactFraction}{PartialFraction} to return to compact form.")) (|padicallyExpand| (((|SparseUnivariatePolynomial| |#1|) |#1| |#1|) "\\spad{padicallyExpand(p,x)} is a utility function that expands the second argument \\spad{x} ``p-adically'' in the first.")) (|numberOfFractionalTerms| (((|Integer|) $) "\\spad{numberOfFractionalTerms(p)} computes the number of fractional terms in \\spad{p}. This returns 0 if there is no fractional part.")) (|nthFractionalTerm| (($ $ (|Integer|)) "\\spad{nthFractionalTerm(p,n)} extracts the \\spad{n}th fractional term from the partial fraction \\spad{p}. This returns 0 if the index \\spad{n} is out of range.")) (|firstNumer| ((|#1| $) "\\spad{firstNumer(p)} extracts the numerator of the first fractional term. This returns 0 if there is no fractional part (use \\spadfunFrom{wholePart}{PartialFraction} to get the whole part).")) (|firstDenom| (((|Factored| |#1|) $) "\\spad{firstDenom(p)} extracts the denominator of the first fractional term. This returns 1 if there is no fractional part (use \\spadfunFrom{wholePart}{PartialFraction} to get the whole part).")) (|compactFraction| (($ $) "\\spad{compactFraction(p)} normalizes the partial fraction \\spad{p} to the compact representation. In this form,{} the partial fraction has only one fractional term per prime in the denominator.")) (|coerce| (($ (|Fraction| (|Factored| |#1|))) "\\spad{coerce(f)} takes a fraction with numerator and denominator in factored form and creates a partial fraction. It is necessary for the parts to be factored because it is not known in general how to factor elements of \\spad{R} and this is needed to decompose into partial fractions."))) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|PartialFractionPackage| R) 
 ((|constructor| (NIL "The package \\spadtype{PartialFractionPackage} gives an easier to use interfact the domain \\spadtype{PartialFraction}. The user gives a fraction of polynomials,{} and a variable and the package converts it to the proper datatype for the \\spadtype{PartialFraction} domain.")) (|partialFraction| (((|Any|) (|Polynomial| |#1|) (|Factored| (|Polynomial| |#1|)) (|Symbol|)) "\\spad{partialFraction(num, facdenom, var)} returns the partial fraction decomposition of the rational function whose numerator is \\spad{num} and whose factored denominator is \\spad{facdenom} with respect to the variable var.") (((|Any|) (|Fraction| (|Polynomial| |#1|)) (|Symbol|)) "\\spad{partialFraction(rf, var)} returns the partial fraction decomposition of the rational function \\spad{rf} with respect to the variable var."))) 
@@ -3274,7 +3274,7 @@ NIL
 NIL 
 (|PrincipalIdealDomain|) 
 ((|constructor| (NIL "The category of constructive principal ideal domains,{} \\spadignore{i.e.} where a single generator can be constructively found for any ideal given by a finite set of generators. Note that this constructive definition only implies that finitely generated ideals are principal. It is not clear what we would mean by an infinitely generated ideal.")) (|expressIdealMember| (((|Maybe| (|List| $)) (|List| $) $) "\\spad{expressIdealMember([f1,...,fn],h)} returns a representation of \\spad{h} as a linear combination of the \\spad{fi} or \\spad{nothing} if \\spad{h} is not in the ideal generated by the \\spad{fi}.")) (|principalIdeal| (((|Record| (|:| |coef| (|List| $)) (|:| |generator| $)) (|List| $)) "\\spad{principalIdeal([f1,...,fn])} returns a record whose generator component is a generator of the ideal generated by \\spad{[f1,...,fn]} whose coef component satisfies \\spad{generator = sum (input.i * coef.i)}"))) 
-((|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|PolynomialInterpolation| |xx| F) 
 ((|constructor| (NIL "This package exports interpolation algorithms")) (|interpolate| (((|SparseUnivariatePolynomial| |#2|) (|List| |#2|) (|List| |#2|)) "\\spad{interpolate(lf,lg)} \\undocumented") (((|UnivariatePolynomial| |#1| |#2|) (|UnivariatePolynomial| |#1| |#2|) (|List| |#2|) (|List| |#2|)) "\\spad{interpolate(u,lf,lg)} \\undocumented"))) 
@@ -3374,8 +3374,8 @@ NIL
 ((|HasCategory| |#1| (QUOTE (|OrderedRing|)))) 
 (|Polynomial| R) 
 ((|constructor| (NIL "\\indented{2}{This type is the basic representation of sparse recursive multivariate} polynomials whose variables are arbitrary symbols. The ordering is alphabetic determined by the Symbol type. The coefficient ring may be non commutative,{} but the variables are assumed to commute.")) (|integrate| (($ $ (|Symbol|)) "\\spad{integrate(p,x)} computes the integral of \\spad{p*dx},{} \\spadignore{i.e.} integrates the polynomial \\spad{p} with respect to the variable \\spad{x}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#1| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|Symbol|) #5#)) (AND (|HasCategory| |#1| #8=(QUOTE (|PatternMatchable| #9=(|Integer|)))) (|HasCategory| #7# #8#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#1| #12=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #12#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #9#))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #13=(|HasCategory| |#1| #14=(QUOTE (|CharacteristicNonZero|))) #15=(|HasCategory| |#1| (QUOTE (|Algebra| #16=(|Fraction| #9#)))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #9#))) (OR #15# #17=(|HasCategory| |#1| (QUOTE (|RetractableTo| #16#)))) #17# (|HasCategory| |#1| (QUOTE (|Field|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #3# #18=(AND #1# (|HasCategory| $ #14#)) (OR #18# #13#)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#1| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|Symbol|) #5#)) (AND (|HasCategory| |#1| #8=(QUOTE (|PatternMatchable| #9=(|Integer|)))) (|HasCategory| #7# #8#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|Pattern| #9#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#1| #12=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #12#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #9#))) #13=(|HasCategory| |#1| (QUOTE (|Algebra| #14=(|Fraction| #9#)))) #15=(|HasCategory| |#1| #16=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #9#))) (OR #13# #17=(|HasCategory| |#1| (QUOTE (|RetractableTo| #14#)))) #17# (|HasCategory| |#1| (QUOTE (|Field|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #3# #18=(AND #1# (|HasCategory| $ #16#)) (OR #18# #15#)) 
 (|PolynomialFunctions2| R S) 
 ((|constructor| (NIL "\\indented{2}{This package takes a mapping between coefficient rings,{} and lifts} it to a mapping between polynomials over those rings.")) (|map| (((|Polynomial| |#2|) (|Mapping| |#2| |#1|) (|Polynomial| |#1|)) "\\spad{map(f, p)} produces a new polynomial as a result of applying the function \\spad{f} to every coefficient of the polynomial \\spad{p}."))) 
 NIL 
@@ -3390,7 +3390,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) (|HasAttribute| |#2| (QUOTE |canonicalUnitNormal|)) (|HasCategory| |#2| (QUOTE (|GcdDomain|))) (|HasCategory| |#2| (QUOTE (|CommutativeRing|))) (|HasCategory| |#4| #1=(QUOTE (|PatternMatchable| #2=(|Float|)))) (|HasCategory| |#2| #1#) (|HasCategory| |#4| #3=(QUOTE (|PatternMatchable| #4=(|Integer|)))) (|HasCategory| |#2| #3#) (|HasCategory| |#4| #5=(QUOTE (|ConvertibleTo| (|Pattern| #2#)))) (|HasCategory| |#2| #5#) (|HasCategory| |#4| #6=(QUOTE (|ConvertibleTo| (|Pattern| #4#)))) (|HasCategory| |#2| #6#) (|HasCategory| |#4| #7=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#2| #7#)) 
 (|PolynomialCategory| R E |VarSet|) 
 ((|constructor| (NIL "The category for general multi-variate polynomials over a ring \\spad{R},{} in variables from VarSet,{} with exponents from the \\spadtype{OrderedAbelianMonoidSup}.")) (|canonicalUnitNormal| ((|attribute|) "we can choose a unique representative for each associate class. This normalization is chosen to be normalization of leading coefficient (by default).")) (|squareFreePart| (($ $) "\\spad{squareFreePart(p)} returns product of all the irreducible factors of polynomial \\spad{p} each taken with multiplicity one.")) (|squareFree| (((|Factored| $) $) "\\spad{squareFree(p)} returns the square free factorization of the polynomial \\spad{p}.")) (|primitivePart| (($ $ |#3|) "\\spad{primitivePart(p,v)} returns the unitCanonical associate of the polynomial \\spad{p} with its content with respect to the variable \\spad{v} divided out.") (($ $) "\\spad{primitivePart(p)} returns the unitCanonical associate of the polynomial \\spad{p} with its content divided out.")) (|content| (($ $ |#3|) "\\spad{content(p,v)} is the gcd of the coefficients of the polynomial \\spad{p} when \\spad{p} is viewed as a univariate polynomial with respect to the variable \\spad{v}. Thus,{} for polynomial 7*x**2*y + 14*x*y**2,{} the gcd of the coefficients with respect to \\spad{x} is 7*y.")) (|discriminant| (($ $ |#3|) "\\spad{discriminant(p,v)} returns the disriminant of the polynomial \\spad{p} with respect to the variable \\spad{v}.")) (|resultant| (($ $ $ |#3|) "\\spad{resultant(p,q,v)} returns the resultant of the polynomials \\spad{p} and \\spad{q} with respect to the variable \\spad{v}.")) (|primitiveMonomials| (((|List| $) $) "\\spad{primitiveMonomials(p)} gives the list of monomials of the polynomial \\spad{p} with their coefficients removed. Note: \\spad{primitiveMonomials(sum(a_(i) X^(i))) = [X^(1),...,X^(n)]}.")) (|variables| (((|List| |#3|) $) "\\spad{variables(p)} returns the list of those variables actually appearing in the polynomial \\spad{p}.")) (|totalDegree| (((|NonNegativeInteger|) $ (|List| |#3|)) "\\spad{totalDegree(p, lv)} returns the maximum sum (over all monomials of polynomial \\spad{p}) of the variables in the list lv.") (((|NonNegativeInteger|) $) "\\spad{totalDegree(p)} returns the largest sum over all monomials of all exponents of a monomial.")) (|isExpt| (((|Union| (|Record| (|:| |var| |#3|) (|:| |exponent| (|NonNegativeInteger|))) "failed") $) "\\spad{isExpt(p)} returns \\spad{[x, n]} if polynomial \\spad{p} has the form \\spad{x**n} and \\spad{n > 0}.")) (|isTimes| (((|Union| (|List| $) "failed") $) "\\spad{isTimes(p)} returns \\spad{[a1,...,an]} if polynomial \\spad{p = a1 ... an} and \\spad{n >= 2},{} and,{} for each \\spad{i},{} \\spad{ai} is either a nontrivial constant in \\spad{R} or else of the form \\spad{x**e},{} where \\spad{e > 0} is an integer and \\spad{x} in a member of VarSet.")) (|isPlus| (((|Union| (|List| $) "failed") $) "\\spad{isPlus(p)} returns \\spad{[m1,...,mn]} if polynomial \\spad{p = m1 + ... + mn} and \\spad{n >= 2} and each \\spad{mi} is a nonzero monomial.")) (|multivariate| (($ (|SparseUnivariatePolynomial| $) |#3|) "\\spad{multivariate(sup,v)} converts an anonymous univariable polynomial \\spad{sup} to a polynomial in the variable \\spad{v}.") (($ (|SparseUnivariatePolynomial| |#1|) |#3|) "\\spad{multivariate(sup,v)} converts an anonymous univariable polynomial \\spad{sup} to a polynomial in the variable \\spad{v}.")) (|monomial| (($ $ (|List| |#3|) (|List| (|NonNegativeInteger|))) "\\spad{monomial(a,[v1..vn],[e1..en])} returns \\spad{a*prod(vi**ei)}.") (($ $ |#3| (|NonNegativeInteger|)) "\\spad{monomial(a,x,n)} creates the monomial \\spad{a*x**n} where \\spad{a} is a polynomial,{} \\spad{x} is a variable and \\spad{n} is a nonnegative integer.")) (|monicDivide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $ |#3|) "\\spad{monicDivide(a,b,v)} divides the polynomial a by the polynomial \\spad{b},{} with each viewed as a univariate polynomial in \\spad{v} returning both the quotient and remainder. Error: if \\spad{b} is not monic with respect to \\spad{v}.")) (|minimumDegree| (((|List| (|NonNegativeInteger|)) $ (|List| |#3|)) "\\spad{minimumDegree(p, lv)} gives the list of minimum degrees of the polynomial \\spad{p} with respect to each of the variables in the list lv") (((|NonNegativeInteger|) $ |#3|) "\\spad{minimumDegree(p,v)} gives the minimum degree of polynomial \\spad{p} with respect to \\spad{v},{} \\spadignore{i.e.} viewed a univariate polynomial in \\spad{v}")) (|mainVariable| (((|Union| |#3| "failed") $) "\\spad{mainVariable(p)} returns the biggest variable which actually occurs in the polynomial \\spad{p},{} or \"failed\" if no variables are present. fails precisely if polynomial satisfies ground?")) (|univariate| (((|SparseUnivariatePolynomial| |#1|) $) "\\spad{univariate(p)} converts the multivariate polynomial \\spad{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") (((|SparseUnivariatePolynomial| $) $ |#3|) "\\spad{univariate(p,v)} converts the multivariate polynomial \\spad{p} into a univariate polynomial in \\spad{v},{} whose coefficients are still multivariate polynomials (in all the other variables).")) (|monomials| (((|List| $) $) "\\spad{monomials(p)} returns the list of non-zero monomials of polynomial \\spad{p},{} \\spadignore{i.e.} \\spad{monomials(sum(a_(i) X^(i))) = [a_(1) X^(1),...,a_(n) X^(n)]}.")) (|coefficient| (($ $ (|List| |#3|) (|List| (|NonNegativeInteger|))) "\\spad{coefficient(p, lv, ln)} views the polynomial \\spad{p} as a polynomial in the variables of \\spad{lv} and returns the coefficient of the term \\spad{lv**ln},{} \\spadignore{i.e.} \\spad{prod(lv_i ** ln_i)}.") (($ $ |#3| (|NonNegativeInteger|)) "\\spad{coefficient(p,v,n)} views the polynomial \\spad{p} as a univariate polynomial in \\spad{v} and returns the coefficient of the \\spad{v**n} term.")) (|degree| (((|List| (|NonNegativeInteger|)) $ (|List| |#3|)) "\\spad{degree(p,lv)} gives the list of degrees of polynomial \\spad{p} with respect to each of the variables in the list \\spad{lv}.") (((|NonNegativeInteger|) $ |#3|) "\\spad{degree(p,v)} gives the degree of polynomial \\spad{p} with respect to the variable \\spad{v}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
 NIL 
 (|PolynomialCategoryQuotientFunctions| E V R P F) 
 ((|constructor| (NIL "This package transforms multivariate polynomials or fractions into univariate polynomials or fractions,{} and back.")) (|isPower| (((|Union| (|Record| (|:| |val| |#5|) (|:| |exponent| (|Integer|))) "failed") |#5|) "\\spad{isPower(p)} returns \\spad{[x, n]} if \\spad{p = x**n} and \\spad{n <> 0},{} \"failed\" otherwise.")) (|isExpt| (((|Union| (|Record| (|:| |var| |#2|) (|:| |exponent| (|Integer|))) "failed") |#5|) "\\spad{isExpt(p)} returns \\spad{[x, n]} if \\spad{p = x**n} and \\spad{n <> 0},{} \"failed\" otherwise.")) (|isTimes| (((|Union| (|List| |#5|) "failed") |#5|) "\\spad{isTimes(p)} returns \\spad{[a1,...,an]} if \\spad{p = a1 ... an} and \\spad{n > 1},{} \"failed\" otherwise.")) (|isPlus| (((|Union| (|List| |#5|) "failed") |#5|) "\\spad{isPlus(p)} returns [\\spad{m1},{}...,{}mn] if \\spad{p = m1 + ... + mn} and \\spad{n > 1},{} \"failed\" otherwise.")) (|multivariate| ((|#5| (|Fraction| (|SparseUnivariatePolynomial| |#5|)) |#2|) "\\spad{multivariate(f, v)} applies both the numerator and denominator of \\spad{f} to \\spad{v}.")) (|univariate| (((|SparseUnivariatePolynomial| |#5|) |#5| |#2| (|SparseUnivariatePolynomial| |#5|)) "\\spad{univariate(f, x, p)} returns \\spad{f} viewed as a univariate polynomial in \\spad{x},{} using the side-condition \\spad{p(x) = 0}.") (((|Fraction| (|SparseUnivariatePolynomial| |#5|)) |#5| |#2|) "\\spad{univariate(f, v)} returns \\spad{f} viewed as a univariate rational function in \\spad{v}.")) (|mainVariable| (((|Union| |#2| "failed") |#5|) "\\spad{mainVariable(f)} returns the highest variable appearing in the numerator or the denominator of \\spad{f},{} \"failed\" if \\spad{f} has no variables.")) (|variables| (((|List| |#2|) |#5|) "\\spad{variables(f)} returns the list of variables appearing in the numerator or the denominator of \\spad{f}."))) 
@@ -3414,7 +3414,7 @@ NIL
 NIL 
 (|PolynomialRing| R E) 
 ((|constructor| (NIL "This domain represents generalized polynomials with coefficients (from a not necessarily commutative ring),{} and terms indexed by their exponents (from an arbitrary ordered abelian monoid). This type is used,{} for example,{} by the \\spadtype{DistributedMultivariatePolynomial} domain where the exponent domain is a direct product of non negative integers.")) (|canonicalUnitNormal| ((|attribute|) "canonicalUnitNormal guarantees that the function unitCanonical returns the same representative for all associates of any particular element.")) (|fmecg| (($ $ |#2| |#1| $) "\\spad{fmecg(p1,e,r,p2)} finds \\spad{X} : \\spad{p1} - \\spad{r} * X**e * \\spad{p2}"))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
 (#1=(|HasCategory| |#1| (QUOTE (|Algebra| #2=(|Fraction| #3=(|Integer|))))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (OR #5=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #4#) #5# (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (OR #1# #6=(|HasCategory| |#1| (QUOTE (|RetractableTo| #2#)))) #6# (|HasCategory| |#1| (QUOTE (|RetractableTo| #3#))) (|HasCategory| |#1| (QUOTE (|Field|))) (|HasCategory| |#1| (QUOTE (|GcdDomain|))) (AND #4# (|HasCategory| |#2| (QUOTE (|CancellationAbelianMonoid|)))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|))) 
 (|PrecomputedAssociatedEquations| R L) 
 ((|constructor| (NIL "\\spadtype{PrecomputedAssociatedEquations} stores some generic precomputations which speed up the computations of the associated equations needed for factoring operators.")) (|firstUncouplingMatrix| (((|Union| (|Matrix| |#1|) "failed") |#2| (|PositiveInteger|)) "\\spad{firstUncouplingMatrix(op, m)} returns the matrix A such that \\spad{A w = (W',W'',...,W^N)} in the corresponding associated equations for right-factors of order \\spad{m} of \\spad{op}. Returns \"failed\" if the matrix A has not been precomputed for the particular combination \\spad{degree(L), m}."))) 
@@ -3446,7 +3446,7 @@ NIL
 NIL 
 (|Product| A B) 
 ((|constructor| (NIL "This domain implements cartesian product")) (|selectsecond| ((|#2| $) "\\spad{selectsecond(x)} \\undocumented")) (|selectfirst| ((|#1| $) "\\spad{selectfirst(x)} \\undocumented")) (|makeprod| (($ |#1| |#2|) "\\spad{makeprod(a,b)} \\undocumented"))) 
-((|unitsKnown| AND (|has| |#2| #1=(|Group|)) (|has| |#1| #1#))) 
+NIL 
 ((OR #1=(AND (|HasCategory| |#1| #2=(QUOTE (|OrderedAbelianMonoidSup|))) (|HasCategory| |#2| #2#)) #3=(AND (|HasCategory| |#1| #4=(QUOTE (|OrderedSet|))) (|HasCategory| |#2| #4#))) #1# (OR #5=(AND (|HasCategory| |#1| #6=(QUOTE (|CancellationAbelianMonoid|))) (|HasCategory| |#2| #6#)) #1# #7=(AND (|HasCategory| |#1| #8=(QUOTE (|AbelianGroup|))) (|HasCategory| |#2| #8#))) #7# (OR #5# #1# #7# #9=(AND (|HasCategory| |#1| #10=(QUOTE (|AbelianMonoid|))) (|HasCategory| |#2| #10#))) #11=(AND (|HasCategory| |#1| #12=(QUOTE (|Group|))) (|HasCategory| |#2| #12#)) (OR #11# #13=(AND (|HasCategory| |#1| #14=(QUOTE (|Monoid|))) (|HasCategory| |#2| #14#))) (AND (|HasCategory| |#1| #15=(QUOTE (|Finite|))) (|HasCategory| |#2| #15#)) (OR #5# #1# #7# #9# #11# #13#) #13# #9# #5# #3#) 
 (|Property|) 
 ((|constructor| (NIL "\\indented{1}{Author: Gabriel Dos Reis} Date Created: October 24,{} 2007 Date Last Modified: January 18,{} 2008. An `Property' is a pair of name and value.")) (|property| (($ (|Identifier|) (|SExpression|)) "\\spad{property(n,val)} constructs a property with name `n' and value `val'.")) (|value| (((|SExpression|) $) "\\spad{value(p)} returns value of property \\spad{p}")) (|name| (((|Identifier|) $) "\\spad{name(p)} returns the name of property \\spad{p}"))) 
@@ -3490,7 +3490,7 @@ NIL
 NIL 
 (|PowerSeriesCategory| |Coef| |Expon| |Var|) 
 ((|constructor| (NIL "\\spadtype{PowerSeriesCategory} is the most general power series category with exponents in an ordered abelian monoid.")) (|complete| (($ $) "\\spad{complete(f)} causes all terms of \\spad{f} to be computed. Note: this results in an infinite loop if \\spad{f} has infinitely many terms.")) (|pole?| (((|Boolean|) $) "\\spad{pole?(f)} determines if the power series \\spad{f} has a pole.")) (|variables| (((|List| |#3|) $) "\\spad{variables(f)} returns a list of the variables occuring in the power series \\spad{f}.")) (|degree| ((|#2| $) "\\spad{degree(f)} returns the exponent of the lowest order term of \\spad{f}.")) (|leadingCoefficient| ((|#1| $) "\\spad{leadingCoefficient(f)} returns the coefficient of the lowest order term of \\spad{f}")) (|leadingMonomial| (($ $) "\\spad{leadingMonomial(f)} returns the monomial of \\spad{f} of lowest order.")) (|monomial| (($ $ (|List| |#3|) (|List| |#2|)) "\\spad{monomial(a,[x1,..,xk],[n1,..,nk])} computes \\spad{a * x1**n1 * .. * xk**nk}.") (($ $ |#3| |#2|) "\\spad{monomial(a,x,n)} computes \\spad{a*x**n}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|))) 
 NIL 
 (|PlottableSpaceCurveCategory|) 
 ((|constructor| (NIL "PlottableSpaceCurveCategory is the category of curves in 3-space which may be plotted via the graphics facilities. Functions are provided for obtaining lists of lists of points,{} representing the branches of the curve,{} and for determining the ranges of the x-,{} y-,{} and \\spad{z}-coordinates of the points on the curve.")) (|zRange| (((|Segment| (|DoubleFloat|)) $) "\\spad{zRange(c)} returns the range of the \\spad{z}-coordinates of the points on the curve \\spad{c}.")) (|yRange| (((|Segment| (|DoubleFloat|)) $) "\\spad{yRange(c)} returns the range of the \\spad{y}-coordinates of the points on the curve \\spad{c}.")) (|xRange| (((|Segment| (|DoubleFloat|)) $) "\\spad{xRange(c)} returns the range of the \\spad{x}-coordinates of the points on the curve \\spad{c}.")) (|listBranches| (((|List| (|List| (|Point| (|DoubleFloat|)))) $) "\\spad{listBranches(c)} returns a list of lists of points,{} representing the branches of the curve \\spad{c}."))) 
@@ -3562,7 +3562,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| |#2| (QUOTE (|IntegerNumberSystem|))) (|HasCategory| |#2| (QUOTE (|EuclideanDomain|))) (|HasCategory| |#2| (QUOTE (|RetractableTo| (|Symbol|)))) (|HasCategory| |#2| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#2| (QUOTE (|RealConstant|))) (|HasCategory| |#2| (QUOTE (|OrderedIntegralDomain|))) (|HasCategory| |#2| (QUOTE (|OrderedSet|))) (|HasCategory| |#2| (QUOTE (|RetractableTo| (|Integer|)))) (|HasCategory| |#2| (QUOTE (|StepThrough|)))) 
 (|QuotientFieldCategory| S) 
 ((|constructor| (NIL "QuotientField(\\spad{S}) is the category of fractions of an Integral Domain \\spad{S}.")) (|floor| ((|#1| $) "\\spad{floor(x)} returns the largest integral element below \\spad{x}.")) (|ceiling| ((|#1| $) "\\spad{ceiling(x)} returns the smallest integral element above \\spad{x}.")) (|random| (($) "\\spad{random()} returns a random fraction.")) (|fractionPart| (($ $) "\\spad{fractionPart(x)} returns the fractional part of \\spad{x}. \\spad{x} = wholePart(\\spad{x}) + fractionPart(\\spad{x})")) (|wholePart| ((|#1| $) "\\spad{wholePart(x)} returns the whole part of the fraction \\spad{x} \\spadignore{i.e.} the truncated quotient of the numerator by the denominator.")) (|denominator| (($ $) "\\spad{denominator(x)} is the denominator of the fraction \\spad{x} converted to \\%.")) (|numerator| (($ $) "\\spad{numerator(x)} is the numerator of the fraction \\spad{x} converted to \\%.")) (|denom| ((|#1| $) "\\spad{denom(x)} returns the denominator of the fraction \\spad{x}.")) (|numer| ((|#1| $) "\\spad{numer(x)} returns the numerator of the fraction \\spad{x}.")) (/ (($ |#1| |#1|) "\\spad{d1 / d2} returns the fraction \\spad{d1} divided by \\spad{d2}."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|QuotientFieldCategoryFunctions2| A B R S) 
 ((|constructor| (NIL "This package extends a function between integral domains to a mapping between their quotient fields.")) (|map| ((|#4| (|Mapping| |#2| |#1|) |#3|) "\\spad{map(func,frac)} applies the function \\spad{func} to the numerator and denominator of \\spad{frac}."))) 
@@ -3582,15 +3582,15 @@ NIL
 NIL 
 (|Quaternion| R) 
 ((|constructor| (NIL "\\spadtype{Quaternion} implements quaternions over a \\indented{2}{commutative ring. The main constructor function is \\spadfun{quatern}} \\indented{2}{which takes 4 arguments: the real part,{} the \\spad{i} imaginary part,{} the \\spad{j}} \\indented{2}{imaginary part and the \\spad{k} imaginary part.}"))) 
-((|noZeroDivisors| |has| |#1| (|EntireRing|)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-((|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|)))) #1=(|HasCategory| |#1| (QUOTE (|Field|))) (OR #2=(|HasCategory| |#1| (QUOTE (|EntireRing|))) #1#) #2# (|HasCategory| |#1| (QUOTE (|OrderedSet|))) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #3=(|Integer|)))) (|HasCategory| |#1| (|%list| (QUOTE |InnerEvalable|) (QUOTE #4=(|Symbol|)) #5=(|devaluate| |#1|))) (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) #5#)) (|HasCategory| |#1| (|%list| (QUOTE |Eltable|) #5# #5#)) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #4#))) (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #4#))) (OR #1# #6=(|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #3#))))) #6# (|HasCategory| |#1| (QUOTE (|RetractableTo| #3#))) (|HasCategory| |#1| (QUOTE (|RealNumberSystem|))) (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|)))) 
+((|noZeroDivisors| |has| |#1| (|EntireRing|))) 
+((|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|)))) #1=(|HasCategory| |#1| (QUOTE (|Field|))) (OR #2=(|HasCategory| |#1| (QUOTE (|EntireRing|))) #1#) #2# (|HasCategory| |#1| (QUOTE (|OrderedSet|))) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #3=(|Integer|)))) (|HasCategory| |#1| (|%list| (QUOTE |InnerEvalable|) (QUOTE #4=(|Symbol|)) #5=(|devaluate| |#1|))) (|HasCategory| |#1| (|%list| (QUOTE |Evalable|) #5#)) (|HasCategory| |#1| (|%list| (QUOTE |Eltable|) #5# #5#)) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #4#))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #4#))) (OR #1# #6=(|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #3#))))) #6# (|HasCategory| |#1| (QUOTE (|RetractableTo| #3#))) (|HasCategory| |#1| (QUOTE (|RealNumberSystem|))) (|HasCategory| |#1| (QUOTE (|IntegerNumberSystem|)))) 
 (|QuaternionCategory&| S R) 
 ((|constructor| (NIL "\\spadtype{QuaternionCategory} describes the category of quaternions and implements functions that are not representation specific.")) (|rationalIfCan| (((|Union| (|Fraction| (|Integer|)) "failed") $) "\\spad{rationalIfCan(q)} returns \\spad{q} as a rational number,{} or \"failed\" if this is not possible. Note: if \\spad{rational?(q)} is \\spad{true},{} the conversion can be done and the rational number will be returned.")) (|rational| (((|Fraction| (|Integer|)) $) "\\spad{rational(q)} tries to convert \\spad{q} into a rational number. Error: if this is not possible. If \\spad{rational?(q)} is \\spad{true},{} the conversion will be done and the rational number returned.")) (|rational?| (((|Boolean|) $) "\\spad{rational?(q)} returns {\\it \\spad{true}} if all the imaginary parts of \\spad{q} are zero and the real part can be converted into a rational number,{} and {\\it \\spad{false}} otherwise.")) (|abs| ((|#2| $) "\\spad{abs(q)} computes the absolute value of quaternion \\spad{q} (sqrt of norm).")) (|real| ((|#2| $) "\\spad{real(q)} extracts the real part of quaternion \\spad{q}.")) (|quatern| (($ |#2| |#2| |#2| |#2|) "\\spad{quatern(r,i,j,k)} constructs a quaternion from scalars.")) (|norm| ((|#2| $) "\\spad{norm(q)} computes the norm of \\spad{q} (the sum of the squares of the components).")) (|imagK| ((|#2| $) "\\spad{imagK(q)} extracts the imaginary \\spad{k} part of quaternion \\spad{q}.")) (|imagJ| ((|#2| $) "\\spad{imagJ(q)} extracts the imaginary \\spad{j} part of quaternion \\spad{q}.")) (|imagI| ((|#2| $) "\\spad{imagI(q)} extracts the imaginary \\spad{i} part of quaternion \\spad{q}.")) (|conjugate| (($ $) "\\spad{conjugate(q)} negates the imaginary parts of quaternion \\spad{q}."))) 
 NIL 
 ((|HasCategory| |#2| (QUOTE (|IntegerNumberSystem|))) (|HasCategory| |#2| (QUOTE (|RealNumberSystem|))) (|HasCategory| |#2| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#2| (QUOTE (|Field|))) (|HasCategory| |#2| (QUOTE (|OrderedSet|))) (|HasCategory| |#2| (QUOTE (|EntireRing|)))) 
 (|QuaternionCategory| R) 
 ((|constructor| (NIL "\\spadtype{QuaternionCategory} describes the category of quaternions and implements functions that are not representation specific.")) (|rationalIfCan| (((|Union| (|Fraction| (|Integer|)) "failed") $) "\\spad{rationalIfCan(q)} returns \\spad{q} as a rational number,{} or \"failed\" if this is not possible. Note: if \\spad{rational?(q)} is \\spad{true},{} the conversion can be done and the rational number will be returned.")) (|rational| (((|Fraction| (|Integer|)) $) "\\spad{rational(q)} tries to convert \\spad{q} into a rational number. Error: if this is not possible. If \\spad{rational?(q)} is \\spad{true},{} the conversion will be done and the rational number returned.")) (|rational?| (((|Boolean|) $) "\\spad{rational?(q)} returns {\\it \\spad{true}} if all the imaginary parts of \\spad{q} are zero and the real part can be converted into a rational number,{} and {\\it \\spad{false}} otherwise.")) (|abs| ((|#1| $) "\\spad{abs(q)} computes the absolute value of quaternion \\spad{q} (sqrt of norm).")) (|real| ((|#1| $) "\\spad{real(q)} extracts the real part of quaternion \\spad{q}.")) (|quatern| (($ |#1| |#1| |#1| |#1|) "\\spad{quatern(r,i,j,k)} constructs a quaternion from scalars.")) (|norm| ((|#1| $) "\\spad{norm(q)} computes the norm of \\spad{q} (the sum of the squares of the components).")) (|imagK| ((|#1| $) "\\spad{imagK(q)} extracts the imaginary \\spad{k} part of quaternion \\spad{q}.")) (|imagJ| ((|#1| $) "\\spad{imagJ(q)} extracts the imaginary \\spad{j} part of quaternion \\spad{q}.")) (|imagI| ((|#1| $) "\\spad{imagI(q)} extracts the imaginary \\spad{i} part of quaternion \\spad{q}.")) (|conjugate| (($ $) "\\spad{conjugate(q)} negates the imaginary parts of quaternion \\spad{q}."))) 
-((|noZeroDivisors| |has| |#1| (|EntireRing|)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| |has| |#1| (|EntireRing|))) 
 NIL 
 (|QuaternionCategoryFunctions2| QR R QS S) 
 ((|constructor| (NIL "\\spadtype{QuaternionCategoryFunctions2} implements functions between two quaternion domains. The function \\spadfun{map} is used by the system interpreter to coerce between quaternion types.")) (|map| ((|#3| (|Mapping| |#4| |#2|) |#1|) "\\spad{map(f,u)} maps \\spad{f} onto the component parts of the quaternion \\spad{u}."))) 
@@ -3610,12 +3610,12 @@ NIL
 NIL 
 (|RadicalFunctionField| F UP UPUP |radicnd| |n|) 
 ((|constructor| (NIL "Function field defined by y**n = \\spad{f}(\\spad{x})."))) 
-((|noZeroDivisors| |has| #1=(|Fraction| |#2|) . #2=((|Field|))) (|canonicalUnitNormal| |has| #1# . #2#) (|canonicalsClosed| |has| #1# . #2#) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-((|HasCategory| #1=(|Fraction| |#2|) (QUOTE (|CharacteristicNonZero|))) (|HasCategory| #1# (QUOTE (|CharacteristicZero|))) #2=(|HasCategory| #1# (QUOTE (|FiniteFieldCategory|))) (OR #3=(|HasCategory| #1# #4=(QUOTE (|Field|))) #2#) #3# (|HasCategory| #1# #5=(QUOTE (|Finite|))) (OR #6=(AND (|HasCategory| #1# (QUOTE (|DifferentialRing|))) #3#) #2#) (OR #6# #7=(AND (|HasCategory| #1# (QUOTE (|DifferentialSpace|))) #3#) #2#) (OR #8=(AND #3# #9=(|HasCategory| #1# (QUOTE (|PartialDifferentialRing| #10=(|Symbol|))))) (AND #2# #9#)) (OR #8# #11=(AND #3# (|HasCategory| #1# (QUOTE (|PartialDifferentialSpace| #10#))))) (|HasCategory| #1# (QUOTE (|LinearlyExplicitRingOver| #12=(|Integer|)))) (OR #3# #13=(|HasCategory| #1# (QUOTE (|RetractableTo| (|Fraction| #12#))))) #13# (|HasCategory| #1# (QUOTE (|RetractableTo| #12#))) (|HasCategory| |#1| #4#) (|HasCategory| |#1| #5#) #7# #11# #6# #8#) 
+((|noZeroDivisors| |has| #1=(|Fraction| |#2|) . #2=((|Field|))) (|canonicalUnitNormal| |has| #1# . #2#) ((|commutative| "*") . T)) 
+((|HasCategory| #1=(|Fraction| |#2|) (QUOTE (|CharacteristicNonZero|))) (|HasCategory| #1# (QUOTE (|CharacteristicZero|))) #2=(|HasCategory| #1# (QUOTE (|FiniteFieldCategory|))) (OR #3=(|HasCategory| #1# #4=(QUOTE (|Field|))) #2#) #3# (|HasCategory| #1# #5=(QUOTE (|Finite|))) (OR #6=(AND (|HasCategory| #1# (QUOTE (|DifferentialRing|))) #3#) #2#) (OR #6# #7=(AND (|HasCategory| #1# (QUOTE (|DifferentialSpace|))) #3#) #2#) (OR #8=(AND #3# #9=(|HasCategory| #1# (QUOTE (|PartialDifferentialRing| #10=(|Symbol|))))) (AND #2# #9#)) (OR #8# #11=(AND #3# (|HasCategory| #1# (QUOTE (|PartialDifferentialSpace| #10#))))) (|HasCategory| #1# (QUOTE (|LinearlyExplicitRingOver| #12=(|Integer|)))) (OR #3# #13=(|HasCategory| #1# (QUOTE (|RetractableTo| (|Fraction| #12#))))) #13# (|HasCategory| #1# (QUOTE (|RetractableTo| #12#))) (|HasCategory| |#1| #4#) (|HasCategory| |#1| #5#) #11# #7# #6# #8#) 
 (|RadixExpansion| |bb|) 
 ((|constructor| (NIL "This domain allows rational numbers to be presented as repeating decimal expansions or more generally as repeating expansions in any base.")) (|fractRadix| (($ (|List| (|Integer|)) (|List| (|Integer|))) "\\spad{fractRadix(pre,cyc)} creates a fractional radix expansion from a list of prefix ragits and a list of cyclic ragits. For example,{} \\spad{fractRadix([1],[6])} will return \\spad{0.16666666...}.")) (|wholeRadix| (($ (|List| (|Integer|))) "\\spad{wholeRadix(l)} creates an integral radix expansion from a list of ragits. For example,{} \\spad{wholeRadix([1,3,4])} will return \\spad{134}.")) (|cycleRagits| (((|List| (|Integer|)) $) "\\spad{cycleRagits(rx)} returns the cyclic part of the ragits of the fractional part of a radix expansion. For example,{} if \\spad{x = 3/28 = 0.10 714285 714285 ...},{} then \\spad{cycleRagits(x) = [7,1,4,2,8,5]}.")) (|prefixRagits| (((|List| (|Integer|)) $) "\\spad{prefixRagits(rx)} returns the non-cyclic part of the ragits of the fractional part of a radix expansion. For example,{} if \\spad{x = 3/28 = 0.10 714285 714285 ...},{} then \\spad{prefixRagits(x)=[1,0]}.")) (|fractRagits| (((|Stream| (|Integer|)) $) "\\spad{fractRagits(rx)} returns the ragits of the fractional part of a radix expansion.")) (|wholeRagits| (((|List| (|Integer|)) $) "\\spad{wholeRagits(rx)} returns the ragits of the integer part of a radix expansion.")) (|fractionPart| (((|Fraction| (|Integer|)) $) "\\spad{fractionPart(rx)} returns the fractional part of a radix expansion."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| #2=(|Integer|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #2#))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #2#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #2#)))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (QUOTE (|InnerEvalable| #3# #2#))) (|HasCategory| #2# (QUOTE (|Evalable| #2#))) (|HasCategory| #2# (QUOTE (|Eltable| #2# #2#))) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #2#))) #9=(AND (|HasCategory| $ #5#) #1#) (OR #9# #4#)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
+(#1=(|HasCategory| #2=(|Integer|) (QUOTE (|PolynomialFactorizationExplicit|))) (|HasCategory| #2# (QUOTE (|RetractableTo| #3=(|Symbol|)))) #4=(|HasCategory| #2# #5=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #2# (QUOTE (|RealConstant|))) #6=(|HasCategory| #2# (QUOTE (|OrderedIntegralDomain|))) #7=(|HasCategory| #2# (QUOTE (|OrderedSet|))) (OR #6# #7#) (|HasCategory| #2# (QUOTE (|RetractableTo| #2#))) (|HasCategory| #2# (QUOTE (|StepThrough|))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #8=(|Float|)))) (|HasCategory| #2# (QUOTE (|PatternMatchable| #2#))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #2# (QUOTE (|ConvertibleTo| (|Pattern| #2#)))) (|HasCategory| #2# (QUOTE (|PartialDifferentialSpace| #3#))) (|HasCategory| #2# (QUOTE (|DifferentialSpace|))) (|HasCategory| #2# (QUOTE (|DifferentialRing|))) (|HasCategory| #2# (QUOTE (|PartialDifferentialRing| #3#))) (|HasCategory| #2# (QUOTE (|InnerEvalable| #3# #2#))) (|HasCategory| #2# (QUOTE (|Evalable| #2#))) (|HasCategory| #2# (QUOTE (|Eltable| #2# #2#))) (|HasCategory| #2# (QUOTE (|EuclideanDomain|))) (|HasCategory| #2# (QUOTE (|IntegerNumberSystem|))) (|HasCategory| #2# (QUOTE (|LinearlyExplicitRingOver| #2#))) #9=(AND (|HasCategory| $ #5#) #1#) (OR #9# #4#)) 
 (|RadixUtilities|) 
 ((|constructor| (NIL "This package provides tools for creating radix expansions.")) (|radix| (((|Any|) (|Fraction| (|Integer|)) (|Integer|)) "\\spad{radix(x,b)} converts \\spad{x} to a radix expansion in base \\spad{b}."))) 
 NIL 
@@ -3646,7 +3646,7 @@ NIL
 NIL 
 (|RealClosedField|) 
 ((|constructor| (NIL "\\axiomType{RealClosedField} provides common acces functions for all real closed fields.")) (|approximate| (((|Fraction| (|Integer|)) $ $) "\\axiom{approximate(\\spad{n},{}\\spad{p})} gives an approximation of \\axiom{\\spad{n}} that has precision \\axiom{\\spad{p}}")) (|rename| (($ $ (|OutputForm|)) "\\axiom{rename(\\spad{x},{}name)} gives a new number that prints as name")) (|rename!| (($ $ (|OutputForm|)) "\\axiom{rename!(\\spad{x},{}name)} changes the way \\axiom{\\spad{x}} is printed")) (|sqrt| (($ (|Integer|)) "\\axiom{sqrt(\\spad{x})} is \\axiom{\\spad{x} ** (1/2)}") (($ (|Fraction| (|Integer|))) "\\axiom{sqrt(\\spad{x})} is \\axiom{\\spad{x} ** (1/2)}") (($ $) "\\axiom{sqrt(\\spad{x})} is \\axiom{\\spad{x} ** (1/2)}") (($ $ (|PositiveInteger|)) "\\axiom{sqrt(\\spad{x},{}\\spad{n})} is \\axiom{\\spad{x} ** (1/n)}")) (|allRootsOf| (((|List| $) (|Polynomial| (|Integer|))) "\\axiom{allRootsOf(pol)} creates all the roots of \\axiom{pol} naming each uniquely") (((|List| $) (|Polynomial| (|Fraction| (|Integer|)))) "\\axiom{allRootsOf(pol)} creates all the roots of \\axiom{pol} naming each uniquely") (((|List| $) (|Polynomial| $)) "\\axiom{allRootsOf(pol)} creates all the roots of \\axiom{pol} naming each uniquely") (((|List| $) (|SparseUnivariatePolynomial| (|Integer|))) "\\axiom{allRootsOf(pol)} creates all the roots of \\axiom{pol} naming each uniquely") (((|List| $) (|SparseUnivariatePolynomial| (|Fraction| (|Integer|)))) "\\axiom{allRootsOf(pol)} creates all the roots of \\axiom{pol} naming each uniquely") (((|List| $) (|SparseUnivariatePolynomial| $)) "\\axiom{allRootsOf(pol)} creates all the roots of \\axiom{pol} naming each uniquely")) (|rootOf| (((|Union| $ "failed") (|SparseUnivariatePolynomial| $) (|PositiveInteger|)) "\\axiom{rootOf(pol,{}\\spad{n})} creates the \\spad{n}th root for the order of \\axiom{pol} and gives it unique name") (((|Union| $ "failed") (|SparseUnivariatePolynomial| $) (|PositiveInteger|) (|OutputForm|)) "\\axiom{rootOf(pol,{}\\spad{n},{}name)} creates the \\spad{n}th root for the order of \\axiom{pol} and names it \\axiom{name}")) (|mainValue| (((|Union| (|SparseUnivariatePolynomial| $) "failed") $) "\\axiom{mainValue(\\spad{x})} is the expression of \\axiom{\\spad{x}} in terms of \\axiom{SparseUnivariatePolynomial(\\$)}")) (|mainDefiningPolynomial| (((|Union| (|SparseUnivariatePolynomial| $) "failed") $) "\\axiom{mainDefiningPolynomial(\\spad{x})} is the defining polynomial for the main algebraic quantity of \\axiom{\\spad{x}}")) (|mainForm| (((|Union| (|OutputForm|) "failed") $) "\\axiom{mainForm(\\spad{x})} is the main algebraic quantity name of \\axiom{\\spad{x}}"))) 
-((|noZeroDivisors| . T) (|canonicalUnitNormal| . T) (|canonicalsClosed| . T) (|leftUnitary| . T) (|rightUnitary| . T) ((|commutative| "*") . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T) (|canonicalUnitNormal| . T) ((|commutative| "*") . T)) 
 NIL 
 (|ElementaryRischDE| R F) 
 ((|constructor| (NIL "\\indented{1}{Risch differential equation,{} elementary case.} Author: Manuel Bronstein Date Created: 1 February 1988 Date Last Updated: 2 November 1995 Keywords: elementary,{} function,{} integration.")) (|rischDE| (((|Record| (|:| |ans| |#2|) (|:| |right| |#2|) (|:| |sol?| (|Boolean|))) (|Integer|) |#2| |#2| (|Symbol|) (|Mapping| (|Union| (|Record| (|:| |mainpart| |#2|) (|:| |limitedlogs| (|List| (|Record| (|:| |coeff| |#2|) (|:| |logand| |#2|))))) "failed") |#2| (|List| |#2|)) (|Mapping| (|Union| (|Record| (|:| |ratpart| |#2|) (|:| |coeff| |#2|)) "failed") |#2| |#2|)) "\\spad{rischDE(n, f, g, x, lim, ext)} returns \\spad{[y, h, b]} such that \\spad{dy/dx + n df/dx y = h} and \\spad{b := h = g}. The equation \\spad{dy/dx + n df/dx y = g} has no solution if \\spad{h \\~~= g} (\\spad{y} is a partial solution in that case). Notes: \\spad{lim} is a limited integration function,{} and ext is an extended integration function."))) 
@@ -3694,7 +3694,7 @@ NIL
 NIL 
 (|RealClosure| |TheField|) 
 ((|constructor| (NIL "This domain implements the real closure of an ordered field.")) (|relativeApprox| (((|Fraction| (|Integer|)) $ $) "\\axiom{relativeApprox(\\spad{n},{}\\spad{p})} gives a relative approximation of \\axiom{\\spad{n}} that has precision \\axiom{\\spad{p}}")) (|mainCharacterization| (((|Union| (|RightOpenIntervalRootCharacterization| $ (|SparseUnivariatePolynomial| $)) "failed") $) "\\axiom{mainCharacterization(\\spad{x})} is the main algebraic quantity of \\axiom{\\spad{x}} (\\axiom{SEG})")) (|algebraicOf| (($ (|RightOpenIntervalRootCharacterization| $ (|SparseUnivariatePolynomial| $)) (|OutputForm|)) "\\axiom{algebraicOf(char)} is the external number"))) 
-((|noZeroDivisors| . T) (|canonicalUnitNormal| . T) (|canonicalsClosed| . T) (|leftUnitary| . T) (|rightUnitary| . T) ((|commutative| "*") . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T) (|canonicalUnitNormal| . T) ((|commutative| "*") . T)) 
 ((OR #1=(|HasCategory| |#1| #2=(QUOTE (|RetractableTo| #3=(|Integer|)))) #4=(|HasCategory| #5=(|Fraction| #3#) #2#)) (|HasCategory| |#1| #6=(QUOTE (|RetractableTo| #5#))) #1# (|HasCategory| #5# #6#) #4#) 
 (|ReductionOfOrder| F L) 
 ((|constructor| (NIL "\\spadtype{ReductionOfOrder} provides functions for reducing the order of linear ordinary differential equations once some solutions are known.")) (|ReduceOrder| (((|Record| (|:| |eq| |#2|) (|:| |op| (|List| |#1|))) |#2| (|List| |#1|)) "\\spad{ReduceOrder(op, [f1,...,fk])} returns \\spad{[op1,[g1,...,gk]]} such that for any solution \\spad{z} of \\spad{op1 z = 0},{} \\spad{y = gk \\int(g_{k-1} \\int(... \\int(g1 \\int z)...)} is a solution of \\spad{op y = 0}. Each \\spad{fi} must satisfy \\spad{op fi = 0}.") ((|#2| |#2| |#1|) "\\spad{ReduceOrder(op, s)} returns \\spad{op1} such that for any solution \\spad{z} of \\spad{op1 z = 0},{} \\spad{y = s \\int z} is a solution of \\spad{op y = 0}. \\spad{s} must satisfy \\spad{op s = 0}."))) 
@@ -3734,7 +3734,7 @@ NIL
 NIL 
 (|ResidueRing| F |Expon| |VarSet| |FPol| |LFPol|) 
 ((|constructor| (NIL "ResidueRing is the quotient of a polynomial ring by an ideal. The ideal is given as a list of generators. The elements of the domain are equivalence classes expressed in terms of reduced elements")) (|lift| ((|#4| $) "\\spad{lift(x)} return the canonical representative of the equivalence class \\spad{x}")) (|coerce| (($ |#4|) "\\spad{coerce(f)} produces the equivalence class of \\spad{f} in the residue ring")) (|reduce| (($ |#4|) "\\spad{reduce(f)} produces the equivalence class of \\spad{f} in the residue ring"))) 
-(((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") . T)) 
 NIL 
 (|ReturnAst|) 
 ((|constructor| (NIL "This domain represents `return' expressions.")) (|expression| (((|SpadAst|) $) "\\spad{expression(e)} returns the expression returned by `e'."))) 
@@ -3785,12 +3785,12 @@ NIL
 NIL 
 NIL 
 (|Ring&| S) 
-((|constructor| (NIL "The category of rings with unity,{} always associative,{} but not necessarily commutative.")) (|unitsKnown| ((|attribute|) "recip truly yields reciprocal or \"failed\" if not a unit. Note: \\spad{recip(0) = \"failed\"}.")) (|characteristic| (((|NonNegativeInteger|)) "\\spad{characteristic()} returns the characteristic of the ring this is the smallest positive integer \\spad{n} such that \\spad{n*x=0} for all \\spad{x} in the ring,{} or zero if no such \\spad{n} exists."))) 
+((|constructor| (NIL "The category of rings with unity,{} always associative,{} but not necessarily commutative.")) (|characteristic| (((|NonNegativeInteger|)) "\\spad{characteristic()} returns the characteristic of the ring this is the smallest positive integer \\spad{n} such that \\spad{n*x=0} for all \\spad{x} in the ring,{} or zero if no such \\spad{n} exists."))) 
 NIL 
 NIL 
 (|Ring|) 
-((|constructor| (NIL "The category of rings with unity,{} always associative,{} but not necessarily commutative.")) (|unitsKnown| ((|attribute|) "recip truly yields reciprocal or \"failed\" if not a unit. Note: \\spad{recip(0) = \"failed\"}.")) (|characteristic| (((|NonNegativeInteger|)) "\\spad{characteristic()} returns the characteristic of the ring this is the smallest positive integer \\spad{n} such that \\spad{n*x=0} for all \\spad{x} in the ring,{} or zero if no such \\spad{n} exists."))) 
-((|unitsKnown| . T)) 
+((|constructor| (NIL "The category of rings with unity,{} always associative,{} but not necessarily commutative.")) (|characteristic| (((|NonNegativeInteger|)) "\\spad{characteristic()} returns the characteristic of the ring this is the smallest positive integer \\spad{n} such that \\spad{n*x=0} for all \\spad{x} in the ring,{} or zero if no such \\spad{n} exists."))) 
+NIL 
 NIL 
 (|RationalInterpolation| |xx| F) 
 ((|constructor| (NIL "This package exports rational interpolation algorithms"))) 
@@ -3806,12 +3806,12 @@ NIL
 ((|HasCategory| |#4| (QUOTE (|EuclideanDomain|))) (|HasCategory| |#4| (QUOTE (|Field|))) (|HasCategory| |#4| (QUOTE (|IntegralDomain|))) (|HasCategory| |#4| (QUOTE (|CommutativeRing|)))) 
 (|RectangularMatrixCategory| |m| |n| R |Row| |Col|) 
 ((|constructor| (NIL "\\spadtype{RectangularMatrixCategory} is a category of matrices of fixed dimensions. The dimensions of the matrix will be parameters of the domain. Domains in this category will be \\spad{R}-modules and will be non-mutable.")) (|nullSpace| (((|List| |#5|) $) "\\spad{nullSpace(m)}+ returns a basis for the null space of the matrix \\spad{m}.")) (|nullity| (((|NonNegativeInteger|) $) "\\spad{nullity(m)} returns the nullity of the matrix \\spad{m}. This is the dimension of the null space of the matrix \\spad{m}.")) (|rank| (((|NonNegativeInteger|) $) "\\spad{rank(m)} returns the rank of the matrix \\spad{m}.")) (|rowEchelon| (($ $) "\\spad{rowEchelon(m)} returns the row echelon form of the matrix \\spad{m}.")) (/ (($ $ |#3|) "\\spad{m/r} divides the elements of \\spad{m} by \\spad{r}. Error: if \\spad{r = 0}.")) (|exquo| (((|Union| $ "failed") $ |#3|) "\\spad{exquo(m,r)} computes the exact quotient of the elements of \\spad{m} by \\spad{r},{} returning \\axiom{\"failed\"} if this is not possible.")) (|map| (($ (|Mapping| |#3| |#3| |#3|) $ $) "\\spad{map(f,a,b)} returns \\spad{c},{} where \\spad{c} is such that \\spad{c(i,j) = f(a(i,j),b(i,j))} for all \\spad{i},{} \\spad{j}.")) (|column| ((|#5| $ (|Integer|)) "\\spad{column(m,j)} returns the \\spad{j}th column of the matrix \\spad{m}. Error: if the index outside the proper range.")) (|row| ((|#4| $ (|Integer|)) "\\spad{row(m,i)} returns the \\spad{i}th row of the matrix \\spad{m}. Error: if the index is outside the proper range.")) (|qelt| ((|#3| $ (|Integer|) (|Integer|)) "\\spad{qelt(m,i,j)} returns the element in the \\spad{i}th row and \\spad{j}th column of the matrix \\spad{m}. Note: there is NO error check to determine if indices are in the proper ranges.")) (|elt| ((|#3| $ (|Integer|) (|Integer|) |#3|) "\\spad{elt(m,i,j,r)} returns the element in the \\spad{i}th row and \\spad{j}th column of the matrix \\spad{m},{} if \\spad{m} has an \\spad{i}th row and a \\spad{j}th column,{} and returns \\spad{r} otherwise.") ((|#3| $ (|Integer|) (|Integer|)) "\\spad{elt(m,i,j)} returns the element in the \\spad{i}th row and \\spad{j}th column of the matrix \\spad{m}. Error: if indices are outside the proper ranges.")) (|listOfLists| (((|List| (|List| |#3|)) $) "\\spad{listOfLists(m)} returns the rows of the matrix \\spad{m} as a list of lists.")) (|ncols| (((|NonNegativeInteger|) $) "\\spad{ncols(m)} returns the number of columns in the matrix \\spad{m}.")) (|nrows| (((|NonNegativeInteger|) $) "\\spad{nrows(m)} returns the number of rows in the matrix \\spad{m}.")) (|maxColIndex| (((|Integer|) $) "\\spad{maxColIndex(m)} returns the index of the 'last' column of the matrix \\spad{m}.")) (|minColIndex| (((|Integer|) $) "\\spad{minColIndex(m)} returns the index of the 'first' column of the matrix \\spad{m}.")) (|maxRowIndex| (((|Integer|) $) "\\spad{maxRowIndex(m)} returns the index of the 'last' row of the matrix \\spad{m}.")) (|minRowIndex| (((|Integer|) $) "\\spad{minRowIndex(m)} returns the index of the 'first' row of the matrix \\spad{m}.")) (|antisymmetric?| (((|Boolean|) $) "\\spad{antisymmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and antisymmetric (\\spadignore{i.e.} \\spad{m[i,j] = -m[j,i]} for all \\spad{i} and \\spad{j}) and \\spad{false} otherwise.")) (|symmetric?| (((|Boolean|) $) "\\spad{symmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and symmetric (\\spadignore{i.e.} \\spad{m[i,j] = m[j,i]} for all \\spad{i} and \\spad{j}) and \\spad{false} otherwise.")) (|diagonal?| (((|Boolean|) $) "\\spad{diagonal?(m)} returns \\spad{true} if the matrix \\spad{m} is square and diagonal (\\spadignore{i.e.} all entries of \\spad{m} not on the diagonal are zero) and \\spad{false} otherwise.")) (|square?| (((|Boolean|) $) "\\spad{square?(m)} returns \\spad{true} if \\spad{m} is a square matrix (\\spadignore{i.e.} if \\spad{m} has the same number of rows as columns) and \\spad{false} otherwise.")) (|matrix| (($ (|List| (|List| |#3|))) "\\spad{matrix(l)} converts the list of lists \\spad{l} to a matrix,{} where the list of lists is viewed as a list of the rows of the matrix."))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 NIL 
 (|RectangularMatrix| |m| |n| R) 
 ((|constructor| (NIL "\\spadtype{RectangularMatrix} is a matrix domain where the number of rows and the number of columns are parameters of the domain.")) (|rectangularMatrix| (($ (|Matrix| |#3|)) "\\spad{rectangularMatrix(m)} converts a matrix of type \\spadtype{Matrix} to a matrix of type \\spad{RectangularMatrix}."))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
-(#1=(|HasCategory| |#3| (QUOTE (|CommutativeRing|))) (OR (AND #1# #2=(|HasCategory| |#3| (|%list| (QUOTE |Evalable|) (|devaluate| |#3|)))) (AND #3=(|HasCategory| |#3| (QUOTE (|Field|))) #2#) #4=(AND #5=(|HasCategory| |#3| (QUOTE (|SetCategory|))) #2#)) (|HasCategory| |#3| (QUOTE (|ConvertibleTo| (|InputForm|)))) (OR #1# #3#) #3# (|HasCategory| |#3| (QUOTE (|EuclideanDomain|))) (|HasCategory| |#3| (QUOTE (|IntegralDomain|))) #4# #5# (|HasCategory| |#3| (QUOTE (|BasicType|))) (|HasCategory| |#3| (QUOTE (|CoercibleTo| (|OutputForm|))))) 
+NIL 
+(#1=(|HasCategory| |#3| (QUOTE (|CommutativeRing|))) (OR (AND #1# #2=(|HasCategory| |#3| (|%list| (QUOTE |Evalable|) (|devaluate| |#3|)))) (AND #3=(|HasCategory| |#3| (QUOTE (|Field|))) #2#) #4=(AND #5=(|HasCategory| |#3| (QUOTE (|SetCategory|))) #2#)) (|HasCategory| |#3| (QUOTE (|ConvertibleTo| (|InputForm|)))) (OR #1# #3#) #3# (|HasCategory| |#3| (QUOTE (|EuclideanDomain|))) (|HasCategory| |#3| (QUOTE (|IntegralDomain|))) (|HasCategory| |#3| (QUOTE (|CoercibleTo| (|OutputForm|)))) (|HasCategory| |#3| (QUOTE (|BasicType|))) #5# #4#) 
 (|RectangularMatrixCategoryFunctions2| |m| |n| R1 |Row1| |Col1| M1 R2 |Row2| |Col2| M2) 
 ((|constructor| (NIL "\\spadtype{RectangularMatrixCategoryFunctions2} provides functions between two matrix domains. The functions provided are \\spadfun{map} and \\spadfun{reduce}.")) (|reduce| ((|#7| (|Mapping| |#7| |#3| |#7|) |#6| |#7|) "\\spad{reduce(f,m,r)} returns a matrix \\spad{n} where \\spad{n[i,j] = f(m[i,j],r)} for all indices spad{\\spad{i}} and \\spad{j}.")) (|map| ((|#10| (|Mapping| |#7| |#3|) |#6|) "\\spad{map(f,m)} applies the function \\spad{f} to the elements of the matrix \\spad{m}."))) 
 NIL 
@@ -3838,15 +3838,15 @@ NIL
 NIL 
 (|RealNumberSystem|) 
 ((|constructor| (NIL "The real number system category is intended as a model for the real numbers. The real numbers form an ordered normed field. Note that we have purposely not included \\spadtype{DifferentialRing} or the elementary functions (see \\spadtype{TranscendentalFunctionCategory}) in the definition.")) (|round| (($ $) "\\spad{round x} computes the integer closest to \\spad{x}.")) (|truncate| (($ $) "\\spad{truncate x} returns the integer between \\spad{x} and 0 closest to \\spad{x}.")) (|fractionPart| (($ $) "\\spad{fractionPart x} returns the fractional part of \\spad{x}.")) (|wholePart| (((|Integer|) $) "\\spad{wholePart x} returns the integer part of \\spad{x}.")) (|floor| (($ $) "\\spad{floor x} returns the largest integer \\spad{<= x}.")) (|ceiling| (($ $) "\\spad{ceiling x} returns the small integer \\spad{>= x}.")) (|norm| (($ $) "\\spad{norm x} returns the same as absolute value."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|RightOpenIntervalRootCharacterization| |TheField| |ThePolDom|) 
 ((|constructor| (NIL "\\axiomType{RightOpenIntervalRootCharacterization} provides work with interval root coding.")) (|relativeApprox| ((|#1| |#2| $ |#1|) "\\axiom{relativeApprox(exp,{}\\spad{c},{}\\spad{p}) = a} is relatively close to exp as a polynomial in \\spad{c} ip to precision \\spad{p}")) (|mightHaveRoots| (((|Boolean|) |#2| $) "\\axiom{mightHaveRoots(\\spad{p},{}\\spad{r})} is \\spad{false} if \\axiom{\\spad{p}.\\spad{r}} is not 0")) (|refine| (($ $) "\\axiom{refine(rootChar)} shrinks isolating interval around \\axiom{rootChar}")) (|middle| ((|#1| $) "\\axiom{middle(rootChar)} is the middle of the isolating interval")) (|size| ((|#1| $) "The size of the isolating interval")) (|right| ((|#1| $) "\\axiom{right(rootChar)} is the right bound of the isolating interval")) (|left| ((|#1| $) "\\axiom{left(rootChar)} is the left bound of the isolating interval"))) 
 NIL 
 NIL 
 (|RomanNumeral|) 
-((|constructor| (NIL "\\spadtype{RomanNumeral} provides functions for converting \\indented{1}{integers to roman numerals.}")) (|roman| (($ (|Integer|)) "\\spad{roman(n)} creates a roman numeral for \\spad{n}.") (($ (|Symbol|)) "\\spad{roman(n)} creates a roman numeral for symbol \\spad{n}.")) (|noetherian| ((|attribute|) "ascending chain condition on ideals.")) (|canonicalsClosed| ((|attribute|) "two positives multiply to give positive.")) (|canonical| ((|attribute|) "mathematical equality is data structure equality."))) 
-((|noetherian| . T) (|canonicalsClosed| . T) (|canonical| . T) (|canonicalUnitNormal| . T) (|multiplicativeValuation| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|constructor| (NIL "\\spadtype{RomanNumeral} provides functions for converting \\indented{1}{integers to roman numerals.}")) (|roman| (($ (|Integer|)) "\\spad{roman(n)} creates a roman numeral for \\spad{n}.") (($ (|Symbol|)) "\\spad{roman(n)} creates a roman numeral for symbol \\spad{n}.")) (|canonical| ((|attribute|) "mathematical equality is data structure equality."))) 
+((|canonical| . T) (|canonicalUnitNormal| . T) (|multiplicativeValuation| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|RecursivePolynomialCategory&| S R E V) 
 ((|constructor| (NIL "A category for general multi-variate polynomials with coefficients in a ring,{} variables in an ordered set,{} and exponents from an ordered abelian monoid,{} with a \\axiomOp{sup} operation. When not constant,{} such a polynomial is viewed as a univariate polynomial in its main variable \\spad{w}. \\spad{r}. \\spad{t}. to the total ordering on the elements in the ordered set,{} so that some operations usually defined for univariate polynomials make sense here.")) (|mainSquareFreePart| (($ $) "\\axiom{mainSquareFreePart(\\spad{p})} returns the square free part of \\axiom{\\spad{p}} viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over \\axiom{\\spad{R}}.")) (|mainPrimitivePart| (($ $) "\\axiom{mainPrimitivePart(\\spad{p})} returns the primitive part of \\axiom{\\spad{p}} viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over \\axiom{\\spad{R}}.")) (|mainContent| (($ $) "\\axiom{mainContent(\\spad{p})} returns the content of \\axiom{\\spad{p}} viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over \\axiom{\\spad{R}}.")) (|primitivePart!| (($ $) "\\axiom{primitivePart!(\\spad{p})} replaces \\axiom{\\spad{p}} by its primitive part.")) (|gcd| ((|#2| |#2| $) "\\axiom{gcd(\\spad{r},{}\\spad{p})} returns the gcd of \\axiom{\\spad{r}} and the content of \\axiom{\\spad{p}}.")) (|nextsubResultant2| (($ $ $ $ $) "\\axiom{\\spad{nextsubResultant2}(\\spad{p},{}\\spad{q},{}\\spad{z},{}\\spad{s})} is the multivariate version of the operation \\axiomOpFrom{\\spad{next_sousResultant2}}{PseudoRemainderSequence} from the \\axiomType{PseudoRemainderSequence} constructor.")) (|LazardQuotient2| (($ $ $ $ (|NonNegativeInteger|)) "\\axiom{\\spad{LazardQuotient2}(\\spad{p},{}a,{}\\spad{b},{}\\spad{n})} returns \\axiom{(a**(\\spad{n}-1) * \\spad{p}) exquo b**(\\spad{n}-1)} assuming that this quotient does not fail.")) (|LazardQuotient| (($ $ $ (|NonNegativeInteger|)) "\\axiom{LazardQuotient(a,{}\\spad{b},{}\\spad{n})} returns \\axiom{a**n exquo b**(\\spad{n}-1)} assuming that this quotient does not fail.")) (|lastSubResultant| (($ $ $) "\\axiom{lastSubResultant(a,{}\\spad{b})} returns the last non-zero subresultant of \\axiom{a} and \\axiom{\\spad{b}} where \\axiom{a} and \\axiom{\\spad{b}} are assumed to have the same main variable \\axiom{\\spad{v}} and are viewed as univariate polynomials in \\axiom{\\spad{v}}.")) (|subResultantChain| (((|List| $) $ $) "\\axiom{subResultantChain(a,{}\\spad{b})},{} where \\axiom{a} and \\axiom{\\spad{b}} are not contant polynomials with the same main variable,{} returns the subresultant chain of \\axiom{a} and \\axiom{\\spad{b}}.")) (|resultant| (($ $ $) "\\axiom{resultant(a,{}\\spad{b})} computes the resultant of \\axiom{a} and \\axiom{\\spad{b}} where \\axiom{a} and \\axiom{\\spad{b}} are assumed to have the same main variable \\axiom{\\spad{v}} and are viewed as univariate polynomials in \\axiom{\\spad{v}}.")) (|halfExtendedSubResultantGcd2| (((|Record| (|:| |gcd| $) (|:| |coef2| $)) $ $) "\\axiom{\\spad{halfExtendedSubResultantGcd2}(a,{}\\spad{b})} returns \\axiom{[\\spad{g},{}cb]} if \\axiom{extendedSubResultantGcd(a,{}\\spad{b})} returns \\axiom{[\\spad{g},{}ca,{}cb]} otherwise produces an error.")) (|halfExtendedSubResultantGcd1| (((|Record| (|:| |gcd| $) (|:| |coef1| $)) $ $) "\\axiom{\\spad{halfExtendedSubResultantGcd1}(a,{}\\spad{b})} returns \\axiom{[\\spad{g},{}ca]} if \\axiom{extendedSubResultantGcd(a,{}\\spad{b})} returns \\axiom{[\\spad{g},{}ca,{}cb]} otherwise produces an error.")) (|extendedSubResultantGcd| (((|Record| (|:| |gcd| $) (|:| |coef1| $) (|:| |coef2| $)) $ $) "\\axiom{extendedSubResultantGcd(a,{}\\spad{b})} returns \\axiom{[ca,{}cb,{}\\spad{r}]} such that \\axiom{\\spad{r}} is \\axiom{subResultantGcd(a,{}\\spad{b})} and we have \\axiom{ca * a + cb * cb = \\spad{r}} .")) (|subResultantGcd| (($ $ $) "\\axiom{subResultantGcd(a,{}\\spad{b})} computes a gcd of \\axiom{a} and \\axiom{\\spad{b}} where \\axiom{a} and \\axiom{\\spad{b}} are assumed to have the same main variable \\axiom{\\spad{v}} and are viewed as univariate polynomials in \\axiom{\\spad{v}} with coefficients in the fraction field of the polynomial ring generated by their other variables over \\axiom{\\spad{R}}.")) (|exactQuotient!| (($ $ $) "\\axiom{exactQuotient!(a,{}\\spad{b})} replaces \\axiom{a} by \\axiom{exactQuotient(a,{}\\spad{b})}") (($ $ |#2|) "\\axiom{exactQuotient!(\\spad{p},{}\\spad{r})} replaces \\axiom{\\spad{p}} by \\axiom{exactQuotient(\\spad{p},{}\\spad{r})}.")) (|exactQuotient| (($ $ $) "\\axiom{exactQuotient(a,{}\\spad{b})} computes the exact quotient of \\axiom{a} by \\axiom{\\spad{b}},{} which is assumed to be a divisor of \\axiom{a}. No error is returned if this exact quotient fails!") (($ $ |#2|) "\\axiom{exactQuotient(\\spad{p},{}\\spad{r})} computes the exact quotient of \\axiom{\\spad{p}} by \\axiom{\\spad{r}},{} which is assumed to be a divisor of \\axiom{\\spad{p}}. No error is returned if this exact quotient fails!")) (|primPartElseUnitCanonical!| (($ $) "\\axiom{primPartElseUnitCanonical!(\\spad{p})} replaces \\axiom{\\spad{p}} by \\axiom{primPartElseUnitCanonical(\\spad{p})}.")) (|primPartElseUnitCanonical| (($ $) "\\axiom{primPartElseUnitCanonical(\\spad{p})} returns \\axiom{primitivePart(\\spad{p})} if \\axiom{\\spad{R}} is a gcd-domain,{} otherwise \\axiom{unitCanonical(\\spad{p})}.")) (|convert| (($ (|Polynomial| |#2|)) "\\axiom{convert(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}},{} otherwise an error is produced.") (($ (|Polynomial| (|Integer|))) "\\axiom{convert(\\spad{p})} returns the same as \\axiom{retract(\\spad{p})}.") (($ (|Polynomial| (|Integer|))) "\\axiom{convert(\\spad{p})} returns the same as \\axiom{retract(\\spad{p})}") (($ (|Polynomial| (|Fraction| (|Integer|)))) "\\axiom{convert(\\spad{p})} returns the same as \\axiom{retract(\\spad{p})}.")) (|retract| (($ (|Polynomial| |#2|)) "\\axiom{retract(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if \\axiom{retractIfCan(\\spad{p})} does not return \"failed\",{} otherwise an error is produced.") (($ (|Polynomial| |#2|)) "\\axiom{retract(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if \\axiom{retractIfCan(\\spad{p})} does not return \"failed\",{} otherwise an error is produced.") (($ (|Polynomial| (|Integer|))) "\\axiom{retract(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if \\axiom{retractIfCan(\\spad{p})} does not return \"failed\",{} otherwise an error is produced.") (($ (|Polynomial| |#2|)) "\\axiom{retract(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if \\axiom{retractIfCan(\\spad{p})} does not return \"failed\",{} otherwise an error is produced.") (($ (|Polynomial| (|Integer|))) "\\axiom{retract(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if \\axiom{retractIfCan(\\spad{p})} does not return \"failed\",{} otherwise an error is produced.") (($ (|Polynomial| (|Fraction| (|Integer|)))) "\\axiom{retract(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if \\axiom{retractIfCan(\\spad{p})} does not return \"failed\",{} otherwise an error is produced.")) (|retractIfCan| (((|Union| $ "failed") (|Polynomial| |#2|)) "\\axiom{retractIfCan(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}}.") (((|Union| $ "failed") (|Polynomial| |#2|)) "\\axiom{retractIfCan(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}}.") (((|Union| $ "failed") (|Polynomial| (|Integer|))) "\\axiom{retractIfCan(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}}.") (((|Union| $ "failed") (|Polynomial| |#2|)) "\\axiom{retractIfCan(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}}.") (((|Union| $ "failed") (|Polynomial| (|Integer|))) "\\axiom{retractIfCan(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}}.") (((|Union| $ "failed") (|Polynomial| (|Fraction| (|Integer|)))) "\\axiom{retractIfCan(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}}.")) (|initiallyReduce| (($ $ $) "\\axiom{initiallyReduce(a,{}\\spad{b})} returns a polynomial \\axiom{\\spad{r}} such that \\axiom{initiallyReduced?(\\spad{r},{}\\spad{b})} holds and there exists an integer \\axiom{\\spad{e}} such that \\axiom{init(\\spad{b})^e a - \\spad{r}} is zero modulo \\axiom{\\spad{b}}.")) (|headReduce| (($ $ $) "\\axiom{headReduce(a,{}\\spad{b})} returns a polynomial \\axiom{\\spad{r}} such that \\axiom{headReduced?(\\spad{r},{}\\spad{b})} holds and there exists an integer \\axiom{\\spad{e}} such that \\axiom{init(\\spad{b})^e a - \\spad{r}} is zero modulo \\axiom{\\spad{b}}.")) (|lazyResidueClass| (((|Record| (|:| |polnum| $) (|:| |polden| $) (|:| |power| (|NonNegativeInteger|))) $ $) "\\axiom{lazyResidueClass(a,{}\\spad{b})} returns \\axiom{[\\spad{p},{}\\spad{q},{}\\spad{n}]} where \\axiom{\\spad{p} / q**n} represents the residue class of \\axiom{a} modulo \\axiom{\\spad{b}} and \\axiom{\\spad{p}} is reduced \\spad{w}.\\spad{r}.\\spad{t}. \\axiom{\\spad{b}} and \\axiom{\\spad{q}} is \\axiom{init(\\spad{b})}.")) (|monicModulo| (($ $ $) "\\axiom{monicModulo(a,{}\\spad{b})} computes \\axiom{a mod \\spad{b}},{} if \\axiom{\\spad{b}} is monic as univariate polynomial in its main variable.")) (|pseudoDivide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\axiom{pseudoDivide(a,{}\\spad{b})} computes \\axiom{[pquo(a,{}\\spad{b}),{}prem(a,{}\\spad{b})]},{} both polynomials viewed as univariate polynomials in the main variable of \\axiom{\\spad{b}},{} if \\axiom{\\spad{b}} is not a constant polynomial.")) (|lazyPseudoDivide| (((|Record| (|:| |coef| $) (|:| |gap| (|NonNegativeInteger|)) (|:| |quotient| $) (|:| |remainder| $)) $ $ |#4|) "\\axiom{lazyPseudoDivide(a,{}\\spad{b},{}\\spad{v})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{q},{}\\spad{r}]} such that \\axiom{\\spad{r} = lazyPrem(a,{}\\spad{b},{}\\spad{v})},{} \\axiom{(c**g)*r = prem(a,{}\\spad{b},{}\\spad{v})} and \\axiom{\\spad{q}} is the pseudo-quotient computed in this lazy pseudo-division.") (((|Record| (|:| |coef| $) (|:| |gap| (|NonNegativeInteger|)) (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\axiom{lazyPseudoDivide(a,{}\\spad{b})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{q},{}\\spad{r}]} such that \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{r}] = lazyPremWithDefault(a,{}\\spad{b})} and \\axiom{\\spad{q}} is the pseudo-quotient computed in this lazy pseudo-division.")) (|lazyPremWithDefault| (((|Record| (|:| |coef| $) (|:| |gap| (|NonNegativeInteger|)) (|:| |remainder| $)) $ $ |#4|) "\\axiom{lazyPremWithDefault(a,{}\\spad{b},{}\\spad{v})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{r}]} such that \\axiom{\\spad{r} = lazyPrem(a,{}\\spad{b},{}\\spad{v})} and \\axiom{(c**g)*r = prem(a,{}\\spad{b},{}\\spad{v})}.") (((|Record| (|:| |coef| $) (|:| |gap| (|NonNegativeInteger|)) (|:| |remainder| $)) $ $) "\\axiom{lazyPremWithDefault(a,{}\\spad{b})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{r}]} such that \\axiom{\\spad{r} = lazyPrem(a,{}\\spad{b})} and \\axiom{(c**g)*r = prem(a,{}\\spad{b})}.")) (|lazyPquo| (($ $ $ |#4|) "\\axiom{lazyPquo(a,{}\\spad{b},{}\\spad{v})} returns the polynomial \\axiom{\\spad{q}} such that \\axiom{lazyPseudoDivide(a,{}\\spad{b},{}\\spad{v})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{q},{}\\spad{r}]}.") (($ $ $) "\\axiom{lazyPquo(a,{}\\spad{b})} returns the polynomial \\axiom{\\spad{q}} such that \\axiom{lazyPseudoDivide(a,{}\\spad{b})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{q},{}\\spad{r}]}.")) (|lazyPrem| (($ $ $ |#4|) "\\axiom{lazyPrem(a,{}\\spad{b},{}\\spad{v})} returns the polynomial \\axiom{\\spad{r}} reduced \\spad{w}.\\spad{r}.\\spad{t}. \\axiom{\\spad{b}} viewed as univariate polynomials in the variable \\axiom{\\spad{v}} such that \\axiom{\\spad{b}} divides \\axiom{init(\\spad{b})^e a - \\spad{r}} where \\axiom{\\spad{e}} is the number of steps of this pseudo-division.") (($ $ $) "\\axiom{lazyPrem(a,{}\\spad{b})} returns the polynomial \\axiom{\\spad{r}} reduced \\spad{w}.\\spad{r}.\\spad{t}. \\axiom{\\spad{b}} and such that \\axiom{\\spad{b}} divides \\axiom{init(\\spad{b})^e a - \\spad{r}} where \\axiom{\\spad{e}} is the number of steps of this pseudo-division.")) (|pquo| (($ $ $ |#4|) "\\axiom{pquo(a,{}\\spad{b},{}\\spad{v})} computes the pseudo-quotient of \\axiom{a} by \\axiom{\\spad{b}},{} both viewed as univariate polynomials in \\axiom{\\spad{v}}.") (($ $ $) "\\axiom{pquo(a,{}\\spad{b})} computes the pseudo-quotient of \\axiom{a} by \\axiom{\\spad{b}},{} both viewed as univariate polynomials in the main variable of \\axiom{\\spad{b}}.")) (|prem| (($ $ $ |#4|) "\\axiom{prem(a,{}\\spad{b},{}\\spad{v})} computes the pseudo-remainder of \\axiom{a} by \\axiom{\\spad{b}},{} both viewed as univariate polynomials in \\axiom{\\spad{v}}.") (($ $ $) "\\axiom{prem(a,{}\\spad{b})} computes the pseudo-remainder of \\axiom{a} by \\axiom{\\spad{b}},{} both viewed as univariate polynomials in the main variable of \\axiom{\\spad{b}}.")) (|normalized?| (((|Boolean|) $ (|List| $)) "\\axiom{normalized?(\\spad{q},{}lp)} returns \\spad{true} iff \\axiom{normalized?(\\spad{q},{}\\spad{p})} holds for every \\axiom{\\spad{p}} in \\axiom{lp}.") (((|Boolean|) $ $) "\\axiom{normalized?(a,{}\\spad{b})} returns \\spad{true} iff \\axiom{a} and its iterated initials have degree zero \\spad{w}.\\spad{r}.\\spad{t}. the main variable of \\axiom{\\spad{b}}")) (|initiallyReduced?| (((|Boolean|) $ (|List| $)) "\\axiom{initiallyReduced?(\\spad{q},{}lp)} returns \\spad{true} iff \\axiom{initiallyReduced?(\\spad{q},{}\\spad{p})} holds for every \\axiom{\\spad{p}} in \\axiom{lp}.") (((|Boolean|) $ $) "\\axiom{initiallyReduced?(a,{}\\spad{b})} returns \\spad{false} iff there exists an iterated initial of \\axiom{a} which is not reduced \\spad{w}.\\spad{r}.\\spad{t} \\axiom{\\spad{b}}.")) (|headReduced?| (((|Boolean|) $ (|List| $)) "\\axiom{headReduced?(\\spad{q},{}lp)} returns \\spad{true} iff \\axiom{headReduced?(\\spad{q},{}\\spad{p})} holds for every \\axiom{\\spad{p}} in \\axiom{lp}.") (((|Boolean|) $ $) "\\axiom{headReduced?(a,{}\\spad{b})} returns \\spad{true} iff \\axiom{degree(head(a),{}mvar(\\spad{b})) < mdeg(\\spad{b})}.")) (|reduced?| (((|Boolean|) $ (|List| $)) "\\axiom{reduced?(\\spad{q},{}lp)} returns \\spad{true} iff \\axiom{reduced?(\\spad{q},{}\\spad{p})} holds for every \\axiom{\\spad{p}} in \\axiom{lp}.") (((|Boolean|) $ $) "\\axiom{reduced?(a,{}\\spad{b})} returns \\spad{true} iff \\axiom{degree(a,{}mvar(\\spad{b})) < mdeg(\\spad{b})}.")) (|supRittWu?| (((|Boolean|) $ $) "\\axiom{supRittWu?(a,{}\\spad{b})} returns \\spad{true} if \\axiom{a} is greater than \\axiom{\\spad{b}} \\spad{w}.\\spad{r}.\\spad{t}. the Ritt and Wu Wen Tsun ordering using the refinement of Lazard.")) (|infRittWu?| (((|Boolean|) $ $) "\\axiom{infRittWu?(a,{}\\spad{b})} returns \\spad{true} if \\axiom{a} is less than \\axiom{\\spad{b}} \\spad{w}.\\spad{r}.\\spad{t}. the Ritt and Wu Wen Tsun ordering using the refinement of Lazard.")) (|RittWuCompare| (((|Union| (|Boolean|) "failed") $ $) "\\axiom{RittWuCompare(a,{}\\spad{b})} returns \\axiom{\"failed\"} if \\axiom{a} and \\axiom{\\spad{b}} have same rank \\spad{w}.\\spad{r}.\\spad{t}. Ritt and Wu Wen Tsun ordering using the refinement of Lazard,{} otherwise returns \\axiom{infRittWu?(a,{}\\spad{b})}.")) (|mainMonomials| (((|List| $) $) "\\axiom{mainMonomials(\\spad{p})} returns an error if \\axiom{\\spad{p}} is \\axiom{\\spad{O}},{} otherwise,{} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}} returns [1],{} otherwise returns the list of the monomials of \\axiom{\\spad{p}},{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in its main variable.")) (|mainCoefficients| (((|List| $) $) "\\axiom{mainCoefficients(\\spad{p})} returns an error if \\axiom{\\spad{p}} is \\axiom{\\spad{O}},{} otherwise,{} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}} returns [\\spad{p}],{} otherwise returns the list of the coefficients of \\axiom{\\spad{p}},{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in its main variable.")) (|leastMonomial| (($ $) "\\axiom{leastMonomial(\\spad{p})} returns an error if \\axiom{\\spad{p}} is \\axiom{\\spad{O}},{} otherwise,{} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}} returns \\axiom{1},{} otherwise,{} the monomial of \\axiom{\\spad{p}} with lowest degree,{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in its main variable.")) (|mainMonomial| (($ $) "\\axiom{mainMonomial(\\spad{p})} returns an error if \\axiom{\\spad{p}} is \\axiom{\\spad{O}},{} otherwise,{} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}} returns \\axiom{1},{} otherwise,{} \\axiom{mvar(\\spad{p})} raised to the power \\axiom{mdeg(\\spad{p})}.")) (|quasiMonic?| (((|Boolean|) $) "\\axiom{quasiMonic?(\\spad{p})} returns \\spad{false} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns \\spad{true} iff the initial of \\axiom{\\spad{p}} lies in the base ring \\axiom{\\spad{R}}.")) (|monic?| (((|Boolean|) $) "\\axiom{monic?(\\spad{p})} returns \\spad{false} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns \\spad{true} iff \\axiom{\\spad{p}} is monic as a univariate polynomial in its main variable.")) (|reductum| (($ $ |#4|) "\\axiom{reductum(\\spad{p},{}\\spad{v})} returns the reductum of \\axiom{\\spad{p}},{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in \\axiom{\\spad{v}}.")) (|leadingCoefficient| (($ $ |#4|) "\\axiom{leadingCoefficient(\\spad{p},{}\\spad{v})} returns the leading coefficient of \\axiom{\\spad{p}},{} where \\axiom{\\spad{p}} is viewed as A univariate polynomial in \\axiom{\\spad{v}}.")) (|deepestInitial| (($ $) "\\axiom{deepestInitial(\\spad{p})} returns an error if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns the last term of \\axiom{iteratedInitials(\\spad{p})}.")) (|iteratedInitials| (((|List| $) $) "\\axiom{iteratedInitials(\\spad{p})} returns \\axiom{[]} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns the list of the iterated initials of \\axiom{\\spad{p}}.")) (|deepestTail| (($ $) "\\axiom{deepestTail(\\spad{p})} returns \\axiom{0} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns tail(\\spad{p}),{} if \\axiom{tail(\\spad{p})} belongs to \\axiom{\\spad{R}} or \\axiom{mvar(tail(\\spad{p})) < mvar(\\spad{p})},{} otherwise returns \\axiom{deepestTail(tail(\\spad{p}))}.")) (|tail| (($ $) "\\axiom{tail(\\spad{p})} returns its reductum,{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in its main variable.")) (|head| (($ $) "\\axiom{head(\\spad{p})} returns \\axiom{\\spad{p}} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns its leading term (monomial in the AXIOM sense),{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in its main variable.")) (|init| (($ $) "\\axiom{init(\\spad{p})} returns an error if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns its leading coefficient,{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in its main variable.")) (|mdeg| (((|NonNegativeInteger|) $) "\\axiom{mdeg(\\spad{p})} returns an error if \\axiom{\\spad{p}} is \\axiom{0},{} otherwise,{} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}} returns \\axiom{0},{} otherwise,{} returns the degree of \\axiom{\\spad{p}} in its main variable.")) (|mvar| ((|#4| $) "\\axiom{mvar(\\spad{p})} returns an error if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns its main variable \\spad{w}. \\spad{r}. \\spad{t}. to the total ordering on the elements in \\axiom{\\spad{V}}."))) 
@@ -3854,7 +3854,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|GcdDomain|))) (|HasCategory| |#2| (QUOTE (|IntegralDomain|))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #1=(|Integer|)))) (|HasCategory| |#2| (QUOTE (|IntegerNumberSystem|))) (|HasCategory| |#2| (QUOTE (|Algebra| #1#))) (|HasCategory| |#2| (QUOTE (|QuotientFieldCategory| #1#))) (|HasCategory| |#2| (QUOTE (|Algebra| (|Fraction| #1#)))) (|HasCategory| |#4| (QUOTE (|ConvertibleTo| (|Symbol|))))) 
 (|RecursivePolynomialCategory| R E V) 
 ((|constructor| (NIL "A category for general multi-variate polynomials with coefficients in a ring,{} variables in an ordered set,{} and exponents from an ordered abelian monoid,{} with a \\axiomOp{sup} operation. When not constant,{} such a polynomial is viewed as a univariate polynomial in its main variable \\spad{w}. \\spad{r}. \\spad{t}. to the total ordering on the elements in the ordered set,{} so that some operations usually defined for univariate polynomials make sense here.")) (|mainSquareFreePart| (($ $) "\\axiom{mainSquareFreePart(\\spad{p})} returns the square free part of \\axiom{\\spad{p}} viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over \\axiom{\\spad{R}}.")) (|mainPrimitivePart| (($ $) "\\axiom{mainPrimitivePart(\\spad{p})} returns the primitive part of \\axiom{\\spad{p}} viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over \\axiom{\\spad{R}}.")) (|mainContent| (($ $) "\\axiom{mainContent(\\spad{p})} returns the content of \\axiom{\\spad{p}} viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over \\axiom{\\spad{R}}.")) (|primitivePart!| (($ $) "\\axiom{primitivePart!(\\spad{p})} replaces \\axiom{\\spad{p}} by its primitive part.")) (|gcd| ((|#1| |#1| $) "\\axiom{gcd(\\spad{r},{}\\spad{p})} returns the gcd of \\axiom{\\spad{r}} and the content of \\axiom{\\spad{p}}.")) (|nextsubResultant2| (($ $ $ $ $) "\\axiom{\\spad{nextsubResultant2}(\\spad{p},{}\\spad{q},{}\\spad{z},{}\\spad{s})} is the multivariate version of the operation \\axiomOpFrom{\\spad{next_sousResultant2}}{PseudoRemainderSequence} from the \\axiomType{PseudoRemainderSequence} constructor.")) (|LazardQuotient2| (($ $ $ $ (|NonNegativeInteger|)) "\\axiom{\\spad{LazardQuotient2}(\\spad{p},{}a,{}\\spad{b},{}\\spad{n})} returns \\axiom{(a**(\\spad{n}-1) * \\spad{p}) exquo b**(\\spad{n}-1)} assuming that this quotient does not fail.")) (|LazardQuotient| (($ $ $ (|NonNegativeInteger|)) "\\axiom{LazardQuotient(a,{}\\spad{b},{}\\spad{n})} returns \\axiom{a**n exquo b**(\\spad{n}-1)} assuming that this quotient does not fail.")) (|lastSubResultant| (($ $ $) "\\axiom{lastSubResultant(a,{}\\spad{b})} returns the last non-zero subresultant of \\axiom{a} and \\axiom{\\spad{b}} where \\axiom{a} and \\axiom{\\spad{b}} are assumed to have the same main variable \\axiom{\\spad{v}} and are viewed as univariate polynomials in \\axiom{\\spad{v}}.")) (|subResultantChain| (((|List| $) $ $) "\\axiom{subResultantChain(a,{}\\spad{b})},{} where \\axiom{a} and \\axiom{\\spad{b}} are not contant polynomials with the same main variable,{} returns the subresultant chain of \\axiom{a} and \\axiom{\\spad{b}}.")) (|resultant| (($ $ $) "\\axiom{resultant(a,{}\\spad{b})} computes the resultant of \\axiom{a} and \\axiom{\\spad{b}} where \\axiom{a} and \\axiom{\\spad{b}} are assumed to have the same main variable \\axiom{\\spad{v}} and are viewed as univariate polynomials in \\axiom{\\spad{v}}.")) (|halfExtendedSubResultantGcd2| (((|Record| (|:| |gcd| $) (|:| |coef2| $)) $ $) "\\axiom{\\spad{halfExtendedSubResultantGcd2}(a,{}\\spad{b})} returns \\axiom{[\\spad{g},{}cb]} if \\axiom{extendedSubResultantGcd(a,{}\\spad{b})} returns \\axiom{[\\spad{g},{}ca,{}cb]} otherwise produces an error.")) (|halfExtendedSubResultantGcd1| (((|Record| (|:| |gcd| $) (|:| |coef1| $)) $ $) "\\axiom{\\spad{halfExtendedSubResultantGcd1}(a,{}\\spad{b})} returns \\axiom{[\\spad{g},{}ca]} if \\axiom{extendedSubResultantGcd(a,{}\\spad{b})} returns \\axiom{[\\spad{g},{}ca,{}cb]} otherwise produces an error.")) (|extendedSubResultantGcd| (((|Record| (|:| |gcd| $) (|:| |coef1| $) (|:| |coef2| $)) $ $) "\\axiom{extendedSubResultantGcd(a,{}\\spad{b})} returns \\axiom{[ca,{}cb,{}\\spad{r}]} such that \\axiom{\\spad{r}} is \\axiom{subResultantGcd(a,{}\\spad{b})} and we have \\axiom{ca * a + cb * cb = \\spad{r}} .")) (|subResultantGcd| (($ $ $) "\\axiom{subResultantGcd(a,{}\\spad{b})} computes a gcd of \\axiom{a} and \\axiom{\\spad{b}} where \\axiom{a} and \\axiom{\\spad{b}} are assumed to have the same main variable \\axiom{\\spad{v}} and are viewed as univariate polynomials in \\axiom{\\spad{v}} with coefficients in the fraction field of the polynomial ring generated by their other variables over \\axiom{\\spad{R}}.")) (|exactQuotient!| (($ $ $) "\\axiom{exactQuotient!(a,{}\\spad{b})} replaces \\axiom{a} by \\axiom{exactQuotient(a,{}\\spad{b})}") (($ $ |#1|) "\\axiom{exactQuotient!(\\spad{p},{}\\spad{r})} replaces \\axiom{\\spad{p}} by \\axiom{exactQuotient(\\spad{p},{}\\spad{r})}.")) (|exactQuotient| (($ $ $) "\\axiom{exactQuotient(a,{}\\spad{b})} computes the exact quotient of \\axiom{a} by \\axiom{\\spad{b}},{} which is assumed to be a divisor of \\axiom{a}. No error is returned if this exact quotient fails!") (($ $ |#1|) "\\axiom{exactQuotient(\\spad{p},{}\\spad{r})} computes the exact quotient of \\axiom{\\spad{p}} by \\axiom{\\spad{r}},{} which is assumed to be a divisor of \\axiom{\\spad{p}}. No error is returned if this exact quotient fails!")) (|primPartElseUnitCanonical!| (($ $) "\\axiom{primPartElseUnitCanonical!(\\spad{p})} replaces \\axiom{\\spad{p}} by \\axiom{primPartElseUnitCanonical(\\spad{p})}.")) (|primPartElseUnitCanonical| (($ $) "\\axiom{primPartElseUnitCanonical(\\spad{p})} returns \\axiom{primitivePart(\\spad{p})} if \\axiom{\\spad{R}} is a gcd-domain,{} otherwise \\axiom{unitCanonical(\\spad{p})}.")) (|convert| (($ (|Polynomial| |#1|)) "\\axiom{convert(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}},{} otherwise an error is produced.") (($ (|Polynomial| (|Integer|))) "\\axiom{convert(\\spad{p})} returns the same as \\axiom{retract(\\spad{p})}.") (($ (|Polynomial| (|Integer|))) "\\axiom{convert(\\spad{p})} returns the same as \\axiom{retract(\\spad{p})}") (($ (|Polynomial| (|Fraction| (|Integer|)))) "\\axiom{convert(\\spad{p})} returns the same as \\axiom{retract(\\spad{p})}.")) (|retract| (($ (|Polynomial| |#1|)) "\\axiom{retract(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if \\axiom{retractIfCan(\\spad{p})} does not return \"failed\",{} otherwise an error is produced.") (($ (|Polynomial| |#1|)) "\\axiom{retract(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if \\axiom{retractIfCan(\\spad{p})} does not return \"failed\",{} otherwise an error is produced.") (($ (|Polynomial| (|Integer|))) "\\axiom{retract(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if \\axiom{retractIfCan(\\spad{p})} does not return \"failed\",{} otherwise an error is produced.") (($ (|Polynomial| |#1|)) "\\axiom{retract(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if \\axiom{retractIfCan(\\spad{p})} does not return \"failed\",{} otherwise an error is produced.") (($ (|Polynomial| (|Integer|))) "\\axiom{retract(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if \\axiom{retractIfCan(\\spad{p})} does not return \"failed\",{} otherwise an error is produced.") (($ (|Polynomial| (|Fraction| (|Integer|)))) "\\axiom{retract(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if \\axiom{retractIfCan(\\spad{p})} does not return \"failed\",{} otherwise an error is produced.")) (|retractIfCan| (((|Union| $ "failed") (|Polynomial| |#1|)) "\\axiom{retractIfCan(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}}.") (((|Union| $ "failed") (|Polynomial| |#1|)) "\\axiom{retractIfCan(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}}.") (((|Union| $ "failed") (|Polynomial| (|Integer|))) "\\axiom{retractIfCan(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}}.") (((|Union| $ "failed") (|Polynomial| |#1|)) "\\axiom{retractIfCan(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}}.") (((|Union| $ "failed") (|Polynomial| (|Integer|))) "\\axiom{retractIfCan(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}}.") (((|Union| $ "failed") (|Polynomial| (|Fraction| (|Integer|)))) "\\axiom{retractIfCan(\\spad{p})} returns \\axiom{\\spad{p}} as an element of the current domain if all its variables belong to \\axiom{\\spad{V}}.")) (|initiallyReduce| (($ $ $) "\\axiom{initiallyReduce(a,{}\\spad{b})} returns a polynomial \\axiom{\\spad{r}} such that \\axiom{initiallyReduced?(\\spad{r},{}\\spad{b})} holds and there exists an integer \\axiom{\\spad{e}} such that \\axiom{init(\\spad{b})^e a - \\spad{r}} is zero modulo \\axiom{\\spad{b}}.")) (|headReduce| (($ $ $) "\\axiom{headReduce(a,{}\\spad{b})} returns a polynomial \\axiom{\\spad{r}} such that \\axiom{headReduced?(\\spad{r},{}\\spad{b})} holds and there exists an integer \\axiom{\\spad{e}} such that \\axiom{init(\\spad{b})^e a - \\spad{r}} is zero modulo \\axiom{\\spad{b}}.")) (|lazyResidueClass| (((|Record| (|:| |polnum| $) (|:| |polden| $) (|:| |power| (|NonNegativeInteger|))) $ $) "\\axiom{lazyResidueClass(a,{}\\spad{b})} returns \\axiom{[\\spad{p},{}\\spad{q},{}\\spad{n}]} where \\axiom{\\spad{p} / q**n} represents the residue class of \\axiom{a} modulo \\axiom{\\spad{b}} and \\axiom{\\spad{p}} is reduced \\spad{w}.\\spad{r}.\\spad{t}. \\axiom{\\spad{b}} and \\axiom{\\spad{q}} is \\axiom{init(\\spad{b})}.")) (|monicModulo| (($ $ $) "\\axiom{monicModulo(a,{}\\spad{b})} computes \\axiom{a mod \\spad{b}},{} if \\axiom{\\spad{b}} is monic as univariate polynomial in its main variable.")) (|pseudoDivide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\axiom{pseudoDivide(a,{}\\spad{b})} computes \\axiom{[pquo(a,{}\\spad{b}),{}prem(a,{}\\spad{b})]},{} both polynomials viewed as univariate polynomials in the main variable of \\axiom{\\spad{b}},{} if \\axiom{\\spad{b}} is not a constant polynomial.")) (|lazyPseudoDivide| (((|Record| (|:| |coef| $) (|:| |gap| (|NonNegativeInteger|)) (|:| |quotient| $) (|:| |remainder| $)) $ $ |#3|) "\\axiom{lazyPseudoDivide(a,{}\\spad{b},{}\\spad{v})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{q},{}\\spad{r}]} such that \\axiom{\\spad{r} = lazyPrem(a,{}\\spad{b},{}\\spad{v})},{} \\axiom{(c**g)*r = prem(a,{}\\spad{b},{}\\spad{v})} and \\axiom{\\spad{q}} is the pseudo-quotient computed in this lazy pseudo-division.") (((|Record| (|:| |coef| $) (|:| |gap| (|NonNegativeInteger|)) (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\axiom{lazyPseudoDivide(a,{}\\spad{b})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{q},{}\\spad{r}]} such that \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{r}] = lazyPremWithDefault(a,{}\\spad{b})} and \\axiom{\\spad{q}} is the pseudo-quotient computed in this lazy pseudo-division.")) (|lazyPremWithDefault| (((|Record| (|:| |coef| $) (|:| |gap| (|NonNegativeInteger|)) (|:| |remainder| $)) $ $ |#3|) "\\axiom{lazyPremWithDefault(a,{}\\spad{b},{}\\spad{v})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{r}]} such that \\axiom{\\spad{r} = lazyPrem(a,{}\\spad{b},{}\\spad{v})} and \\axiom{(c**g)*r = prem(a,{}\\spad{b},{}\\spad{v})}.") (((|Record| (|:| |coef| $) (|:| |gap| (|NonNegativeInteger|)) (|:| |remainder| $)) $ $) "\\axiom{lazyPremWithDefault(a,{}\\spad{b})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{r}]} such that \\axiom{\\spad{r} = lazyPrem(a,{}\\spad{b})} and \\axiom{(c**g)*r = prem(a,{}\\spad{b})}.")) (|lazyPquo| (($ $ $ |#3|) "\\axiom{lazyPquo(a,{}\\spad{b},{}\\spad{v})} returns the polynomial \\axiom{\\spad{q}} such that \\axiom{lazyPseudoDivide(a,{}\\spad{b},{}\\spad{v})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{q},{}\\spad{r}]}.") (($ $ $) "\\axiom{lazyPquo(a,{}\\spad{b})} returns the polynomial \\axiom{\\spad{q}} such that \\axiom{lazyPseudoDivide(a,{}\\spad{b})} returns \\axiom{[\\spad{c},{}\\spad{g},{}\\spad{q},{}\\spad{r}]}.")) (|lazyPrem| (($ $ $ |#3|) "\\axiom{lazyPrem(a,{}\\spad{b},{}\\spad{v})} returns the polynomial \\axiom{\\spad{r}} reduced \\spad{w}.\\spad{r}.\\spad{t}. \\axiom{\\spad{b}} viewed as univariate polynomials in the variable \\axiom{\\spad{v}} such that \\axiom{\\spad{b}} divides \\axiom{init(\\spad{b})^e a - \\spad{r}} where \\axiom{\\spad{e}} is the number of steps of this pseudo-division.") (($ $ $) "\\axiom{lazyPrem(a,{}\\spad{b})} returns the polynomial \\axiom{\\spad{r}} reduced \\spad{w}.\\spad{r}.\\spad{t}. \\axiom{\\spad{b}} and such that \\axiom{\\spad{b}} divides \\axiom{init(\\spad{b})^e a - \\spad{r}} where \\axiom{\\spad{e}} is the number of steps of this pseudo-division.")) (|pquo| (($ $ $ |#3|) "\\axiom{pquo(a,{}\\spad{b},{}\\spad{v})} computes the pseudo-quotient of \\axiom{a} by \\axiom{\\spad{b}},{} both viewed as univariate polynomials in \\axiom{\\spad{v}}.") (($ $ $) "\\axiom{pquo(a,{}\\spad{b})} computes the pseudo-quotient of \\axiom{a} by \\axiom{\\spad{b}},{} both viewed as univariate polynomials in the main variable of \\axiom{\\spad{b}}.")) (|prem| (($ $ $ |#3|) "\\axiom{prem(a,{}\\spad{b},{}\\spad{v})} computes the pseudo-remainder of \\axiom{a} by \\axiom{\\spad{b}},{} both viewed as univariate polynomials in \\axiom{\\spad{v}}.") (($ $ $) "\\axiom{prem(a,{}\\spad{b})} computes the pseudo-remainder of \\axiom{a} by \\axiom{\\spad{b}},{} both viewed as univariate polynomials in the main variable of \\axiom{\\spad{b}}.")) (|normalized?| (((|Boolean|) $ (|List| $)) "\\axiom{normalized?(\\spad{q},{}lp)} returns \\spad{true} iff \\axiom{normalized?(\\spad{q},{}\\spad{p})} holds for every \\axiom{\\spad{p}} in \\axiom{lp}.") (((|Boolean|) $ $) "\\axiom{normalized?(a,{}\\spad{b})} returns \\spad{true} iff \\axiom{a} and its iterated initials have degree zero \\spad{w}.\\spad{r}.\\spad{t}. the main variable of \\axiom{\\spad{b}}")) (|initiallyReduced?| (((|Boolean|) $ (|List| $)) "\\axiom{initiallyReduced?(\\spad{q},{}lp)} returns \\spad{true} iff \\axiom{initiallyReduced?(\\spad{q},{}\\spad{p})} holds for every \\axiom{\\spad{p}} in \\axiom{lp}.") (((|Boolean|) $ $) "\\axiom{initiallyReduced?(a,{}\\spad{b})} returns \\spad{false} iff there exists an iterated initial of \\axiom{a} which is not reduced \\spad{w}.\\spad{r}.\\spad{t} \\axiom{\\spad{b}}.")) (|headReduced?| (((|Boolean|) $ (|List| $)) "\\axiom{headReduced?(\\spad{q},{}lp)} returns \\spad{true} iff \\axiom{headReduced?(\\spad{q},{}\\spad{p})} holds for every \\axiom{\\spad{p}} in \\axiom{lp}.") (((|Boolean|) $ $) "\\axiom{headReduced?(a,{}\\spad{b})} returns \\spad{true} iff \\axiom{degree(head(a),{}mvar(\\spad{b})) < mdeg(\\spad{b})}.")) (|reduced?| (((|Boolean|) $ (|List| $)) "\\axiom{reduced?(\\spad{q},{}lp)} returns \\spad{true} iff \\axiom{reduced?(\\spad{q},{}\\spad{p})} holds for every \\axiom{\\spad{p}} in \\axiom{lp}.") (((|Boolean|) $ $) "\\axiom{reduced?(a,{}\\spad{b})} returns \\spad{true} iff \\axiom{degree(a,{}mvar(\\spad{b})) < mdeg(\\spad{b})}.")) (|supRittWu?| (((|Boolean|) $ $) "\\axiom{supRittWu?(a,{}\\spad{b})} returns \\spad{true} if \\axiom{a} is greater than \\axiom{\\spad{b}} \\spad{w}.\\spad{r}.\\spad{t}. the Ritt and Wu Wen Tsun ordering using the refinement of Lazard.")) (|infRittWu?| (((|Boolean|) $ $) "\\axiom{infRittWu?(a,{}\\spad{b})} returns \\spad{true} if \\axiom{a} is less than \\axiom{\\spad{b}} \\spad{w}.\\spad{r}.\\spad{t}. the Ritt and Wu Wen Tsun ordering using the refinement of Lazard.")) (|RittWuCompare| (((|Union| (|Boolean|) "failed") $ $) "\\axiom{RittWuCompare(a,{}\\spad{b})} returns \\axiom{\"failed\"} if \\axiom{a} and \\axiom{\\spad{b}} have same rank \\spad{w}.\\spad{r}.\\spad{t}. Ritt and Wu Wen Tsun ordering using the refinement of Lazard,{} otherwise returns \\axiom{infRittWu?(a,{}\\spad{b})}.")) (|mainMonomials| (((|List| $) $) "\\axiom{mainMonomials(\\spad{p})} returns an error if \\axiom{\\spad{p}} is \\axiom{\\spad{O}},{} otherwise,{} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}} returns [1],{} otherwise returns the list of the monomials of \\axiom{\\spad{p}},{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in its main variable.")) (|mainCoefficients| (((|List| $) $) "\\axiom{mainCoefficients(\\spad{p})} returns an error if \\axiom{\\spad{p}} is \\axiom{\\spad{O}},{} otherwise,{} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}} returns [\\spad{p}],{} otherwise returns the list of the coefficients of \\axiom{\\spad{p}},{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in its main variable.")) (|leastMonomial| (($ $) "\\axiom{leastMonomial(\\spad{p})} returns an error if \\axiom{\\spad{p}} is \\axiom{\\spad{O}},{} otherwise,{} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}} returns \\axiom{1},{} otherwise,{} the monomial of \\axiom{\\spad{p}} with lowest degree,{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in its main variable.")) (|mainMonomial| (($ $) "\\axiom{mainMonomial(\\spad{p})} returns an error if \\axiom{\\spad{p}} is \\axiom{\\spad{O}},{} otherwise,{} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}} returns \\axiom{1},{} otherwise,{} \\axiom{mvar(\\spad{p})} raised to the power \\axiom{mdeg(\\spad{p})}.")) (|quasiMonic?| (((|Boolean|) $) "\\axiom{quasiMonic?(\\spad{p})} returns \\spad{false} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns \\spad{true} iff the initial of \\axiom{\\spad{p}} lies in the base ring \\axiom{\\spad{R}}.")) (|monic?| (((|Boolean|) $) "\\axiom{monic?(\\spad{p})} returns \\spad{false} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns \\spad{true} iff \\axiom{\\spad{p}} is monic as a univariate polynomial in its main variable.")) (|reductum| (($ $ |#3|) "\\axiom{reductum(\\spad{p},{}\\spad{v})} returns the reductum of \\axiom{\\spad{p}},{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in \\axiom{\\spad{v}}.")) (|leadingCoefficient| (($ $ |#3|) "\\axiom{leadingCoefficient(\\spad{p},{}\\spad{v})} returns the leading coefficient of \\axiom{\\spad{p}},{} where \\axiom{\\spad{p}} is viewed as A univariate polynomial in \\axiom{\\spad{v}}.")) (|deepestInitial| (($ $) "\\axiom{deepestInitial(\\spad{p})} returns an error if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns the last term of \\axiom{iteratedInitials(\\spad{p})}.")) (|iteratedInitials| (((|List| $) $) "\\axiom{iteratedInitials(\\spad{p})} returns \\axiom{[]} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns the list of the iterated initials of \\axiom{\\spad{p}}.")) (|deepestTail| (($ $) "\\axiom{deepestTail(\\spad{p})} returns \\axiom{0} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns tail(\\spad{p}),{} if \\axiom{tail(\\spad{p})} belongs to \\axiom{\\spad{R}} or \\axiom{mvar(tail(\\spad{p})) < mvar(\\spad{p})},{} otherwise returns \\axiom{deepestTail(tail(\\spad{p}))}.")) (|tail| (($ $) "\\axiom{tail(\\spad{p})} returns its reductum,{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in its main variable.")) (|head| (($ $) "\\axiom{head(\\spad{p})} returns \\axiom{\\spad{p}} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns its leading term (monomial in the AXIOM sense),{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in its main variable.")) (|init| (($ $) "\\axiom{init(\\spad{p})} returns an error if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns its leading coefficient,{} where \\axiom{\\spad{p}} is viewed as a univariate polynomial in its main variable.")) (|mdeg| (((|NonNegativeInteger|) $) "\\axiom{mdeg(\\spad{p})} returns an error if \\axiom{\\spad{p}} is \\axiom{0},{} otherwise,{} if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}} returns \\axiom{0},{} otherwise,{} returns the degree of \\axiom{\\spad{p}} in its main variable.")) (|mvar| ((|#3| $) "\\axiom{mvar(\\spad{p})} returns an error if \\axiom{\\spad{p}} belongs to \\axiom{\\spad{R}},{} otherwise returns its main variable \\spad{w}. \\spad{r}. \\spad{t}. to the total ordering on the elements in \\axiom{\\spad{V}}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
 NIL 
 (|RepeatAst|) 
 ((|constructor| (NIL "This domain represents the `repeat' iterator syntax.")) (|body| (((|SpadAst|) $) "\\spad{body(e)} returns the body of the loop `e'.")) (|iterators| (((|List| (|SpadAst|)) $) "\\spad{iterators(e)} returns the list of iterators controlling the loop `e'."))) 
@@ -3910,7 +3910,7 @@ NIL
 NIL 
 (|SimpleAlgebraicExtension| R UP M) 
 ((|constructor| (NIL "Domain which represents simple algebraic extensions of arbitrary rings. The first argument to the domain,{} \\spad{R},{} is the underlying ring,{} the second argument is a domain of univariate polynomials over \\spad{K},{} while the last argument specifies the defining minimal polynomial. The elements of the domain are canonically represented as polynomials of degree less than that of the minimal polynomial with coefficients in \\spad{R}. The second argument is both the type of the third argument and the underlying representation used by \\spadtype{SAE} itself."))) 
-((|noZeroDivisors| |has| |#1| . #1=((|Field|))) (|canonicalUnitNormal| |has| |#1| . #1#) (|canonicalsClosed| |has| |#1| . #1#) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| |has| |#1| . #1=((|Field|))) (|canonicalUnitNormal| |has| |#1| . #1#) ((|commutative| "*") . T)) 
 ((|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #1=(|HasCategory| |#1| (QUOTE (|FiniteFieldCategory|))) (OR #2=(|HasCategory| |#1| (QUOTE (|Field|))) #1#) #2# (|HasCategory| |#1| (QUOTE (|Finite|))) (OR #3=(AND (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) #2#) #1#) (OR #3# #4=(AND (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) #2#) #1#) (OR #5=(AND #2# #6=(|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #7=(|Symbol|))))) (AND #1# #6#)) (OR #5# #8=(AND #2# (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #7#))))) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #9=(|Integer|)))) (OR #2# #10=(|HasCategory| |#1| (QUOTE (|RetractableTo| (|Fraction| #9#))))) #10# (|HasCategory| |#1| (QUOTE (|RetractableTo| #9#))) (OR #4# #1#) #8# #4# #3# #5#) 
 (|SimpleAlgebraicExtensionAlgFactor| UP SAE UPA) 
 ((|constructor| (NIL "Factorization of univariate polynomials with coefficients in an algebraic extension of the rational numbers (\\spadtype{Fraction Integer}).")) (|factor| (((|Factored| |#3|) |#3|) "\\spad{factor(p)} returns a prime factorisation of \\spad{p}."))) 
@@ -3942,8 +3942,8 @@ NIL
 NIL 
 (|SequentialDifferentialPolynomial| R) 
 ((|constructor| (NIL "\\spadtype{SequentialDifferentialPolynomial} implements an ordinary differential polynomial ring in arbitrary number of differential indeterminates,{} with coefficients in a ring. The ranking on the differential indeterminate is sequential. \\blankline"))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#1| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|SequentialDifferentialVariable| #8=(|Symbol|)) #5#)) (AND (|HasCategory| |#1| #9=(QUOTE (|PatternMatchable| #10=(|Integer|)))) (|HasCategory| #7# #9#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#1| #12=(QUOTE (|ConvertibleTo| (|Pattern| #10#)))) (|HasCategory| #7# #12#)) (AND (|HasCategory| |#1| #13=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #13#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #10#))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #14=(|HasCategory| |#1| #15=(QUOTE (|CharacteristicNonZero|))) #16=(|HasCategory| |#1| (QUOTE (|Algebra| #17=(|Fraction| #10#)))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #10#))) (OR #16# #18=(|HasCategory| |#1| (QUOTE (|RetractableTo| #17#)))) #18# (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #8#))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #8#))) (|HasCategory| |#1| (QUOTE (|Field|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #3# #19=(AND #1# (|HasCategory| $ #15#)) (OR #19# #14#)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#1| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| #7=(|SequentialDifferentialVariable| #8=(|Symbol|)) #5#)) (AND (|HasCategory| |#1| #9=(QUOTE (|PatternMatchable| #10=(|Integer|)))) (|HasCategory| #7# #9#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| #7# #11#)) (AND (|HasCategory| |#1| #12=(QUOTE (|ConvertibleTo| (|Pattern| #10#)))) (|HasCategory| #7# #12#)) (AND (|HasCategory| |#1| #13=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #7# #13#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #10#))) #14=(|HasCategory| |#1| (QUOTE (|Algebra| #15=(|Fraction| #10#)))) #16=(|HasCategory| |#1| #17=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #10#))) (OR #14# #18=(|HasCategory| |#1| (QUOTE (|RetractableTo| #15#)))) #18# (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #8#))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #8#))) (|HasCategory| |#1| (QUOTE (|Field|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #3# #19=(AND #1# (|HasCategory| $ #17#)) (OR #19# #16#)) 
 (|SequentialDifferentialVariable| S) 
 ((|constructor| (NIL "\\spadtype{OrderlyDifferentialVariable} adds a commonly used sequential ranking to the set of derivatives of an ordered list of differential indeterminates. A sequential ranking is a ranking \\spadfun{<} of the derivatives with the property that for any derivative \\spad{v},{} there are only a finite number of derivatives \\spad{u} with \\spad{u} \\spadfun{<} \\spad{v}. This domain belongs to \\spadtype{DifferentialVariableCategory}. It defines \\spadfun{weight} to be just \\spadfun{order},{} and it defines a sequential ranking \\spadfun{<} on derivatives \\spad{u} by the lexicographic order on the pair (\\spadfun{variable}(\\spad{u}),{} \\spadfun{order}(\\spad{u}))."))) 
 NIL 
@@ -4050,8 +4050,8 @@ NIL
 NIL 
 (|SplitHomogeneousDirectProduct| |dimtot| |dim1| S) 
 ((|constructor| (NIL "\\indented{2}{This type represents the finite direct or cartesian product of an} underlying ordered component type. The vectors are ordered as if they were split into two blocks. The \\spad{dim1} parameter specifies the length of the first block. The ordering is lexicographic between the blocks but acts like \\spadtype{HomogeneousDirectProduct} within each block. This type is a suitable third argument for \\spadtype{GeneralDistributedMultivariatePolynomial}."))) 
-((|rightUnitary| |has| |#3| . #1=((|Ring|))) (|leftUnitary| |has| |#3| . #1#) (|unitsKnown| |has| |#3| (ATTRIBUTE |unitsKnown|))) 
-((OR (AND #1=(|HasCategory| |#3| (QUOTE (|AbelianGroup|))) #2=(|HasCategory| |#3| (|%list| (QUOTE |Evalable|) #3=(|devaluate| |#3|)))) (AND #4=(|HasCategory| |#3| (QUOTE (|AbelianMonoid|))) #2#) (AND #5=(|HasCategory| |#3| (QUOTE (|AbelianSemiGroup|))) #2#) (AND #6=(|HasCategory| |#3| (QUOTE (|CancellationAbelianMonoid|))) #2#) (AND #7=(|HasCategory| |#3| (QUOTE (|CommutativeRing|))) #2#) (AND #8=(|HasCategory| |#3| (QUOTE (|DifferentialRing|))) #2#) (AND #9=(|HasCategory| |#3| (QUOTE (|Field|))) #2#) (AND #10=(|HasCategory| |#3| (QUOTE (|Finite|))) #2#) (AND #11=(|HasCategory| |#3| (QUOTE (|Monoid|))) #2#) (AND #12=(|HasCategory| |#3| (QUOTE (|OrderedAbelianMonoidSup|))) #2#) (AND #13=(|HasCategory| |#3| #14=(QUOTE (|OrderedSet|))) #2#) (AND #15=(|HasCategory| |#3| (QUOTE (|PartialDifferentialRing| #16=(|Symbol|)))) #2#) (AND #17=(|HasCategory| |#3| (QUOTE (|Ring|))) #2#) #18=(AND #19=(|HasCategory| |#3| (QUOTE (|SetCategory|))) #2#)) (|HasCategory| |#3| (QUOTE (|CoercibleTo| (|OutputForm|)))) #9# (OR #7# #9# #17#) (OR #7# #9#) #1# #17# #11# #12# (OR #12# #13#) #13# #10# (OR (AND #7# #20=(|HasCategory| |#3| (QUOTE (|LinearlyExplicitRingOver| #21=(|Integer|))))) (AND #8# #20#) (AND #9# #20#) (AND #20# #15#) #22=(AND #20# #17#)) #15# (OR #1# #4# #5# #23=(|HasCategory| |#3| (QUOTE (|BasicType|))) #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #15# #17#) (OR #1# #4# #6# #7# #8# #9# #15# #17#) (OR #1# #6# #7# #8# #9# #15# #17#) (OR #1# #7# #8# #9# #15# #17#) (OR #8# #15# #17#) #8# (OR #8# #24=(AND (|HasCategory| |#3| (QUOTE (|DifferentialSpace|))) #17#)) (OR #25=(AND (|HasCategory| |#3| (QUOTE (|PartialDifferentialSpace| #16#))) #17#) #15#) #19# (OR (AND #1# #26=(|HasCategory| |#3| (QUOTE (|RetractableTo| (|Fraction| #21#))))) (AND #4# #26#) (AND #5# #26#) (AND #6# #26#) (AND #7# #26#) (AND #8# #26#) (AND #9# #26#) (AND #10# #26#) (AND #11# #26#) (AND #12# #26#) (AND #13# #26#) (AND #15# #26#) (AND #26# #17#) #27=(AND #26# #19#)) (OR #28=(AND #1# #29=(|HasCategory| |#3| (QUOTE (|RetractableTo| #21#)))) #30=(AND #4# #29#) #31=(AND #5# #29#) #32=(AND #6# #29#) #33=(AND #7# #29#) #34=(AND #8# #29#) #35=(AND #12# #29#) #36=(AND #13# #29#) #37=(AND #15# #29#) #38=(AND #29# #19#) #39=(AND #9# #29#) #40=(AND #10# #29#) #41=(AND #11# #29#) #17#) (OR #28# #30# #31# #32# #33# #34# #35# #36# #37# #38# #39# #40# #41# (AND #29# #17#)) #23# (|HasCategory| #21# #14#) #22# #24# #25# (OR #38# #17#) #38# #27# (|HasAttribute| |#3| (QUOTE |unitsKnown|)) (AND #8# #17#) (AND #15# #17#) #7# #4# #6# #5# #18# (AND #23# (|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #3#))) (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #3#))) 
+NIL 
+((OR (AND #1=(|HasCategory| |#3| (QUOTE (|AbelianGroup|))) #2=(|HasCategory| |#3| (|%list| (QUOTE |Evalable|) #3=(|devaluate| |#3|)))) (AND #4=(|HasCategory| |#3| (QUOTE (|AbelianMonoid|))) #2#) (AND #5=(|HasCategory| |#3| (QUOTE (|AbelianSemiGroup|))) #2#) (AND #6=(|HasCategory| |#3| (QUOTE (|CancellationAbelianMonoid|))) #2#) (AND #7=(|HasCategory| |#3| (QUOTE (|CommutativeRing|))) #2#) (AND #8=(|HasCategory| |#3| (QUOTE (|DifferentialRing|))) #2#) (AND #9=(|HasCategory| |#3| (QUOTE (|Field|))) #2#) (AND #10=(|HasCategory| |#3| (QUOTE (|Finite|))) #2#) (AND #11=(|HasCategory| |#3| (QUOTE (|Monoid|))) #2#) (AND #12=(|HasCategory| |#3| (QUOTE (|OrderedAbelianMonoidSup|))) #2#) (AND #13=(|HasCategory| |#3| #14=(QUOTE (|OrderedSet|))) #2#) (AND #15=(|HasCategory| |#3| (QUOTE (|PartialDifferentialRing| #16=(|Symbol|)))) #2#) (AND #17=(|HasCategory| |#3| (QUOTE (|Ring|))) #2#) #18=(AND #19=(|HasCategory| |#3| (QUOTE (|SetCategory|))) #2#)) (|HasCategory| |#3| (QUOTE (|CoercibleTo| (|OutputForm|)))) #9# (OR #7# #9# #17#) (OR #7# #9#) #1# #17# #11# #12# (OR #12# #13#) #13# #10# (OR (AND #7# #20=(|HasCategory| |#3| (QUOTE (|LinearlyExplicitRingOver| #21=(|Integer|))))) (AND #8# #20#) (AND #9# #20#) (AND #20# #15#) #22=(AND #20# #17#)) #15# (OR #1# #4# #5# #23=(|HasCategory| |#3| (QUOTE (|BasicType|))) #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #10# #11# #12# #13# #15# #17# #19#) (OR #1# #4# #5# #6# #7# #8# #9# #15# #17#) (OR #1# #4# #6# #7# #8# #9# #15# #17#) (OR #1# #6# #7# #8# #9# #15# #17#) (OR #1# #7# #8# #9# #15# #17#) (OR #8# #15# #17#) #8# (OR #8# #24=(AND (|HasCategory| |#3| (QUOTE (|DifferentialSpace|))) #17#)) (OR #25=(AND (|HasCategory| |#3| (QUOTE (|PartialDifferentialSpace| #16#))) #17#) #15#) #19# (OR (AND #1# #26=(|HasCategory| |#3| (QUOTE (|RetractableTo| (|Fraction| #21#))))) (AND #4# #26#) (AND #5# #26#) (AND #6# #26#) (AND #7# #26#) (AND #8# #26#) (AND #9# #26#) (AND #10# #26#) (AND #11# #26#) (AND #12# #26#) (AND #13# #26#) (AND #15# #26#) (AND #26# #17#) #27=(AND #26# #19#)) (OR #28=(AND #1# #29=(|HasCategory| |#3| (QUOTE (|RetractableTo| #21#)))) #30=(AND #4# #29#) #31=(AND #5# #29#) #32=(AND #6# #29#) #33=(AND #7# #29#) #34=(AND #8# #29#) #35=(AND #12# #29#) #36=(AND #13# #29#) #37=(AND #15# #29#) #38=(AND #29# #19#) #39=(AND #9# #29#) #40=(AND #10# #29#) #41=(AND #11# #29#) #17#) (OR #28# #30# #31# #32# #33# #34# #35# #36# #37# #38# #39# #40# #41# (AND #29# #17#)) #23# (|HasCategory| #21# #14#) #22# #24# #25# (OR #38# #17#) #38# #27# (AND #8# #17#) (AND #15# #17#) #7# #4# #6# #5# #18# (AND #23# (|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #3#))) (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #3#))) 
 (|SturmHabichtPackage| R |x|) 
 ((|constructor| (NIL "This package produces functions for counting etc. real roots of univariate polynomials in \\spad{x} over \\spad{R},{} which must be an OrderedIntegralDomain")) (|countRealRootsMultiple| (((|Integer|) (|UnivariatePolynomial| |#2| |#1|)) "\\spad{countRealRootsMultiple(p)} says how many real roots \\spad{p} has,{} counted with multiplicity")) (|SturmHabichtMultiple| (((|Integer|) (|UnivariatePolynomial| |#2| |#1|) (|UnivariatePolynomial| |#2| |#1|)) "\\spad{SturmHabichtMultiple(p1,p2)} computes c_{+}-c_{-} where c_{+} is the number of real roots of \\spad{p1} with \\spad{p2>0} and c_{-} is the number of real roots of \\spad{p1} with \\spad{p2<0}. If \\spad{p2=1} what you get is the number of real roots of \\spad{p1}.")) (|countRealRoots| (((|Integer|) (|UnivariatePolynomial| |#2| |#1|)) "\\spad{countRealRoots(p)} says how many real roots \\spad{p} has")) (|SturmHabicht| (((|Integer|) (|UnivariatePolynomial| |#2| |#1|) (|UnivariatePolynomial| |#2| |#1|)) "\\spad{SturmHabicht(p1,p2)} computes c_{+}-c_{-} where c_{+} is the number of real roots of \\spad{p1} with \\spad{p2>0} and c_{-} is the number of real roots of \\spad{p1} with \\spad{p2<0}. If \\spad{p2=1} what you get is the number of real roots of \\spad{p1}.")) (|SturmHabichtCoefficients| (((|List| |#1|) (|UnivariatePolynomial| |#2| |#1|) (|UnivariatePolynomial| |#2| |#1|)) "\\spad{SturmHabichtCoefficients(p1,p2)} computes the principal Sturm-Habicht coefficients of \\spad{p1} and \\spad{p2}")) (|SturmHabichtSequence| (((|List| (|UnivariatePolynomial| |#2| |#1|)) (|UnivariatePolynomial| |#2| |#1|) (|UnivariatePolynomial| |#2| |#1|)) "\\spad{SturmHabichtSequence(p1,p2)} computes the Sturm-Habicht sequence of \\spad{p1} and \\spad{p2}")) (|subresultantSequence| (((|List| (|UnivariatePolynomial| |#2| |#1|)) (|UnivariatePolynomial| |#2| |#1|) (|UnivariatePolynomial| |#2| |#1|)) "\\spad{subresultantSequence(p1,p2)} computes the (standard) subresultant sequence of \\spad{p1} and \\spad{p2}"))) 
 NIL 
@@ -4077,8 +4077,8 @@ NIL
 NIL 
 NIL 
 (|SingleInteger|) 
-((|constructor| (NIL "SingleInteger is intended to support machine integer arithmetic.")) (|xor| (($ $ $) "\\spad{xor(n,m)} returns the bit-by-bit logical {\\em xor} of the single integers \\spad{n} and \\spad{m}.")) (|noetherian| ((|attribute|) "\\spad{noetherian} all ideals are finitely generated (in fact principal).")) (|canonicalsClosed| ((|attribute|) "\\spad{canonicalClosed} means two positives multiply to give positive.")) (|canonical| ((|attribute|) "\\spad{canonical} means that mathematical equality is implied by data structure equality."))) 
-((|noetherian| . T) (|canonicalsClosed| . T) (|canonical| . T) (|canonicalUnitNormal| . T) (|multiplicativeValuation| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|constructor| (NIL "SingleInteger is intended to support machine integer arithmetic.")) (|xor| (($ $ $) "\\spad{xor(n,m)} returns the bit-by-bit logical {\\em xor} of the single integers \\spad{n} and \\spad{m}.")) (|canonical| ((|attribute|) "\\spad{canonical} means that mathematical equality is implied by data structure equality."))) 
+((|canonical| . T) (|canonicalUnitNormal| . T) (|multiplicativeValuation| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|StackAggregate| S) 
 ((|constructor| (NIL "A stack is a bag where the last item inserted is the first item extracted.")) (|depth| (((|NonNegativeInteger|) $) "\\spad{depth(s)} returns the number of elements of stack \\spad{s}. Note: \\axiom{depth(\\spad{s}) = \\#s}.")) (|top| ((|#1| $) "\\spad{top(s)} returns the top element \\spad{x} from \\spad{s}; \\spad{s} remains unchanged. Note: Use \\axiom{pop!(\\spad{s})} to obtain \\spad{x} and remove it from \\spad{s}.")) (|pop!| ((|#1| $) "\\spad{pop!(s)} returns the top element \\spad{x},{} destructively removing \\spad{x} from \\spad{s}. Note: Use \\axiom{top(\\spad{s})} to obtain \\spad{x} without removing it from \\spad{s}. Error: if \\spad{s} is empty.")) (|push!| ((|#1| |#1| $) "\\spad{push!(x,s)} pushes \\spad{x} onto stack \\spad{s},{} \\spadignore{i.e.} destructively changing \\spad{s} so as to have a new first (top) element \\spad{x}. Afterwards,{} pop!(\\spad{s}) produces \\spad{x} and pop!(\\spad{s}) produces the original \\spad{s}."))) 
@@ -4094,7 +4094,7 @@ NIL
 ((|HasCategory| |#3| (QUOTE (|Field|))) (|HasAttribute| |#3| (QUOTE (|commutative| "*"))) (|HasCategory| |#3| (QUOTE (|CommutativeRing|)))) 
 (|SquareMatrixCategory| |ndim| R |Row| |Col|) 
 ((|constructor| (NIL "\\spadtype{SquareMatrixCategory} is a general square matrix category which allows different representations and indexing schemes. Rows and columns may be extracted with rows returned as objects of type Row and colums returned as objects of type Col.")) (** (($ $ (|Integer|)) "\\spad{m**n} computes an integral power of the matrix \\spad{m}. Error: if the matrix is not invertible.")) (|inverse| (((|Union| $ "failed") $) "\\spad{inverse(m)} returns the inverse of the matrix \\spad{m},{} if that matrix is invertible and returns \"failed\" otherwise.")) (|minordet| ((|#2| $) "\\spad{minordet(m)} computes the determinant of the matrix \\spad{m} using minors.")) (|determinant| ((|#2| $) "\\spad{determinant(m)} returns the determinant of the matrix \\spad{m}.")) (* ((|#3| |#3| $) "\\spad{r * x} is the product of the row vector \\spad{r} and the matrix \\spad{x}. Error: if the dimensions are incompatible.") ((|#4| $ |#4|) "\\spad{x * c} is the product of the matrix \\spad{x} and the column vector \\spad{c}. Error: if the dimensions are incompatible.")) (|diagonalProduct| ((|#2| $) "\\spad{diagonalProduct(m)} returns the product of the elements on the diagonal of the matrix \\spad{m}.")) (|trace| ((|#2| $) "\\spad{trace(m)} returns the trace of the matrix \\spad{m}. this is the sum of the elements on the diagonal of the matrix \\spad{m}.")) (|diagonal| ((|#3| $) "\\spad{diagonal(m)} returns a row consisting of the elements on the diagonal of the matrix \\spad{m}.")) (|diagonalMatrix| (($ (|List| |#2|)) "\\spad{diagonalMatrix(l)} returns a diagonal matrix with the elements of \\spad{l} on the diagonal.")) (|scalarMatrix| (($ |#2|) "\\spad{scalarMatrix(r)} returns an \\spad{n}-by-\\spad{n} matrix with \\spad{r}'s on the diagonal and zeroes elsewhere."))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 NIL 
 (|SmithNormalForm| R |Row| |Col| M) 
 ((|constructor| (NIL "\\spadtype{SmithNormalForm} is a package which provides some standard canonical forms for matrices.")) (|diophantineSystem| (((|Record| (|:| |particular| (|Union| |#3| "failed")) (|:| |basis| (|List| |#3|))) |#4| |#3|) "\\spad{diophantineSystem(A,B)} returns a particular integer solution and an integer basis of the equation \\spad{AX = B}.")) (|completeSmith| (((|Record| (|:| |Smith| |#4|) (|:| |leftEqMat| |#4|) (|:| |rightEqMat| |#4|)) |#4|) "\\spad{completeSmith} returns a record that contains the Smith normal form \\spad{H} of the matrix and the left and right equivalence matrices \\spad{U} and \\spad{V} such that U*m*v = \\spad{H}")) (|smith| ((|#4| |#4|) "\\spad{smith(m)} returns the Smith Normal form of the matrix \\spad{m}.")) (|completeHermite| (((|Record| (|:| |Hermite| |#4|) (|:| |eqMat| |#4|)) |#4|) "\\spad{completeHermite} returns a record that contains the Hermite normal form \\spad{H} of the matrix and the equivalence matrix \\spad{U} such that U*m = \\spad{H}")) (|hermite| ((|#4| |#4|) "\\spad{hermite(m)} returns the Hermite normal form of the matrix \\spad{m}."))) 
@@ -4102,12 +4102,12 @@ NIL
 NIL 
 (|SparseMultivariatePolynomial| R |VarSet|) 
 ((|constructor| (NIL "\\indented{2}{This type is the basic representation of sparse recursive multivariate} polynomials. It is parameterized by the coefficient ring and the variable set which may be infinite. The variable ordering is determined by the variable set parameter. The coefficient ring may be non-commutative,{} but the variables are assumed to commute."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#1| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| |#2| #5#)) (AND (|HasCategory| |#1| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| |#2| #7#)) (AND (|HasCategory| |#1| #9=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| |#2| #9#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| |#2| #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#2| #11#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #8#))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #12=(|HasCategory| |#1| #13=(QUOTE (|CharacteristicNonZero|))) #14=(|HasCategory| |#1| (QUOTE (|Algebra| #15=(|Fraction| #8#)))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #8#))) (OR #14# #16=(|HasCategory| |#1| (QUOTE (|RetractableTo| #15#)))) #16# (|HasCategory| |#1| (QUOTE (|Field|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #3# #17=(AND #1# (|HasCategory| $ #13#)) (OR #17# #12#)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) (OR #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #1#) (OR #3# #4# #1#) (OR #3# #1#) #4# #2# (OR #2# #4#) (AND (|HasCategory| |#1| #5=(QUOTE (|PatternMatchable| #6=(|Float|)))) (|HasCategory| |#2| #5#)) (AND (|HasCategory| |#1| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| |#2| #7#)) (AND (|HasCategory| |#1| #9=(QUOTE (|ConvertibleTo| (|Pattern| #6#)))) (|HasCategory| |#2| #9#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| |#2| #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#2| #11#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #8#))) #12=(|HasCategory| |#1| (QUOTE (|Algebra| #13=(|Fraction| #8#)))) #14=(|HasCategory| |#1| #15=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #8#))) (OR #12# #16=(|HasCategory| |#1| (QUOTE (|RetractableTo| #13#)))) #16# (|HasCategory| |#1| (QUOTE (|Field|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #3# #17=(AND #1# (|HasCategory| $ #15#)) (OR #17# #14#)) 
 (|SparseMultivariateTaylorSeries| |Coef| |Var| SMP) 
 ((|constructor| (NIL "This domain provides multivariate Taylor series with variables from an arbitrary ordered set. A Taylor series is represented by a stream of polynomials from the polynomial domain SMP. The \\spad{n}th element of the stream is a form of degree \\spad{n}. SMTS is an internal domain.")) (|fintegrate| (($ (|Mapping| $) |#2| |#1|) "\\spad{fintegrate(f,v,c)} is the integral of \\spad{f()} with respect \\indented{1}{to \\spad{v} and having \\spad{c} as the constant of integration.} \\indented{1}{The evaluation of \\spad{f()} is delayed.}")) (|integrate| (($ $ |#2| |#1|) "\\spad{integrate(s,v,c)} is the integral of \\spad{s} with respect \\indented{1}{to \\spad{v} and having \\spad{c} as the constant of integration.}")) (|csubst| (((|Mapping| (|Stream| |#3|) |#3|) (|List| |#2|) (|List| (|Stream| |#3|))) "\\spad{csubst(a,b)} is for internal use only")) (* (($ |#3| $) "\\spad{smp*ts} multiplies a TaylorSeries by a monomial SMP.")) (|coerce| (($ |#3|) "\\spad{coerce(poly)} regroups the terms by total degree and forms a series.") (($ |#2|) "\\spad{coerce(var)} converts a variable to a Taylor series")) (|coefficient| ((|#3| $ (|NonNegativeInteger|)) "\\spad{coefficient(s, n)} gives the terms of total degree \\spad{n}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-((|HasCategory| |#1| (QUOTE (|Algebra| (|Fraction| (|Integer|))))) #1=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (OR #1# #2=(|HasCategory| |#1| (QUOTE (|IntegralDomain|)))) #2# (|HasCategory| |#1| (QUOTE (|Field|)))) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|))) 
+((|HasCategory| |#1| (QUOTE (|Algebra| (|Fraction| (|Integer|))))) #1=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #2# #1#) (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|Field|)))) 
 (|SquareFreeNormalizedTriangularSetCategory| R E V P) 
 ((|constructor| (NIL "The category of square-free and normalized triangular sets. Thus,{} up to the primitivity axiom of [1],{} these sets are Lazard triangular sets.\\newline References : \\indented{1}{[1] \\spad{D}. LAZARD \"A new method for solving algebraic systems of} \\indented{5}{positive dimension\" Discr. App. Math. 33:147-160,{}1991}"))) 
 NIL 
@@ -4137,7 +4137,7 @@ NIL
 NIL 
 NIL 
 (|ThreeSpaceCategory| R) 
-((|constructor| (NIL "The category ThreeSpaceCategory is used for creating three dimensional objects using functions for defining points,{} curves,{} polygons,{} constructs and the subspaces containing them.")) (|coerce| (((|OutputForm|) $) "\\spad{coerce(s)} returns the \\spadtype{ThreeSpace} \\spad{s} to Output format.")) (|subspace| (((|SubSpace| 3 |#1|) $) "\\spad{subspace(s)} returns the \\spadtype{SubSpace} which holds all the point information in the \\spadtype{ThreeSpace},{} \\spad{s}.")) (|check| (($ $) "\\spad{check(s)} returns lllpt,{} list of lists of lists of point information about the \\spadtype{ThreeSpace} \\spad{s}.")) (|objects| (((|Record| (|:| |points| (|NonNegativeInteger|)) (|:| |curves| (|NonNegativeInteger|)) (|:| |polygons| (|NonNegativeInteger|)) (|:| |constructs| (|NonNegativeInteger|))) $) "\\spad{objects(s)} returns the \\spadtype{ThreeSpace},{} \\spad{s},{} in the form of a 3D object record containing information on the number of points,{} curves,{} polygons and constructs comprising the \\spadtype{ThreeSpace}..")) (|lprop| (((|List| (|SubSpaceComponentProperty|)) $) "\\spad{lprop(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a list of subspace component properties,{} and if so,{} returns the list; An error is signaled otherwise.")) (|llprop| (((|List| (|List| (|SubSpaceComponentProperty|))) $) "\\spad{llprop(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a list of curves which are lists of the subspace component properties of the curves,{} and if so,{} returns the list of lists; An error is signaled otherwise.")) (|lllp| (((|List| (|List| (|List| (|Point| |#1|)))) $) "\\spad{lllp(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a list of components,{} which are lists of curves,{} which are lists of points,{} and if so,{} returns the list of lists of lists; An error is signaled otherwise.")) (|lllip| (((|List| (|List| (|List| (|NonNegativeInteger|)))) $) "\\spad{lllip(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a list of components,{} which are lists of curves,{} which are lists of indices to points,{} and if so,{} returns the list of lists of lists; An error is signaled otherwise.")) (|lp| (((|List| (|Point| |#1|)) $) "\\spad{lp(s)} returns the list of points component which the \\spadtype{ThreeSpace},{} \\spad{s},{} contains; these points are used by reference,{} \\spadignore{i.e.} the component holds indices referring to the points rather than the points themselves. This allows for sharing of the points.")) (|mesh?| (((|Boolean|) $) "\\spad{mesh?(s)} returns \\spad{true} if the \\spadtype{ThreeSpace} \\spad{s} is composed of one component,{} a mesh comprising a list of curves which are lists of points,{} or returns \\spad{false} if otherwise")) (|mesh| (((|List| (|List| (|Point| |#1|))) $) "\\spad{mesh(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a single surface component defined by a list curves which contain lists of points,{} and if so,{} returns the list of lists of points; An error is signaled otherwise.") (($ (|List| (|List| (|Point| |#1|))) (|Boolean|) (|Boolean|)) "\\spad{mesh([[p0],[p1],...,[pn]], close1, close2)} creates a surface defined over a list of curves,{} \\spad{p0} through pn,{} which are lists of points; the booleans \\spad{close1} and \\spad{close2} indicate how the surface is to be closed: \\spad{close1} set to \\spad{true} means that each individual list (a curve) is to be closed (that is,{} the last point of the list is to be connected to the first point); \\spad{close2} set to \\spad{true} means that the boundary at one end of the surface is to be connected to the boundary at the other end (the boundaries are defined as the first list of points (curve) and the last list of points (curve)); the \\spadtype{ThreeSpace} containing this surface is returned.") (($ (|List| (|List| (|Point| |#1|)))) "\\spad{mesh([[p0],[p1],...,[pn]])} creates a surface defined by a list of curves which are lists,{} \\spad{p0} through pn,{} of points,{} and returns a \\spadtype{ThreeSpace} whose component is the surface.") (($ $ (|List| (|List| (|List| |#1|))) (|Boolean|) (|Boolean|)) "\\spad{mesh(s,[ [[r10]...,[r1m]], [[r20]...,[r2m]],..., [[rn0]...,[rnm]] ], close1, close2)} adds a surface component to the \\spadtype{ThreeSpace} \\spad{s},{} which is defined over a rectangular domain of size WxH where \\spad{W} is the number of lists of points from the domain \\spad{PointDomain(R)} and \\spad{H} is the number of elements in each of those lists; the booleans \\spad{close1} and \\spad{close2} indicate how the surface is to be closed: if \\spad{close1} is \\spad{true} this means that each individual list (a curve) is to be closed (\\spadignore{i.e.} the last point of the list is to be connected to the first point); if \\spad{close2} is \\spad{true},{} this means that the boundary at one end of the surface is to be connected to the boundary at the other end (the boundaries are defined as the first list of points (curve) and the last list of points (curve)).") (($ $ (|List| (|List| (|Point| |#1|))) (|Boolean|) (|Boolean|)) "\\spad{mesh(s,[[p0],[p1],...,[pn]], close1, close2)} adds a surface component to the \\spadtype{ThreeSpace},{} which is defined over a list of curves,{} in which each of these curves is a list of points. The boolean arguments \\spad{close1} and \\spad{close2} indicate how the surface is to be closed. Argument \\spad{close1} equal \\spad{true} means that each individual list (a curve) is to be closed,{} \\spadignore{i.e.} the last point of the list is to be connected to the first point. Argument \\spad{close2} equal \\spad{true} means that the boundary at one end of the surface is to be connected to the boundary at the other end,{} \\spadignore{i.e.} the boundaries are defined as the first list of points (curve) and the last list of points (curve).") (($ $ (|List| (|List| (|List| |#1|))) (|List| (|SubSpaceComponentProperty|)) (|SubSpaceComponentProperty|)) "\\spad{mesh(s,[ [[r10]...,[r1m]], [[r20]...,[r2m]],..., [[rn0]...,[rnm]] ], [props], prop)} adds a surface component to the \\spadtype{ThreeSpace} \\spad{s},{} which is defined over a rectangular domain of size WxH where \\spad{W} is the number of lists of points from the domain \\spad{PointDomain(R)} and \\spad{H} is the number of elements in each of those lists; lprops is the list of the subspace component properties for each curve list,{} and prop is the subspace component property by which the points are defined.") (($ $ (|List| (|List| (|Point| |#1|))) (|List| (|SubSpaceComponentProperty|)) (|SubSpaceComponentProperty|)) "\\spad{mesh(s,[[p0],[p1],...,[pn]],[props],prop)} adds a surface component,{} defined over a list curves which contains lists of points,{} to the \\spadtype{ThreeSpace} \\spad{s}; props is a list which contains the subspace component properties for each surface parameter,{} and \\spad{prop} is the subspace component property by which the points are defined.")) (|polygon?| (((|Boolean|) $) "\\spad{polygon?(s)} returns \\spad{true} if the \\spadtype{ThreeSpace} \\spad{s} contains a single polygon component,{} or \\spad{false} otherwise.")) (|polygon| (((|List| (|Point| |#1|)) $) "\\spad{polygon(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a single polygon component defined by a list of points,{} and if so,{} returns the list of points; An error is signaled otherwise.") (($ (|List| (|Point| |#1|))) "\\spad{polygon([p0,p1,...,pn])} creates a polygon defined by a list of points,{} \\spad{p0} through pn,{} and returns a \\spadtype{ThreeSpace} whose component is the polygon.") (($ $ (|List| (|List| |#1|))) "\\spad{polygon(s,[[r0],[r1],...,[rn]])} adds a polygon component defined by a list of points \\spad{r0} through \\spad{rn},{} which are lists of elements from the domain \\spad{PointDomain(m,R)} to the \\spadtype{ThreeSpace} \\spad{s},{} where \\spad{m} is the dimension of the points and \\spad{R} is the \\spadtype{Ring} over which the points are defined.") (($ $ (|List| (|Point| |#1|))) "\\spad{polygon(s,[p0,p1,...,pn])} adds a polygon component defined by a list of points,{} \\spad{p0} throught pn,{} to the \\spadtype{ThreeSpace} \\spad{s}.")) (|closedCurve?| (((|Boolean|) $) "\\spad{closedCurve?(s)} returns \\spad{true} if the \\spadtype{ThreeSpace} \\spad{s} contains a single closed curve component,{} \\spadignore{i.e.} the first element of the curve is also the last element,{} or \\spad{false} otherwise.")) (|closedCurve| (((|List| (|Point| |#1|)) $) "\\spad{closedCurve(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a single closed curve component defined by a list of points in which the first point is also the last point,{} all of which are from the domain \\spad{PointDomain(m,R)} and if so,{} returns the list of points. An error is signaled otherwise.") (($ (|List| (|Point| |#1|))) "\\spad{closedCurve(lp)} sets a list of points defined by the first element of \\spad{lp} through the last element of \\spad{lp} and back to the first elelment again and returns a \\spadtype{ThreeSpace} whose component is the closed curve defined by \\spad{lp}.") (($ $ (|List| (|List| |#1|))) "\\spad{closedCurve(s,[[lr0],[lr1],...,[lrn],[lr0]])} adds a closed curve component defined by a list of points \\spad{lr0} through \\spad{lrn},{} which are lists of elements from the domain \\spad{PointDomain(m,R)},{} where \\spad{R} is the \\spadtype{Ring} over which the point elements are defined and \\spad{m} is the dimension of the points,{} in which the last element of the list of points contains a copy of the first element list,{} \\spad{lr0}. The closed curve is added to the \\spadtype{ThreeSpace},{} \\spad{s}.") (($ $ (|List| (|Point| |#1|))) "\\spad{closedCurve(s,[p0,p1,...,pn,p0])} adds a closed curve component which is a list of points defined by the first element \\spad{p0} through the last element \\spad{pn} and back to the first element \\spad{p0} again,{} to the \\spadtype{ThreeSpace} \\spad{s}.")) (|curve?| (((|Boolean|) $) "\\spad{curve?(s)} queries whether the \\spadtype{ThreeSpace},{} \\spad{s},{} is a curve,{} \\spadignore{i.e.} has one component,{} a list of list of points,{} and returns \\spad{true} if it is,{} or \\spad{false} otherwise.")) (|curve| (((|List| (|Point| |#1|)) $) "\\spad{curve(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a single curve defined by a list of points and if so,{} returns the curve,{} \\spadignore{i.e.} list of points. An error is signaled otherwise.") (($ (|List| (|Point| |#1|))) "\\spad{curve([p0,p1,p2,...,pn])} creates a space curve defined by the list of points \\spad{p0} through \\spad{pn},{} and returns the \\spadtype{ThreeSpace} whose component is the curve.") (($ $ (|List| (|List| |#1|))) "\\spad{curve(s,[[p0],[p1],...,[pn]])} adds a space curve which is a list of points \\spad{p0} through pn defined by lists of elements from the domain \\spad{PointDomain(m,R)},{} where \\spad{R} is the \\spadtype{Ring} over which the point elements are defined and \\spad{m} is the dimension of the points,{} to the \\spadtype{ThreeSpace} \\spad{s}.") (($ $ (|List| (|Point| |#1|))) "\\spad{curve(s,[p0,p1,...,pn])} adds a space curve component defined by a list of points \\spad{p0} through \\spad{pn},{} to the \\spadtype{ThreeSpace} \\spad{s}.")) (|point?| (((|Boolean|) $) "\\spad{point?(s)} queries whether the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a single component which is a point and returns the boolean result.")) (|point| (((|Point| |#1|) $) "\\spad{point(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of only a single point and if so,{} returns the point. An error is signaled otherwise.") (($ (|Point| |#1|)) "\\spad{point(p)} returns a \\spadtype{ThreeSpace} object which is composed of one component,{} the point \\spad{p}.") (($ $ (|NonNegativeInteger|)) "\\spad{point(s,i)} adds a point component which is placed into a component list of the \\spadtype{ThreeSpace},{} \\spad{s},{} at the index given by \\spad{i}.") (($ $ (|List| |#1|)) "\\spad{point(s,[x,y,z])} adds a point component defined by a list of elements which are from the \\spad{PointDomain(R)} to the \\spadtype{ThreeSpace},{} \\spad{s},{} where \\spad{R} is the \\spadtype{Ring} over which the point elements are defined.") (($ $ (|Point| |#1|)) "\\spad{point(s,p)} adds a point component defined by the point,{} \\spad{p},{} specified as a list from \\spad{List(R)},{} to the \\spadtype{ThreeSpace},{} \\spad{s},{} where \\spad{R} is the \\spadtype{Ring} over which the point is defined.")) (|modifyPointData| (($ $ (|NonNegativeInteger|) (|Point| |#1|)) "\\spad{modifyPointData(s,i,p)} changes the point at the indexed location \\spad{i} in the \\spadtype{ThreeSpace},{} \\spad{s},{} to that of point \\spad{p}. This is useful for making changes to a point which has been transformed.")) (|enterPointData| (((|NonNegativeInteger|) $ (|List| (|Point| |#1|))) "\\spad{enterPointData(s,[p0,p1,...,pn])} adds a list of points from \\spad{p0} through pn to the \\spadtype{ThreeSpace},{} \\spad{s},{} and returns the index,{} to the starting point of the list.")) (|copy| (($ $) "\\spad{copy(s)} returns a new \\spadtype{ThreeSpace} that is an exact copy of \\spad{s}.")) (|composites| (((|List| $) $) "\\spad{composites(s)} takes the \\spadtype{ThreeSpace} \\spad{s},{} and creates a list containing a unique \\spadtype{ThreeSpace} for each single composite of \\spad{s}. If \\spad{s} has no composites defined (composites need to be explicitly created),{} the list returned is empty. Note that not all the components need to be part of a composite.")) (|components| (((|List| $) $) "\\spad{components(s)} takes the \\spadtype{ThreeSpace} \\spad{s},{} and creates a list containing a unique \\spadtype{ThreeSpace} for each single component of \\spad{s}. If \\spad{s} has no components defined,{} the list returned is empty.")) (|composite| (($ (|List| $)) "\\spad{composite([s1,s2,...,sn])} will create a new \\spadtype{ThreeSpace} that is a union of all the components from each \\spadtype{ThreeSpace} in the parameter list,{} grouped as a composite.")) (|merge| (($ $ $) "\\spad{merge(s1,s2)} will create a new \\spadtype{ThreeSpace} that has the components of \\spad{s1} and \\spad{s2}; Groupings of components into composites are maintained.") (($ (|List| $)) "\\spad{merge([s1,s2,...,sn])} will create a new \\spadtype{ThreeSpace} that has the components of all the ones in the list; Groupings of components into composites are maintained.")) (|numberOfComposites| (((|NonNegativeInteger|) $) "\\spad{numberOfComposites(s)} returns the number of supercomponents,{} or composites,{} in the \\spadtype{ThreeSpace},{} \\spad{s}; Composites are arbitrary groupings of otherwise distinct and unrelated components; A \\spadtype{ThreeSpace} need not have any composites defined at all and,{} outside of the requirement that no component can belong to more than one composite at a time,{} the definition and interpretation of composites are unrestricted.")) (|numberOfComponents| (((|NonNegativeInteger|) $) "\\spad{numberOfComponents(s)} returns the number of distinct object components in the indicated \\spadtype{ThreeSpace},{} \\spad{s},{} such as points,{} curves,{} polygons,{} and constructs.")) (|create3Space| (($ (|SubSpace| 3 |#1|)) "\\spad{create3Space(s)} creates a \\spadtype{ThreeSpace} object containing objects pre-defined within some \\spadtype{SubSpace} \\spad{s}.") (($) "\\spad{create3Space()} creates a \\spadtype{ThreeSpace} object capable of holding point,{} curve,{} mesh components and any combination."))) 
+((|constructor| (NIL "The category ThreeSpaceCategory is used for creating three dimensional objects using functions for defining points,{} curves,{} polygons,{} constructs and the subspaces containing them.")) (|subspace| (((|SubSpace| 3 |#1|) $) "\\spad{subspace(s)} returns the \\spadtype{SubSpace} which holds all the point information in the \\spadtype{ThreeSpace},{} \\spad{s}.")) (|check| (($ $) "\\spad{check(s)} returns lllpt,{} list of lists of lists of point information about the \\spadtype{ThreeSpace} \\spad{s}.")) (|objects| (((|Record| (|:| |points| (|NonNegativeInteger|)) (|:| |curves| (|NonNegativeInteger|)) (|:| |polygons| (|NonNegativeInteger|)) (|:| |constructs| (|NonNegativeInteger|))) $) "\\spad{objects(s)} returns the \\spadtype{ThreeSpace},{} \\spad{s},{} in the form of a 3D object record containing information on the number of points,{} curves,{} polygons and constructs comprising the \\spadtype{ThreeSpace}..")) (|lprop| (((|List| (|SubSpaceComponentProperty|)) $) "\\spad{lprop(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a list of subspace component properties,{} and if so,{} returns the list; An error is signaled otherwise.")) (|llprop| (((|List| (|List| (|SubSpaceComponentProperty|))) $) "\\spad{llprop(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a list of curves which are lists of the subspace component properties of the curves,{} and if so,{} returns the list of lists; An error is signaled otherwise.")) (|lllp| (((|List| (|List| (|List| (|Point| |#1|)))) $) "\\spad{lllp(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a list of components,{} which are lists of curves,{} which are lists of points,{} and if so,{} returns the list of lists of lists; An error is signaled otherwise.")) (|lllip| (((|List| (|List| (|List| (|NonNegativeInteger|)))) $) "\\spad{lllip(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a list of components,{} which are lists of curves,{} which are lists of indices to points,{} and if so,{} returns the list of lists of lists; An error is signaled otherwise.")) (|lp| (((|List| (|Point| |#1|)) $) "\\spad{lp(s)} returns the list of points component which the \\spadtype{ThreeSpace},{} \\spad{s},{} contains; these points are used by reference,{} \\spadignore{i.e.} the component holds indices referring to the points rather than the points themselves. This allows for sharing of the points.")) (|mesh?| (((|Boolean|) $) "\\spad{mesh?(s)} returns \\spad{true} if the \\spadtype{ThreeSpace} \\spad{s} is composed of one component,{} a mesh comprising a list of curves which are lists of points,{} or returns \\spad{false} if otherwise")) (|mesh| (((|List| (|List| (|Point| |#1|))) $) "\\spad{mesh(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a single surface component defined by a list curves which contain lists of points,{} and if so,{} returns the list of lists of points; An error is signaled otherwise.") (($ (|List| (|List| (|Point| |#1|))) (|Boolean|) (|Boolean|)) "\\spad{mesh([[p0],[p1],...,[pn]], close1, close2)} creates a surface defined over a list of curves,{} \\spad{p0} through pn,{} which are lists of points; the booleans \\spad{close1} and \\spad{close2} indicate how the surface is to be closed: \\spad{close1} set to \\spad{true} means that each individual list (a curve) is to be closed (that is,{} the last point of the list is to be connected to the first point); \\spad{close2} set to \\spad{true} means that the boundary at one end of the surface is to be connected to the boundary at the other end (the boundaries are defined as the first list of points (curve) and the last list of points (curve)); the \\spadtype{ThreeSpace} containing this surface is returned.") (($ (|List| (|List| (|Point| |#1|)))) "\\spad{mesh([[p0],[p1],...,[pn]])} creates a surface defined by a list of curves which are lists,{} \\spad{p0} through pn,{} of points,{} and returns a \\spadtype{ThreeSpace} whose component is the surface.") (($ $ (|List| (|List| (|List| |#1|))) (|Boolean|) (|Boolean|)) "\\spad{mesh(s,[ [[r10]...,[r1m]], [[r20]...,[r2m]],..., [[rn0]...,[rnm]] ], close1, close2)} adds a surface component to the \\spadtype{ThreeSpace} \\spad{s},{} which is defined over a rectangular domain of size WxH where \\spad{W} is the number of lists of points from the domain \\spad{PointDomain(R)} and \\spad{H} is the number of elements in each of those lists; the booleans \\spad{close1} and \\spad{close2} indicate how the surface is to be closed: if \\spad{close1} is \\spad{true} this means that each individual list (a curve) is to be closed (\\spadignore{i.e.} the last point of the list is to be connected to the first point); if \\spad{close2} is \\spad{true},{} this means that the boundary at one end of the surface is to be connected to the boundary at the other end (the boundaries are defined as the first list of points (curve) and the last list of points (curve)).") (($ $ (|List| (|List| (|Point| |#1|))) (|Boolean|) (|Boolean|)) "\\spad{mesh(s,[[p0],[p1],...,[pn]], close1, close2)} adds a surface component to the \\spadtype{ThreeSpace},{} which is defined over a list of curves,{} in which each of these curves is a list of points. The boolean arguments \\spad{close1} and \\spad{close2} indicate how the surface is to be closed. Argument \\spad{close1} equal \\spad{true} means that each individual list (a curve) is to be closed,{} \\spadignore{i.e.} the last point of the list is to be connected to the first point. Argument \\spad{close2} equal \\spad{true} means that the boundary at one end of the surface is to be connected to the boundary at the other end,{} \\spadignore{i.e.} the boundaries are defined as the first list of points (curve) and the last list of points (curve).") (($ $ (|List| (|List| (|List| |#1|))) (|List| (|SubSpaceComponentProperty|)) (|SubSpaceComponentProperty|)) "\\spad{mesh(s,[ [[r10]...,[r1m]], [[r20]...,[r2m]],..., [[rn0]...,[rnm]] ], [props], prop)} adds a surface component to the \\spadtype{ThreeSpace} \\spad{s},{} which is defined over a rectangular domain of size WxH where \\spad{W} is the number of lists of points from the domain \\spad{PointDomain(R)} and \\spad{H} is the number of elements in each of those lists; lprops is the list of the subspace component properties for each curve list,{} and prop is the subspace component property by which the points are defined.") (($ $ (|List| (|List| (|Point| |#1|))) (|List| (|SubSpaceComponentProperty|)) (|SubSpaceComponentProperty|)) "\\spad{mesh(s,[[p0],[p1],...,[pn]],[props],prop)} adds a surface component,{} defined over a list curves which contains lists of points,{} to the \\spadtype{ThreeSpace} \\spad{s}; props is a list which contains the subspace component properties for each surface parameter,{} and \\spad{prop} is the subspace component property by which the points are defined.")) (|polygon?| (((|Boolean|) $) "\\spad{polygon?(s)} returns \\spad{true} if the \\spadtype{ThreeSpace} \\spad{s} contains a single polygon component,{} or \\spad{false} otherwise.")) (|polygon| (((|List| (|Point| |#1|)) $) "\\spad{polygon(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a single polygon component defined by a list of points,{} and if so,{} returns the list of points; An error is signaled otherwise.") (($ (|List| (|Point| |#1|))) "\\spad{polygon([p0,p1,...,pn])} creates a polygon defined by a list of points,{} \\spad{p0} through pn,{} and returns a \\spadtype{ThreeSpace} whose component is the polygon.") (($ $ (|List| (|List| |#1|))) "\\spad{polygon(s,[[r0],[r1],...,[rn]])} adds a polygon component defined by a list of points \\spad{r0} through \\spad{rn},{} which are lists of elements from the domain \\spad{PointDomain(m,R)} to the \\spadtype{ThreeSpace} \\spad{s},{} where \\spad{m} is the dimension of the points and \\spad{R} is the \\spadtype{Ring} over which the points are defined.") (($ $ (|List| (|Point| |#1|))) "\\spad{polygon(s,[p0,p1,...,pn])} adds a polygon component defined by a list of points,{} \\spad{p0} throught pn,{} to the \\spadtype{ThreeSpace} \\spad{s}.")) (|closedCurve?| (((|Boolean|) $) "\\spad{closedCurve?(s)} returns \\spad{true} if the \\spadtype{ThreeSpace} \\spad{s} contains a single closed curve component,{} \\spadignore{i.e.} the first element of the curve is also the last element,{} or \\spad{false} otherwise.")) (|closedCurve| (((|List| (|Point| |#1|)) $) "\\spad{closedCurve(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a single closed curve component defined by a list of points in which the first point is also the last point,{} all of which are from the domain \\spad{PointDomain(m,R)} and if so,{} returns the list of points. An error is signaled otherwise.") (($ (|List| (|Point| |#1|))) "\\spad{closedCurve(lp)} sets a list of points defined by the first element of \\spad{lp} through the last element of \\spad{lp} and back to the first elelment again and returns a \\spadtype{ThreeSpace} whose component is the closed curve defined by \\spad{lp}.") (($ $ (|List| (|List| |#1|))) "\\spad{closedCurve(s,[[lr0],[lr1],...,[lrn],[lr0]])} adds a closed curve component defined by a list of points \\spad{lr0} through \\spad{lrn},{} which are lists of elements from the domain \\spad{PointDomain(m,R)},{} where \\spad{R} is the \\spadtype{Ring} over which the point elements are defined and \\spad{m} is the dimension of the points,{} in which the last element of the list of points contains a copy of the first element list,{} \\spad{lr0}. The closed curve is added to the \\spadtype{ThreeSpace},{} \\spad{s}.") (($ $ (|List| (|Point| |#1|))) "\\spad{closedCurve(s,[p0,p1,...,pn,p0])} adds a closed curve component which is a list of points defined by the first element \\spad{p0} through the last element \\spad{pn} and back to the first element \\spad{p0} again,{} to the \\spadtype{ThreeSpace} \\spad{s}.")) (|curve?| (((|Boolean|) $) "\\spad{curve?(s)} queries whether the \\spadtype{ThreeSpace},{} \\spad{s},{} is a curve,{} \\spadignore{i.e.} has one component,{} a list of list of points,{} and returns \\spad{true} if it is,{} or \\spad{false} otherwise.")) (|curve| (((|List| (|Point| |#1|)) $) "\\spad{curve(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a single curve defined by a list of points and if so,{} returns the curve,{} \\spadignore{i.e.} list of points. An error is signaled otherwise.") (($ (|List| (|Point| |#1|))) "\\spad{curve([p0,p1,p2,...,pn])} creates a space curve defined by the list of points \\spad{p0} through \\spad{pn},{} and returns the \\spadtype{ThreeSpace} whose component is the curve.") (($ $ (|List| (|List| |#1|))) "\\spad{curve(s,[[p0],[p1],...,[pn]])} adds a space curve which is a list of points \\spad{p0} through pn defined by lists of elements from the domain \\spad{PointDomain(m,R)},{} where \\spad{R} is the \\spadtype{Ring} over which the point elements are defined and \\spad{m} is the dimension of the points,{} to the \\spadtype{ThreeSpace} \\spad{s}.") (($ $ (|List| (|Point| |#1|))) "\\spad{curve(s,[p0,p1,...,pn])} adds a space curve component defined by a list of points \\spad{p0} through \\spad{pn},{} to the \\spadtype{ThreeSpace} \\spad{s}.")) (|point?| (((|Boolean|) $) "\\spad{point?(s)} queries whether the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of a single component which is a point and returns the boolean result.")) (|point| (((|Point| |#1|) $) "\\spad{point(s)} checks to see if the \\spadtype{ThreeSpace},{} \\spad{s},{} is composed of only a single point and if so,{} returns the point. An error is signaled otherwise.") (($ (|Point| |#1|)) "\\spad{point(p)} returns a \\spadtype{ThreeSpace} object which is composed of one component,{} the point \\spad{p}.") (($ $ (|NonNegativeInteger|)) "\\spad{point(s,i)} adds a point component which is placed into a component list of the \\spadtype{ThreeSpace},{} \\spad{s},{} at the index given by \\spad{i}.") (($ $ (|List| |#1|)) "\\spad{point(s,[x,y,z])} adds a point component defined by a list of elements which are from the \\spad{PointDomain(R)} to the \\spadtype{ThreeSpace},{} \\spad{s},{} where \\spad{R} is the \\spadtype{Ring} over which the point elements are defined.") (($ $ (|Point| |#1|)) "\\spad{point(s,p)} adds a point component defined by the point,{} \\spad{p},{} specified as a list from \\spad{List(R)},{} to the \\spadtype{ThreeSpace},{} \\spad{s},{} where \\spad{R} is the \\spadtype{Ring} over which the point is defined.")) (|modifyPointData| (($ $ (|NonNegativeInteger|) (|Point| |#1|)) "\\spad{modifyPointData(s,i,p)} changes the point at the indexed location \\spad{i} in the \\spadtype{ThreeSpace},{} \\spad{s},{} to that of point \\spad{p}. This is useful for making changes to a point which has been transformed.")) (|enterPointData| (((|NonNegativeInteger|) $ (|List| (|Point| |#1|))) "\\spad{enterPointData(s,[p0,p1,...,pn])} adds a list of points from \\spad{p0} through pn to the \\spadtype{ThreeSpace},{} \\spad{s},{} and returns the index,{} to the starting point of the list.")) (|copy| (($ $) "\\spad{copy(s)} returns a new \\spadtype{ThreeSpace} that is an exact copy of \\spad{s}.")) (|composites| (((|List| $) $) "\\spad{composites(s)} takes the \\spadtype{ThreeSpace} \\spad{s},{} and creates a list containing a unique \\spadtype{ThreeSpace} for each single composite of \\spad{s}. If \\spad{s} has no composites defined (composites need to be explicitly created),{} the list returned is empty. Note that not all the components need to be part of a composite.")) (|components| (((|List| $) $) "\\spad{components(s)} takes the \\spadtype{ThreeSpace} \\spad{s},{} and creates a list containing a unique \\spadtype{ThreeSpace} for each single component of \\spad{s}. If \\spad{s} has no components defined,{} the list returned is empty.")) (|composite| (($ (|List| $)) "\\spad{composite([s1,s2,...,sn])} will create a new \\spadtype{ThreeSpace} that is a union of all the components from each \\spadtype{ThreeSpace} in the parameter list,{} grouped as a composite.")) (|merge| (($ $ $) "\\spad{merge(s1,s2)} will create a new \\spadtype{ThreeSpace} that has the components of \\spad{s1} and \\spad{s2}; Groupings of components into composites are maintained.") (($ (|List| $)) "\\spad{merge([s1,s2,...,sn])} will create a new \\spadtype{ThreeSpace} that has the components of all the ones in the list; Groupings of components into composites are maintained.")) (|numberOfComposites| (((|NonNegativeInteger|) $) "\\spad{numberOfComposites(s)} returns the number of supercomponents,{} or composites,{} in the \\spadtype{ThreeSpace},{} \\spad{s}; Composites are arbitrary groupings of otherwise distinct and unrelated components; A \\spadtype{ThreeSpace} need not have any composites defined at all and,{} outside of the requirement that no component can belong to more than one composite at a time,{} the definition and interpretation of composites are unrestricted.")) (|numberOfComponents| (((|NonNegativeInteger|) $) "\\spad{numberOfComponents(s)} returns the number of distinct object components in the indicated \\spadtype{ThreeSpace},{} \\spad{s},{} such as points,{} curves,{} polygons,{} and constructs.")) (|create3Space| (($ (|SubSpace| 3 |#1|)) "\\spad{create3Space(s)} creates a \\spadtype{ThreeSpace} object containing objects pre-defined within some \\spadtype{SubSpace} \\spad{s}.") (($) "\\spad{create3Space()} creates a \\spadtype{ThreeSpace} object capable of holding point,{} curve,{} mesh components and any combination."))) 
 NIL 
 NIL 
 (|SpadAst|) 
@@ -4169,9 +4169,9 @@ NIL
 NIL 
 ((AND (|HasCategory| #1=(|SplittingNode| |#1| |#2|) (|%list| (QUOTE |Evalable|) #2=(|%list| (QUOTE |SplittingNode|) (|devaluate| |#1|) (|devaluate| |#2|)))) #3=(|HasCategory| #1# (QUOTE (|SetCategory|)))) #3# (OR #4=(|HasCategory| #1# (QUOTE (|BasicType|))) #3#) (|HasCategory| #1# (QUOTE (|CoercibleTo| (|OutputForm|)))) #4# (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #2#))) 
 (|SquareMatrix| |ndim| R) 
-((|constructor| (NIL "\\spadtype{SquareMatrix} is a matrix domain of square matrices,{} where the number of rows (= number of columns) is a parameter of the type.")) (|unitsKnown| ((|attribute|) "the invertible matrices are simply the matrices whose determinants are units in the Ring \\spad{R}.")) (|central| ((|attribute|) "the elements of the Ring \\spad{R},{} viewed as diagonal matrices,{} commute with all matrices and,{} indeed,{} are the only matrices which commute with all matrices.")) (|squareMatrix| (($ (|Matrix| |#2|)) "\\spad{squareMatrix(m)} converts a matrix of type \\spadtype{Matrix} to a matrix of type \\spadtype{SquareMatrix}.")) (|transpose| (($ $) "\\spad{transpose(m)} returns the transpose of the matrix \\spad{m}.")) (|new| (($ |#2|) "\\spad{new(c)} constructs a new \\spadtype{SquareMatrix} object of dimension \\spad{ndim} with initial entries equal to \\spad{c}."))) 
-((|unitsKnown| . T) (|central| |has| |#2| (ATTRIBUTE (|commutative| "*"))) (|rightUnitary| . T) (|leftUnitary| . T)) 
-(#1=(|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #2=(|Symbol|)))) (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #2#))) #3=(|HasCategory| |#2| (QUOTE (|DifferentialRing|))) (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) #4=(|HasAttribute| |#2| (QUOTE (|commutative| "*"))) #5=(|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #6=(|Integer|)))) (|HasCategory| |#2| (QUOTE (|RetractableTo| (|Fraction| #6#)))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #6#))) (OR (AND #3# #7=(|HasCategory| |#2| (|%list| (QUOTE |Evalable|) (|devaluate| |#2|)))) (AND #5# #7#) (AND #1# #7#) #8=(AND #9=(|HasCategory| |#2| (QUOTE (|SetCategory|))) #7#)) (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#2| (QUOTE (|EuclideanDomain|))) (|HasCategory| |#2| (QUOTE (|IntegralDomain|))) (|HasCategory| |#2| (QUOTE (|Field|))) (OR #4# #3# #1#) (|HasCategory| |#2| (QUOTE (|CoercibleTo| (|OutputForm|)))) (|HasCategory| |#2| (QUOTE (|BasicType|))) #9# #8# (|HasCategory| |#2| (QUOTE (|CommutativeRing|)))) 
+((|constructor| (NIL "\\spadtype{SquareMatrix} is a matrix domain of square matrices,{} where the number of rows (= number of columns) is a parameter of the type.")) (|squareMatrix| (($ (|Matrix| |#2|)) "\\spad{squareMatrix(m)} converts a matrix of type \\spadtype{Matrix} to a matrix of type \\spadtype{SquareMatrix}.")) (|transpose| (($ $) "\\spad{transpose(m)} returns the transpose of the matrix \\spad{m}.")) (|new| (($ |#2|) "\\spad{new(c)} constructs a new \\spadtype{SquareMatrix} object of dimension \\spad{ndim} with initial entries equal to \\spad{c}."))) 
+NIL 
+(#1=(|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #2=(|Symbol|)))) (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #2#))) #3=(|HasCategory| |#2| (QUOTE (|DifferentialRing|))) (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) (|HasAttribute| |#2| (QUOTE (|commutative| "*"))) #4=(|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #5=(|Integer|)))) (|HasCategory| |#2| (QUOTE (|RetractableTo| (|Fraction| #5#)))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #5#))) (OR (AND #3# #6=(|HasCategory| |#2| (|%list| (QUOTE |Evalable|) (|devaluate| |#2|)))) (AND #4# #6#) (AND #1# #6#) #7=(AND #8=(|HasCategory| |#2| (QUOTE (|SetCategory|))) #6#)) (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| |#2| (QUOTE (|EuclideanDomain|))) (|HasCategory| |#2| (QUOTE (|IntegralDomain|))) (|HasCategory| |#2| (QUOTE (|Field|))) #7# #8# (|HasCategory| |#2| (QUOTE (|BasicType|))) (|HasCategory| |#2| (QUOTE (|CoercibleTo| (|OutputForm|)))) (|HasCategory| |#2| (QUOTE (|CommutativeRing|)))) 
 (|StringAggregate&| S) 
 ((|constructor| (NIL "A string aggregate is a category for strings,{} that is,{} one dimensional arrays of characters.")) (|elt| (($ $ $) "\\spad{elt(s,t)} returns the concatenation of \\spad{s} and \\spad{t}. It is provided to allow juxtaposition of strings to work as concatenation. For example,{} \\axiom{\"smoo\" \"shed\"} returns \\axiom{\"smooshed\"}.")) (|rightTrim| (($ $ (|CharacterClass|)) "\\spad{rightTrim(s,cc)} returns \\spad{s} with all trailing occurences of characters in \\spad{cc} deleted. For example,{} \\axiom{rightTrim(\"(abc)\",{} charClass \"()\")} returns \\axiom{\"(abc\"}.") (($ $ (|Character|)) "\\spad{rightTrim(s,c)} returns \\spad{s} with all trailing occurrences of \\spad{c} deleted. For example,{} \\axiom{rightTrim(\" abc \",{} char \" \")} returns \\axiom{\" abc\"}.")) (|leftTrim| (($ $ (|CharacterClass|)) "\\spad{leftTrim(s,cc)} returns \\spad{s} with all leading characters in \\spad{cc} deleted. For example,{} \\axiom{leftTrim(\"(abc)\",{} charClass \"()\")} returns \\axiom{\"abc)\"}.") (($ $ (|Character|)) "\\spad{leftTrim(s,c)} returns \\spad{s} with all leading characters \\spad{c} deleted. For example,{} \\axiom{leftTrim(\" abc \",{} char \" \")} returns \\axiom{\"abc \"}.")) (|trim| (($ $ (|CharacterClass|)) "\\spad{trim(s,cc)} returns \\spad{s} with all characters in \\spad{cc} deleted from right and left ends. For example,{} \\axiom{trim(\"(abc)\",{} charClass \"()\")} returns \\axiom{\"abc\"}.") (($ $ (|Character|)) "\\spad{trim(s,c)} returns \\spad{s} with all characters \\spad{c} deleted from right and left ends. For example,{} \\axiom{trim(\" abc \",{} char \" \")} returns \\axiom{\"abc\"}.")) (|split| (((|List| $) $ (|CharacterClass|)) "\\spad{split(s,cc)} returns a list of substrings delimited by characters in \\spad{cc}.") (((|List| $) $ (|Character|)) "\\spad{split(s,c)} returns a list of substrings delimited by character \\spad{c}.")) (|coerce| (($ (|Character|)) "\\spad{coerce(c)} returns \\spad{c} as a string \\spad{s} with the character \\spad{c}.")) (|position| (((|Integer|) (|CharacterClass|) $ (|Integer|)) "\\spad{position(cc,t,i)} returns the position \\axiom{\\spad{j} >= \\spad{i}} in \\spad{t} of the first character belonging to \\spad{cc}.") (((|Integer|) $ $ (|Integer|)) "\\spad{position(s,t,i)} returns the position \\spad{j} of the substring \\spad{s} in string \\spad{t},{} where \\axiom{\\spad{j} >= \\spad{i}} is required.")) (|replace| (($ $ (|UniversalSegment| (|Integer|)) $) "\\spad{replace(s,i..j,t)} replaces the substring \\axiom{\\spad{s}(\\spad{i}..\\spad{j})} of \\spad{s} by string \\spad{t}.")) (|match?| (((|Boolean|) $ $ (|Character|)) "\\spad{match?(s,t,c)} tests if \\spad{s} matches \\spad{t} except perhaps for multiple and consecutive occurrences of character \\spad{c}. Typically \\spad{c} is the blank character.")) (|match| (((|NonNegativeInteger|) $ $ (|Character|)) "\\spad{match(p,s,wc)} tests if pattern \\axiom{\\spad{p}} matches subject \\axiom{\\spad{s}} where \\axiom{\\spad{wc}} is a wild card character. If no match occurs,{} the index \\axiom{0} is returned; otheriwse,{} the value returned is the first index of the first character in the subject matching the subject (excluding that matched by an initial wild-card). For example,{} \\axiom{match(\"*to*\",{}\"yorktown\",{}\"*\")} returns \\axiom{5} indicating a successful match starting at index \\axiom{5} of \\axiom{\"yorktown\"}.")) (|substring?| (((|Boolean|) $ $ (|Integer|)) "\\spad{substring?(s,t,i)} tests if \\spad{s} is a substring of \\spad{t} beginning at index \\spad{i}. Note: \\axiom{substring?(\\spad{s},{}\\spad{t},{}0) = prefix?(\\spad{s},{}\\spad{t})}.")) (|suffix?| (((|Boolean|) $ $) "\\spad{suffix?(s,t)} tests if the string \\spad{s} is the final substring of \\spad{t}. Note: \\axiom{suffix?(\\spad{s},{}\\spad{t}) == reduce(and,{}[\\spad{s}.\\spad{i} = \\spad{t}.(\\spad{n} - \\spad{m} + \\spad{i}) for \\spad{i} in 0..maxIndex \\spad{s}])} where \\spad{m} and \\spad{n} denote the maxIndex of \\spad{s} and \\spad{t} respectively.")) (|prefix?| (((|Boolean|) $ $) "\\spad{prefix?(s,t)} tests if the string \\spad{s} is the initial substring of \\spad{t}. Note: \\axiom{prefix?(\\spad{s},{}\\spad{t}) == reduce(and,{}[\\spad{s}.\\spad{i} = \\spad{t}.\\spad{i} for \\spad{i} in 0..maxIndex \\spad{s}])}.")) (|upperCase!| (($ $) "\\spad{upperCase!(s)} destructively replaces the alphabetic characters in \\spad{s} by upper case characters.")) (|upperCase| (($ $) "\\spad{upperCase(s)} returns the string with all characters in upper case.")) (|lowerCase!| (($ $) "\\spad{lowerCase!(s)} destructively replaces the alphabetic characters in \\spad{s} by lower case.")) (|lowerCase| (($ $) "\\spad{lowerCase(s)} returns the string with all characters in lower case."))) 
 NIL 
@@ -4274,8 +4274,8 @@ NIL
 NIL 
 (|SparseUnivariateLaurentSeries| |Coef| |var| |cen|) 
 ((|constructor| (NIL "Sparse Laurent series in one variable \\indented{2}{\\spadtype{SparseUnivariateLaurentSeries} is a domain representing Laurent} \\indented{2}{series in one variable with coefficients in an arbitrary ring.\\space{2}The} \\indented{2}{parameters of the type specify the coefficient ring,{} the power series} \\indented{2}{variable,{} and the center of the power series expansion.\\space{2}For example,{}} \\indented{2}{\\spad{SparseUnivariateLaurentSeries(Integer,x,3)} represents Laurent} \\indented{2}{series in \\spad{(x - 3)} with integer coefficients.}")) (|integrate| (($ $ (|Variable| |#2|)) "\\spad{integrate(f(x))} returns an anti-derivative of the power series \\spad{f(x)} with constant coefficient 0. We may integrate a series when we can divide coefficients by integers.")) (|coerce| (($ (|Variable| |#2|)) "\\spad{coerce(var)} converts the series variable \\spad{var} into a Laurent series."))) 
-(((|commutative| "*") OR #1=(|and| #2=(|has| |#1| #3=(|Field|)) (|has| #4=(|SparseUnivariateTaylorSeries| |#1| |#2| |#3|) (|OrderedIntegralDomain|))) (|has| |#1| (|CommutativeRing|)) #5=(|and| #2# (|has| #4# (|PolynomialFactorizationExplicit|)))) (|noZeroDivisors| OR #1# (|has| |#1| (|IntegralDomain|)) #5#) (|canonicalUnitNormal| |has| |#1| . #6=(#3#)) (|canonicalsClosed| |has| |#1| . #6#) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| (QUOTE (|Algebra| (|Fraction| #2=(|Integer|))))) #3=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #4=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #4# #3#) (OR #5=(AND #6=(|HasCategory| |#1| (QUOTE (|Field|))) #7=(|HasCategory| #8=(|SparseUnivariateTaylorSeries| |#1| |#2| |#3|) #9=(QUOTE (|CharacteristicNonZero|)))) #10=(|HasCategory| |#1| #9#)) (OR #11=(AND #6# (|HasCategory| #8# (QUOTE (|OrderedIntegralDomain|)))) #12=(AND #6# (|HasCategory| #8# #13=(QUOTE (|CharacteristicZero|)))) #14=(|HasCategory| |#1| #13#)) (OR #15=(AND #6# (|HasCategory| #8# #16=(QUOTE (|PartialDifferentialRing| #17=(|Symbol|))))) #18=(AND (|HasCategory| |#1| #16#) #19=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #20=(|devaluate| |#1|) #21=(QUOTE #2#) #20#))))) (OR #15# #22=(AND #6# (|HasCategory| #8# (QUOTE (|PartialDifferentialSpace| #17#)))) #18#) (OR #23=(AND #6# (|HasCategory| #8# (QUOTE (|DifferentialRing|)))) #19#) (OR #23# #24=(AND #6# (|HasCategory| #8# (QUOTE (|DifferentialSpace|)))) #19#) (|HasCategory| #2# (QUOTE (|SemiGroup|))) (OR #6# #3#) #6# #25=(AND #6# #26=(|HasCategory| #8# (QUOTE (|PolynomialFactorizationExplicit|)))) (AND #6# (|HasCategory| #8# (QUOTE (|RetractableTo| #17#)))) (AND #6# (|HasCategory| #8# (QUOTE (|ConvertibleTo| (|InputForm|))))) (AND #6# (|HasCategory| #8# (QUOTE (|RealConstant|)))) (OR #4# #6# #3#) #11# (OR #11# #27=(AND #6# (|HasCategory| #8# (QUOTE (|OrderedSet|))))) (OR #28=(AND #6# (|HasCategory| #8# (QUOTE (|RetractableTo| #2#)))) #1#) #28# (AND #6# (|HasCategory| #8# (QUOTE (|StepThrough|)))) (AND #6# (|HasCategory| #8# (|%list| (QUOTE |Eltable|) #29=(|%list| (QUOTE |SparseUnivariateTaylorSeries|) #20# (|devaluate| |#2|) (|devaluate| |#3|)) #29#))) (AND #6# (|HasCategory| #8# (|%list| (QUOTE |Evalable|) #29#))) (AND #6# (|HasCategory| #8# (|%list| (QUOTE |InnerEvalable|) #30=(QUOTE #17#) #29#))) (AND #6# (|HasCategory| #8# (QUOTE (|LinearlyExplicitRingOver| #2#)))) (AND #6# (|HasCategory| #8# (QUOTE (|ConvertibleTo| (|Pattern| #2#))))) (AND #6# (|HasCategory| #8# (QUOTE (|ConvertibleTo| (|Pattern| #31=(|Float|)))))) (AND #6# (|HasCategory| #8# (QUOTE (|PatternMatchable| #2#)))) (AND #6# (|HasCategory| #8# (QUOTE (|PatternMatchable| #31#)))) (AND #32=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #20# #20# #21#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #20# #30#)))) #32# (OR (AND #1# (|HasCategory| |#1| (QUOTE (|AlgebraicallyClosedFunctionSpace| #2#))) (|HasCategory| |#1| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) (AND #1# (|HasSignature| |#1| (|%list| (QUOTE |integrate|) (|%list| #20# #20# #30#))) (|HasSignature| |#1| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #30#) #20#))))) (AND #6# (|HasCategory| #8# (QUOTE (|IntegerNumberSystem|)))) (AND #6# (|HasCategory| #8# (QUOTE (|EuclideanDomain|)))) #26# #7# #10# (OR #11# #25# #3#) (OR #11# #25# #4#) #22# #24# #27# (OR #12# #14#) #33=(AND #6# (|HasCategory| $ #9#) #26#) (OR #5# #33# #10#)) 
+(((|commutative| "*") OR #1=(|and| #2=(|has| |#1| #3=(|Field|)) (|has| #4=(|SparseUnivariateTaylorSeries| |#1| |#2| |#3|) (|OrderedIntegralDomain|))) (|has| |#1| (|CommutativeRing|)) #5=(|and| #2# (|has| #4# (|PolynomialFactorizationExplicit|)))) (|noZeroDivisors| OR #1# (|has| |#1| (|IntegralDomain|)) #5#) (|canonicalUnitNormal| |has| |#1| #3#)) 
+(#1=(|HasCategory| |#1| (QUOTE (|Algebra| (|Fraction| #2=(|Integer|))))) #3=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #4=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #4# #3#) (OR #5=(AND #6=(|HasCategory| |#1| (QUOTE (|Field|))) #7=(|HasCategory| #8=(|SparseUnivariateTaylorSeries| |#1| |#2| |#3|) #9=(QUOTE (|CharacteristicNonZero|)))) #10=(|HasCategory| |#1| #9#)) (OR #11=(AND #6# (|HasCategory| #8# (QUOTE (|OrderedIntegralDomain|)))) #12=(AND #6# (|HasCategory| #8# #13=(QUOTE (|CharacteristicZero|)))) #14=(|HasCategory| |#1| #13#)) (OR #15=(AND #6# (|HasCategory| #8# #16=(QUOTE (|PartialDifferentialRing| #17=(|Symbol|))))) #18=(AND (|HasCategory| |#1| #16#) #19=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #20=(|devaluate| |#1|) #21=(QUOTE #2#) #20#))))) (OR #15# #22=(AND #6# (|HasCategory| #8# (QUOTE (|PartialDifferentialSpace| #17#)))) #18#) (OR #23=(AND #6# (|HasCategory| #8# (QUOTE (|DifferentialRing|)))) #19#) (OR #23# #24=(AND #6# (|HasCategory| #8# (QUOTE (|DifferentialSpace|)))) #19#) (|HasCategory| #2# (QUOTE (|SemiGroup|))) (OR #6# #3#) #6# #25=(AND #6# #26=(|HasCategory| #8# (QUOTE (|PolynomialFactorizationExplicit|)))) (AND #6# (|HasCategory| #8# (QUOTE (|RetractableTo| #17#)))) (AND #6# (|HasCategory| #8# (QUOTE (|ConvertibleTo| (|InputForm|))))) (AND #6# (|HasCategory| #8# (QUOTE (|RealConstant|)))) (OR #4# #6# #3#) #11# (OR #11# #27=(AND #6# (|HasCategory| #8# (QUOTE (|OrderedSet|))))) (OR #28=(AND #6# (|HasCategory| #8# (QUOTE (|RetractableTo| #2#)))) #1#) #28# (AND #6# (|HasCategory| #8# (QUOTE (|StepThrough|)))) (AND #6# (|HasCategory| #8# (|%list| (QUOTE |Eltable|) #29=(|%list| (QUOTE |SparseUnivariateTaylorSeries|) #20# (|devaluate| |#2|) (|devaluate| |#3|)) #29#))) (AND #6# (|HasCategory| #8# (|%list| (QUOTE |Evalable|) #29#))) (AND #6# (|HasCategory| #8# (|%list| (QUOTE |InnerEvalable|) #30=(QUOTE #17#) #29#))) (AND #6# (|HasCategory| #8# (QUOTE (|LinearlyExplicitRingOver| #2#)))) (AND #6# (|HasCategory| #8# (QUOTE (|ConvertibleTo| (|Pattern| #2#))))) (AND #6# (|HasCategory| #8# (QUOTE (|ConvertibleTo| (|Pattern| #31=(|Float|)))))) (AND #6# (|HasCategory| #8# (QUOTE (|PatternMatchable| #2#)))) (AND #6# (|HasCategory| #8# (QUOTE (|PatternMatchable| #31#)))) (AND #32=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #20# #20# #21#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #20# #30#)))) #32# (OR (AND #1# (|HasCategory| |#1| (QUOTE (|AlgebraicallyClosedFunctionSpace| #2#))) (|HasCategory| |#1| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) (AND #1# (|HasSignature| |#1| (|%list| (QUOTE |integrate|) (|%list| #20# #20# #30#))) (|HasSignature| |#1| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #30#) #20#))))) (AND #6# (|HasCategory| #8# (QUOTE (|IntegerNumberSystem|)))) (AND #6# (|HasCategory| #8# (QUOTE (|EuclideanDomain|)))) #26# #7# #10# (OR #11# #25# #3#) (OR #11# #25# #4#) #24# #22# #27# (OR #12# #14#) #33=(AND #6# (|HasCategory| $ #9#) #26#) (OR #5# #33# #10#)) 
 (|FunctionSpaceSum| R F) 
 ((|constructor| (NIL "computes sums of top-level expressions.")) (|sum| ((|#2| |#2| (|SegmentBinding| |#2|)) "\\spad{sum(f(n), n = a..b)} returns \\spad{f}(a) + \\spad{f}(\\spad{a+1}) + ... + \\spad{f}(\\spad{b}).") ((|#2| |#2| (|Symbol|)) "\\spad{sum(a(n), n)} returns A(\\spad{n}) such that A(\\spad{n+1}) - A(\\spad{n}) = a(\\spad{n})."))) 
 NIL 
@@ -4286,8 +4286,8 @@ NIL
 NIL 
 (|SparseUnivariatePolynomial| R) 
 ((|constructor| (NIL "This domain represents univariate polynomials over arbitrary (not necessarily commutative) coefficient rings. The variable is unspecified so that the variable displays as \\spad{?} on output. If it is necessary to specify the variable name,{} use type \\spadtype{UnivariatePolynomial}. The representation is sparse in the sense that only non-zero terms are represented.")) (|fmecg| (($ $ (|NonNegativeInteger|) |#1| $) "\\spad{fmecg(p1,e,r,p2)} finds \\spad{X} : \\spad{p1} - \\spad{r} * X**e * \\spad{p2}")) (|outputForm| (((|OutputForm|) $ (|OutputForm|)) "\\spad{outputForm(p,var)} converts the SparseUnivariatePolynomial \\spad{p} to an output form (see \\spadtype{OutputForm}) printed as a polynomial in the output form variable."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|additiveValuation| |has| |#1| (|Field|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) #2=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #3=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #3# #2#) (AND (|HasCategory| |#1| #4=(QUOTE (|PatternMatchable| #5=(|Float|)))) (|HasCategory| #6=(|SingletonAsOrderedSet|) #4#)) (AND (|HasCategory| |#1| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| #6# #7#)) (AND (|HasCategory| |#1| #9=(QUOTE (|ConvertibleTo| (|Pattern| #5#)))) (|HasCategory| #6# #9#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #6# #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #6# #11#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #8#))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) #12=(|HasCategory| |#1| #13=(QUOTE (|CharacteristicNonZero|))) #14=(|HasCategory| |#1| (QUOTE (|Algebra| #15=(|Fraction| #8#)))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #8#))) (OR #14# #16=(|HasCategory| |#1| (QUOTE (|RetractableTo| #15#)))) #16# (OR #3# #17=(|HasCategory| |#1| (QUOTE (|Field|))) #18=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #2# #1#) (OR #17# #18# #2# #1#) (OR #17# #18# #1#) #17# (|HasCategory| |#1| (QUOTE (|StepThrough|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #19=(|Symbol|)))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #19#))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #18# #20=(AND #1# (|HasCategory| $ #13#)) (OR #20# #12#)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|additiveValuation| |has| |#1| (|Field|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#1| (QUOTE (|PolynomialFactorizationExplicit|))) #2=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #3=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #3# #2#) (AND (|HasCategory| |#1| #4=(QUOTE (|PatternMatchable| #5=(|Float|)))) (|HasCategory| #6=(|SingletonAsOrderedSet|) #4#)) (AND (|HasCategory| |#1| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| #6# #7#)) (AND (|HasCategory| |#1| #9=(QUOTE (|ConvertibleTo| (|Pattern| #5#)))) (|HasCategory| #6# #9#)) (AND (|HasCategory| |#1| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #6# #10#)) (AND (|HasCategory| |#1| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #6# #11#)) (|HasCategory| |#1| (QUOTE (|LinearlyExplicitRingOver| #8#))) #12=(|HasCategory| |#1| (QUOTE (|Algebra| #13=(|Fraction| #8#)))) #14=(|HasCategory| |#1| #15=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|RetractableTo| #8#))) (OR #12# #16=(|HasCategory| |#1| (QUOTE (|RetractableTo| #13#)))) #16# (OR #3# #17=(|HasCategory| |#1| (QUOTE (|Field|))) #18=(|HasCategory| |#1| (QUOTE (|GcdDomain|))) #2# #1#) (OR #17# #18# #2# #1#) (OR #17# #18# #1#) #17# (|HasCategory| |#1| (QUOTE (|StepThrough|))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialSpace| #19=(|Symbol|)))) (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #19#))) (|HasCategory| |#1| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#1| (QUOTE (|DifferentialRing|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) #18# #20=(AND #1# (|HasCategory| $ #15#)) (OR #20# #14#)) 
 (|SparseUnivariatePolynomialFunctions2| R S) 
 ((|constructor| (NIL "This package lifts a mapping from coefficient rings \\spad{R} to \\spad{S} to a mapping from sparse univariate polynomial over \\spad{R} to a sparse univariate polynomial over \\spad{S}. Note that the mapping is assumed to send zero to zero,{} since it will only be applied to the non-zero coefficients of the polynomial.")) (|map| (((|SparseUnivariatePolynomial| |#2|) (|Mapping| |#2| |#1|) (|SparseUnivariatePolynomial| |#1|)) "\\spad{map(func, poly)} creates a new polynomial by applying \\spad{func} to every non-zero coefficient of the polynomial poly."))) 
 NIL 
@@ -4298,11 +4298,11 @@ NIL
 NIL 
 (|SparseUnivariatePuiseuxSeries| |Coef| |var| |cen|) 
 ((|constructor| (NIL "Sparse Puiseux series in one variable \\indented{2}{\\spadtype{SparseUnivariatePuiseuxSeries} is a domain representing Puiseux} \\indented{2}{series in one variable with coefficients in an arbitrary ring.\\space{2}The} \\indented{2}{parameters of the type specify the coefficient ring,{} the power series} \\indented{2}{variable,{} and the center of the power series expansion.\\space{2}For example,{}} \\indented{2}{\\spad{SparseUnivariatePuiseuxSeries(Integer,x,3)} represents Puiseux} \\indented{2}{series in \\spad{(x - 3)} with \\spadtype{Integer} coefficients.}")) (|integrate| (($ $ (|Variable| |#2|)) "\\spad{integrate(f(x))} returns an anti-derivative of the power series \\spad{f(x)} with constant coefficient 0. We may integrate a series when we can divide coefficients by integers."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| . #1=((|Field|))) (|canonicalsClosed| |has| |#1| . #1#) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (|Field|))) 
 (#1=(|HasCategory| |#1| (QUOTE (|Algebra| #2=(|Fraction| #3=(|Integer|))))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #5=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #5# #4#) (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (AND (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #6=(|Symbol|)))) #7=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #8=(|devaluate| |#1|) #9=(|%list| (QUOTE |Fraction|) (QUOTE #3#)) #8#)))) #7# (|HasCategory| #2# (QUOTE (|SemiGroup|))) #10=(|HasCategory| |#1| (QUOTE (|Field|))) (OR #5# #10# #4#) (OR #10# #4#) (AND #11=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #8# #8# #9#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #8# #12=(QUOTE #6#))))) #11# (OR (AND #1# (|HasCategory| |#1| (QUOTE (|AlgebraicallyClosedFunctionSpace| #3#))) (|HasCategory| |#1| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) (AND #1# (|HasSignature| |#1| (|%list| (QUOTE |integrate|) (|%list| #8# #8# #12#))) (|HasSignature| |#1| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #12#) #8#)))))) 
 (|SparseUnivariateTaylorSeries| |Coef| |var| |cen|) 
 ((|constructor| (NIL "Sparse Taylor series in one variable \\indented{2}{\\spadtype{SparseUnivariateTaylorSeries} is a domain representing Taylor} \\indented{2}{series in one variable with coefficients in an arbitrary ring.\\space{2}The} \\indented{2}{parameters of the type specify the coefficient ring,{} the power series} \\indented{2}{variable,{} and the center of the power series expansion.\\space{2}For example,{}} \\indented{2}{\\spadtype{SparseUnivariateTaylorSeries}(Integer,{}\\spad{x},{}3) represents Taylor} \\indented{2}{series in \\spad{(x - 3)} with \\spadtype{Integer} coefficients.}")) (|integrate| (($ $ (|Variable| |#2|)) "\\spad{integrate(f(x),x)} returns an anti-derivative of the power series \\spad{f(x)} with constant coefficient 0. We may integrate a series when we can divide coefficients by integers.")) (|univariatePolynomial| (((|UnivariatePolynomial| |#2| |#1|) $ (|NonNegativeInteger|)) "\\spad{univariatePolynomial(f,k)} returns a univariate polynomial \\indented{1}{consisting of the sum of all terms of \\spad{f} of degree \\spad{<= k}.}")) (|coerce| (($ (|Variable| |#2|)) "\\spad{coerce(var)} converts the series variable \\spad{var} into a \\indented{1}{Taylor series.}") (($ (|UnivariatePolynomial| |#2| |#1|)) "\\spad{coerce(p)} converts a univariate polynomial \\spad{p} in the variable \\spad{var} to a univariate Taylor series in \\spad{var}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|))) 
 (#1=(|HasCategory| |#1| (QUOTE (|Algebra| (|Fraction| #2=(|Integer|))))) #3=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (OR #4=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3#) #4# (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (AND (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #5=(|Symbol|)))) #6=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #7=(|devaluate| |#1|) #8=(QUOTE #9=(|NonNegativeInteger|)) #7#)))) #6# (|HasCategory| #9# (QUOTE (|SemiGroup|))) (AND #10=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #7# #7# #8#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #7# #11=(QUOTE #5#))))) #10# (|HasCategory| |#1| (QUOTE (|Field|))) (OR (AND #1# (|HasCategory| |#1| (QUOTE (|AlgebraicallyClosedFunctionSpace| #2#))) (|HasCategory| |#1| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) (AND #1# (|HasSignature| |#1| (|%list| (QUOTE |integrate|) (|%list| #7# #7# #11#))) (|HasSignature| |#1| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #11#) #7#)))))) 
 (|Symbol|) 
 ((|constructor| (NIL "Basic and scripted symbols.")) (|sample| (($) "\\spad{sample()} returns a sample of \\%")) (|list| (((|List| $) $) "\\spad{list(sy)} takes a scripted symbol and produces a list of the name followed by the scripts.")) (|string| (((|String|) $) "\\spad{string(s)} converts the symbol \\spad{s} to a string. Error: if the symbol is subscripted.")) (|elt| (($ $ (|List| (|OutputForm|))) "\\spad{elt(s,[a1,...,an])} or \\spad{s}([\\spad{a1},{}...,{}an]) returns \\spad{s} subscripted by \\spad{[a1,...,an]}.")) (|argscript| (($ $ (|List| (|OutputForm|))) "\\spad{argscript(s, [a1,...,an])} returns \\spad{s} arg-scripted by \\spad{[a1,...,an]}.")) (|superscript| (($ $ (|List| (|OutputForm|))) "\\spad{superscript(s, [a1,...,an])} returns \\spad{s} superscripted by \\spad{[a1,...,an]}.")) (|subscript| (($ $ (|List| (|OutputForm|))) "\\spad{subscript(s, [a1,...,an])} returns \\spad{s} subscripted by \\spad{[a1,...,an]}.")) (|script| (($ $ (|Record| (|:| |sub| (|List| (|OutputForm|))) (|:| |sup| (|List| (|OutputForm|))) (|:| |presup| (|List| (|OutputForm|))) (|:| |presub| (|List| (|OutputForm|))) (|:| |args| (|List| (|OutputForm|))))) "\\spad{script(s, [a,b,c,d,e])} returns \\spad{s} with subscripts a,{} superscripts \\spad{b},{} pre-superscripts \\spad{c},{} pre-subscripts \\spad{d},{} and argument-scripts \\spad{e}.") (($ $ (|List| (|List| (|OutputForm|)))) "\\spad{script(s, [a,b,c,d,e])} returns \\spad{s} with subscripts a,{} superscripts \\spad{b},{} pre-superscripts \\spad{c},{} pre-subscripts \\spad{d},{} and argument-scripts \\spad{e}. Omitted components are taken to be empty. For example,{} \\spad{script(s, [a,b,c])} is equivalent to \\spad{script(s,[a,b,c,[],[]])}.")) (|scripts| (((|Record| (|:| |sub| (|List| (|OutputForm|))) (|:| |sup| (|List| (|OutputForm|))) (|:| |presup| (|List| (|OutputForm|))) (|:| |presub| (|List| (|OutputForm|))) (|:| |args| (|List| (|OutputForm|)))) $) "\\spad{scripts(s)} returns all the scripts of \\spad{s}.")) (|scripted?| (((|Boolean|) $) "\\spad{scripted?(s)} is \\spad{true} if \\spad{s} has been given any scripts.")) (|name| (($ $) "\\spad{name(s)} returns \\spad{s} without its scripts.")) (|resetNew| (((|Void|)) "\\spad{resetNew()} resets the internals counters that new() and new(\\spad{s}) use to return distinct symbols every time.")) (|new| (($ $) "\\spad{new(s)} returns a new symbol whose name starts with \\%\\spad{s}.") (($) "\\spad{new()} returns a new symbol whose name starts with \\%."))) 
@@ -4314,14 +4314,14 @@ NIL
 NIL 
 (|SymmetricPolynomial| R) 
 ((|constructor| (NIL "This domain implements symmetric polynomial"))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
 (#1=(|HasCategory| |#1| (QUOTE (|Algebra| #2=(|Fraction| #3=(|Integer|))))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (OR #5=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #4#) #5# (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (OR #1# #6=(|HasCategory| |#1| (QUOTE (|RetractableTo| #2#)))) #6# (|HasCategory| |#1| (QUOTE (|RetractableTo| #3#))) (|HasCategory| |#1| (QUOTE (|Field|))) (|HasCategory| |#1| (QUOTE (|GcdDomain|))) (AND #4# (|HasCategory| (|Partition|) (QUOTE (|CancellationAbelianMonoid|)))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|))) 
 (|TheSymbolTable|) 
 ((|constructor| (NIL "Creates and manipulates one global symbol table for FORTRAN code generation,{} containing details of types,{} dimensions,{} and argument lists.")) (|symbolTableOf| (((|SymbolTable|) (|Symbol|) $) "\\spad{symbolTableOf(f,tab)} returns the symbol table of \\spad{f}")) (|argumentListOf| (((|List| (|Symbol|)) (|Symbol|) $) "\\spad{argumentListOf(f,tab)} returns the argument list of \\spad{f}")) (|returnTypeOf| (((|Union| (|:| |fst| (|FortranScalarType|)) (|:| |void| #1="void")) (|Symbol|) $) "\\spad{returnTypeOf(f,tab)} returns the type of the object returned by \\spad{f}")) (|empty| (($) "\\spad{empty()} creates a new,{} empty symbol table.")) (|printTypes| (((|Void|) (|Symbol|)) "\\spad{printTypes(tab)} produces FORTRAN type declarations from \\spad{tab},{} on the current FORTRAN output stream")) (|printHeader| (((|Void|)) "\\spad{printHeader()} produces the FORTRAN header for the current subprogram in the global symbol table on the current FORTRAN output stream.") (((|Void|) (|Symbol|)) "\\spad{printHeader(f)} produces the FORTRAN header for subprogram \\spad{f} in the global symbol table on the current FORTRAN output stream.") (((|Void|) (|Symbol|) $) "\\spad{printHeader(f,tab)} produces the FORTRAN header for subprogram \\spad{f} in symbol table \\spad{tab} on the current FORTRAN output stream.")) (|returnType!| (((|Void|) (|Union| (|:| |fst| (|FortranScalarType|)) (|:| |void| #1#))) "\\spad{returnType!(t)} declares that the return type of he current subprogram in the global symbol table is \\spad{t}.") (((|Void|) (|Symbol|) (|Union| (|:| |fst| (|FortranScalarType|)) (|:| |void| #1#))) "\\spad{returnType!(f,t)} declares that the return type of subprogram \\spad{f} in the global symbol table is \\spad{t}.") (((|Void|) (|Symbol|) (|Union| (|:| |fst| (|FortranScalarType|)) (|:| |void| #1#)) $) "\\spad{returnType!(f,t,tab)} declares that the return type of subprogram \\spad{f} in symbol table \\spad{tab} is \\spad{t}.")) (|argumentList!| (((|Void|) (|List| (|Symbol|))) "\\spad{argumentList!(l)} declares that the argument list for the current subprogram in the global symbol table is \\spad{l}.") (((|Void|) (|Symbol|) (|List| (|Symbol|))) "\\spad{argumentList!(f,l)} declares that the argument list for subprogram \\spad{f} in the global symbol table is \\spad{l}.") (((|Void|) (|Symbol|) (|List| (|Symbol|)) $) "\\spad{argumentList!(f,l,tab)} declares that the argument list for subprogram \\spad{f} in symbol table \\spad{tab} is \\spad{l}.")) (|endSubProgram| (((|Symbol|)) "\\spad{endSubProgram()} asserts that we are no longer processing the current subprogram.")) (|currentSubProgram| (((|Symbol|)) "\\spad{currentSubProgram()} returns the name of the current subprogram being processed")) (|newSubProgram| (((|Void|) (|Symbol|)) "\\spad{newSubProgram(f)} asserts that from now on type declarations are part of subprogram \\spad{f}.")) (|declare!| (((|FortranType|) (|Symbol|) (|FortranType|) (|Symbol|)) "\\spad{declare!(u,t,asp)} declares the parameter \\spad{u} to have type \\spad{t} in \\spad{asp}.") (((|FortranType|) (|Symbol|) (|FortranType|)) "\\spad{declare!(u,t)} declares the parameter \\spad{u} to have type \\spad{t} in the current level of the symbol table.") (((|FortranType|) (|List| (|Symbol|)) (|FortranType|) (|Symbol|) $) "\\spad{declare!(u,t,asp,tab)} declares the parameters \\spad{u} of subprogram \\spad{asp} to have type \\spad{t} in symbol table \\spad{tab}.") (((|FortranType|) (|Symbol|) (|FortranType|) (|Symbol|) $) "\\spad{declare!(u,t,asp,tab)} declares the parameter \\spad{u} of subprogram \\spad{asp} to have type \\spad{t} in symbol table \\spad{tab}.")) (|clearTheSymbolTable| (((|Void|) (|Symbol|)) "\\spad{clearTheSymbolTable(x)} removes the symbol \\spad{x} from the table") (((|Void|)) "\\spad{clearTheSymbolTable()} clears the current symbol table.")) (|showTheSymbolTable| (($) "\\spad{showTheSymbolTable()} returns the current symbol table."))) 
 NIL 
 NIL 
 (|SymbolTable|) 
-((|constructor| (NIL "Create and manipulate a symbol table for generated FORTRAN code")) (|symbolTable| (($ (|List| (|Record| (|:| |key| (|Symbol|)) (|:| |entry| (|FortranType|))))) "\\spad{symbolTable(l)} creates a symbol table from the elements of \\spad{l}.")) (|printTypes| (((|Void|) $) "\\spad{printTypes(tab)} produces FORTRAN type declarations from \\spad{tab},{} on the current FORTRAN output stream")) (|newTypeLists| (((|SExpression|) $) "\\spad{newTypeLists(x)} \\undocumented")) (|typeLists| (((|List| (|List| (|Union| (|:| |name| (|Symbol|)) (|:| |bounds| (|List| (|Union| (|:| S (|Symbol|)) (|:| P (|Polynomial| (|Integer|))))))))) $) "\\spad{typeLists(tab)} returns a list of lists of types of objects in \\spad{tab}")) (|externalList| (((|List| (|Symbol|)) $) "\\spad{externalList(tab)} returns a list of all the external symbols in \\spad{tab}")) (|typeList| (((|List| (|Union| (|:| |name| (|Symbol|)) (|:| |bounds| (|List| (|Union| (|:| S (|Symbol|)) (|:| P (|Polynomial| (|Integer|)))))))) (|FortranScalarType|) $) "\\spad{typeList(t,tab)} returns a list of all the objects of type \\spad{t} in \\spad{tab}")) (|parametersOf| (((|List| (|Symbol|)) $) "\\spad{parametersOf(tab)} returns a list of all the symbols declared in \\spad{tab}")) (|fortranTypeOf| (((|FortranType|) (|Symbol|) $) "\\spad{fortranTypeOf(u,tab)} returns the type of \\spad{u} in \\spad{tab}")) (|declare!| (((|FortranType|) (|Symbol|) (|FortranType|) $) "\\spad{declare!(u,t,tab)} creates a new entry in \\spad{tab},{} declaring \\spad{u} to be of type \\spad{t}") (((|FortranType|) (|List| (|Symbol|)) (|FortranType|) $) "\\spad{declare!(l,t,tab)} creates new entrys in \\spad{tab},{} declaring each of \\spad{l} to be of type \\spad{t}")) (|empty| (($) "\\spad{empty()} returns a new,{} empty symbol table")) (|coerce| (((|Table| (|Symbol|) (|FortranType|)) $) "\\spad{coerce(x)} returns a table view of \\spad{x}"))) 
+((|constructor| (NIL "Create and manipulate a symbol table for generated FORTRAN code")) (|symbolTable| (($ (|List| (|Record| (|:| |key| (|Symbol|)) (|:| |entry| (|FortranType|))))) "\\spad{symbolTable(l)} creates a symbol table from the elements of \\spad{l}.")) (|printTypes| (((|Void|) $) "\\spad{printTypes(tab)} produces FORTRAN type declarations from \\spad{tab},{} on the current FORTRAN output stream")) (|newTypeLists| (((|SExpression|) $) "\\spad{newTypeLists(x)} \\undocumented")) (|typeLists| (((|List| (|List| (|Union| (|:| |name| (|Symbol|)) (|:| |bounds| (|List| (|Union| (|:| S (|Symbol|)) (|:| P (|Polynomial| (|Integer|))))))))) $) "\\spad{typeLists(tab)} returns a list of lists of types of objects in \\spad{tab}")) (|externalList| (((|List| (|Symbol|)) $) "\\spad{externalList(tab)} returns a list of all the external symbols in \\spad{tab}")) (|typeList| (((|List| (|Union| (|:| |name| (|Symbol|)) (|:| |bounds| (|List| (|Union| (|:| S (|Symbol|)) (|:| P (|Polynomial| (|Integer|)))))))) (|FortranScalarType|) $) "\\spad{typeList(t,tab)} returns a list of all the objects of type \\spad{t} in \\spad{tab}")) (|parametersOf| (((|List| (|Symbol|)) $) "\\spad{parametersOf(tab)} returns a list of all the symbols declared in \\spad{tab}")) (|fortranTypeOf| (((|FortranType|) (|Symbol|) $) "\\spad{fortranTypeOf(u,tab)} returns the type of \\spad{u} in \\spad{tab}")) (|declare!| (((|FortranType|) (|Symbol|) (|FortranType|) $) "\\spad{declare!(u,t,tab)} creates a new entry in \\spad{tab},{} declaring \\spad{u} to be of type \\spad{t}") (((|FortranType|) (|List| (|Symbol|)) (|FortranType|) $) "\\spad{declare!(l,t,tab)} creates new entrys in \\spad{tab},{} declaring each of \\spad{l} to be of type \\spad{t}")) (|empty| (($) "\\spad{empty()} returns a new,{} empty symbol table"))) 
 NIL 
 NIL 
 (|Syntax|) 
@@ -4357,7 +4357,7 @@ NIL
 NIL 
 ((AND (|HasCategory| #1=(|Record| (|:| |key| |#1|) (|:| |entry| |#2|)) (|%list| #2=(QUOTE |Evalable|) #3=(|%list| (QUOTE |Record|) (|%list| #4=(QUOTE |:|) (QUOTE |key|) (|devaluate| |#1|)) (|%list| #4# (QUOTE |entry|) #5=(|devaluate| |#2|))))) #6=(|HasCategory| #1# #7=(QUOTE (|SetCategory|)))) (OR #8=(|HasCategory| |#2| #7#) #6#) (OR #9=(|HasCategory| |#2| #10=(QUOTE (|BasicType|))) #8# #11=(|HasCategory| #1# #10#) #6#) (OR #12=(|HasCategory| #1# #13=(QUOTE (|CoercibleTo| (|OutputForm|)))) #14=(|HasCategory| |#2| #13#)) (|HasCategory| #1# (QUOTE (|ConvertibleTo| (|InputForm|)))) (AND #8# (|HasCategory| |#2| (|%list| #2# #5#))) #11# (|HasCategory| |#1| (QUOTE (|OrderedSet|))) #9# (OR #9# #11#) #8# #14# #12# #6# (AND #15=(|HasCategory| $ (|%list| #16=(QUOTE |FiniteAggregate|) #3#)) #11#) #15# (AND #9# (|HasCategory| $ (|%list| #16# #5#))) (|HasCategory| $ (|%list| (QUOTE |ShallowlyMutableAggregate|) #5#))) 
 (|Tableau| S) 
-((|constructor| (NIL "\\indented{1}{The tableau domain is for printing Young tableaux,{} and} coercions to and from List List \\spad{S} where \\spad{S} is a set.")) (|coerce| (((|OutputForm|) $) "\\spad{coerce(t)} converts a tableau \\spad{t} to an output form.")) (|listOfLists| (((|List| (|List| |#1|)) $) "\\spad{listOfLists t} converts a tableau \\spad{t} to a list of lists.")) (|tableau| (($ (|List| (|List| |#1|))) "\\spad{tableau(ll)} converts a list of lists \\spad{ll} to a tableau."))) 
+((|constructor| (NIL "\\indented{1}{The tableau domain is for printing Young tableaux,{} and} coercions to and from List List \\spad{S} where \\spad{S} is a set.")) (|listOfLists| (((|List| (|List| |#1|)) $) "\\spad{listOfLists t} converts a tableau \\spad{t} to a list of lists.")) (|tableau| (($ (|List| (|List| |#1|))) "\\spad{tableau(ll)} converts a list of lists \\spad{ll} to a tableau."))) 
 NIL 
 NIL 
 (|TermAlgebraOperator| S) 
@@ -4434,8 +4434,8 @@ NIL
 ((AND (|HasCategory| |#1| #1=(|%list| (QUOTE |ConvertibleTo|) (|%list| (QUOTE |Pattern|) #2=(|devaluate| |#1|)))) (|HasCategory| |#1| #3=(|%list| (QUOTE |PatternMatchable|) #2#)) (|HasCategory| |#2| #1#) (|HasCategory| |#2| #3#))) 
 (|TaylorSeries| |Coef|) 
 ((|constructor| (NIL "\\spadtype{TaylorSeries} is a general multivariate Taylor series domain over the ring Coef and with variables of type Symbol.")) (|fintegrate| (($ (|Mapping| $) (|Symbol|) |#1|) "\\spad{fintegrate(f,v,c)} is the integral of \\spad{f()} with respect \\indented{1}{to \\spad{v} and having \\spad{c} as the constant of integration.} \\indented{1}{The evaluation of \\spad{f()} is delayed.}")) (|integrate| (($ $ (|Symbol|) |#1|) "\\spad{integrate(s,v,c)} is the integral of \\spad{s} with respect \\indented{1}{to \\spad{v} and having \\spad{c} as the constant of integration.}")) (|coerce| (($ (|Polynomial| |#1|)) "\\spad{coerce(s)} regroups terms of \\spad{s} by total degree \\indented{1}{and forms a series.}") (($ (|Symbol|)) "\\spad{coerce(s)} converts a variable to a Taylor series")) (|coefficient| (((|Polynomial| |#1|) $ (|NonNegativeInteger|)) "\\spad{coefficient(s, n)} gives the terms of total degree \\spad{n}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-((|HasCategory| |#1| (QUOTE (|Algebra| (|Fraction| (|Integer|))))) #1=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (OR #1# #2=(|HasCategory| |#1| (QUOTE (|IntegralDomain|)))) #2# (|HasCategory| |#1| (QUOTE (|Field|)))) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|))) 
+((|HasCategory| |#1| (QUOTE (|Algebra| (|Fraction| (|Integer|))))) #1=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #2# #1#) (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#1| (QUOTE (|Field|)))) 
 (|TriangularSetCategory&| S R E V P) 
 ((|constructor| (NIL "The category of triangular sets of multivariate polynomials with coefficients in an integral domain. Let \\axiom{\\spad{R}} be an integral domain and \\axiom{\\spad{V}} a finite ordered set of variables,{} say \\axiom{\\spad{X1} < \\spad{X2} < ... < Xn}. A set \\axiom{\\spad{S}} of polynomials in \\axiom{\\spad{R}[\\spad{X1},{}\\spad{X2},{}...,{}Xn]} is triangular if no elements of \\axiom{\\spad{S}} lies in \\axiom{\\spad{R}},{} and if two distinct elements of \\axiom{\\spad{S}} have distinct main variables. Note that the empty set is a triangular set. A triangular set is not necessarily a (lexicographical) Groebner basis and the notion of reduction related to triangular sets is based on the recursive view of polynomials. We recall this notion here and refer to [1] for more details. A polynomial \\axiom{\\spad{P}} is reduced \\spad{w}.\\spad{r}.\\spad{t} a non-constant polynomial \\axiom{\\spad{Q}} if the degree of \\axiom{\\spad{P}} in the main variable of \\axiom{\\spad{Q}} is less than the main degree of \\axiom{\\spad{Q}}. A polynomial \\axiom{\\spad{P}} is reduced \\spad{w}.\\spad{r}.\\spad{t} a triangular set \\axiom{\\spad{T}} if it is reduced \\spad{w}.\\spad{r}.\\spad{t}. every polynomial of \\axiom{\\spad{T}}. \\newline References : \\indented{1}{[1] \\spad{P}. AUBRY,{} \\spad{D}. LAZARD and \\spad{M}. MORENO MAZA \"On the Theories} \\indented{5}{of Triangular Sets\" Journal of Symbol. Comp. (to appear)}")) (|coHeight| (((|NonNegativeInteger|) $) "\\axiom{coHeight(ts)} returns \\axiom{size()\\$\\spad{V}} minus \\axiom{\\#ts}.")) (|extend| (($ $ |#5|) "\\axiom{extend(ts,{}\\spad{p})} returns a triangular set which encodes the simple extension by \\axiom{\\spad{p}} of the extension of the base field defined by \\axiom{ts},{} according to the properties of triangular sets of the current category If the required properties do not hold an error is returned.")) (|extendIfCan| (((|Union| $ "failed") $ |#5|) "\\axiom{extendIfCan(ts,{}\\spad{p})} returns a triangular set which encodes the simple extension by \\axiom{\\spad{p}} of the extension of the base field defined by \\axiom{ts},{} according to the properties of triangular sets of the current domain. If the required properties do not hold then \"failed\" is returned. This operation encodes in some sense the properties of the triangular sets of the current category. Is is used to implement the \\axiom{construct} operation to guarantee that every triangular set build from a list of polynomials has the required properties.")) (|select| (((|Union| |#5| "failed") $ |#4|) "\\axiom{select(ts,{}\\spad{v})} returns the polynomial of \\axiom{ts} with \\axiom{\\spad{v}} as main variable,{} if any.")) (|algebraic?| (((|Boolean|) |#4| $) "\\axiom{algebraic?(\\spad{v},{}ts)} returns \\spad{true} iff \\axiom{\\spad{v}} is the main variable of some polynomial in \\axiom{ts}.")) (|algebraicVariables| (((|List| |#4|) $) "\\axiom{algebraicVariables(ts)} returns the decreasingly sorted list of the main variables of the polynomials of \\axiom{ts}.")) (|rest| (((|Union| $ "failed") $) "\\axiom{rest(ts)} returns the polynomials of \\axiom{ts} with smaller main variable than \\axiom{mvar(ts)} if \\axiom{ts} is not empty,{} otherwise returns \"failed\"")) (|last| (((|Union| |#5| "failed") $) "\\axiom{last(ts)} returns the polynomial of \\axiom{ts} with smallest main variable if \\axiom{ts} is not empty,{} otherwise returns \\axiom{\"failed\"}.")) (|first| (((|Union| |#5| "failed") $) "\\axiom{first(ts)} returns the polynomial of \\axiom{ts} with greatest main variable if \\axiom{ts} is not empty,{} otherwise returns \\axiom{\"failed\"}.")) (|zeroSetSplitIntoTriangularSystems| (((|List| (|Record| (|:| |close| $) (|:| |open| (|List| |#5|)))) (|List| |#5|)) "\\axiom{zeroSetSplitIntoTriangularSystems(lp)} returns a list of triangular systems \\axiom{[[\\spad{ts1},{}\\spad{qs1}],{}...,{}[tsn,{}qsn]]} such that the zero set of \\axiom{lp} is the union of the closures of the \\axiom{W_i} where \\axiom{W_i} consists of the zeros of \\axiom{ts} which do not cancel any polynomial in \\axiom{qsi}.")) (|zeroSetSplit| (((|List| $) (|List| |#5|)) "\\axiom{zeroSetSplit(lp)} returns a list \\axiom{lts} of triangular sets such that the zero set of \\axiom{lp} is the union of the closures of the regular zero sets of the members of \\axiom{lts}.")) (|reduceByQuasiMonic| ((|#5| |#5| $) "\\axiom{reduceByQuasiMonic(\\spad{p},{}ts)} returns the same as \\axiom{remainder(\\spad{p},{}collectQuasiMonic(ts)).polnum}.")) (|collectQuasiMonic| (($ $) "\\axiom{collectQuasiMonic(ts)} returns the subset of \\axiom{ts} consisting of the polynomials with initial in \\axiom{\\spad{R}}.")) (|removeZero| ((|#5| |#5| $) "\\axiom{removeZero(\\spad{p},{}ts)} returns \\axiom{0} if \\axiom{\\spad{p}} reduces to \\axiom{0} by pseudo-division \\spad{w}.\\spad{r}.\\spad{t} \\axiom{ts} otherwise returns a polynomial \\axiom{\\spad{q}} computed from \\axiom{\\spad{p}} by removing any coefficient in \\axiom{\\spad{p}} reducing to \\axiom{0}.")) (|initiallyReduce| ((|#5| |#5| $) "\\axiom{initiallyReduce(\\spad{p},{}ts)} returns a polynomial \\axiom{\\spad{r}} such that \\axiom{initiallyReduced?(\\spad{r},{}ts)} holds and there exists some product \\axiom{\\spad{h}} of \\axiom{initials(ts)} such that \\axiom{h*p - \\spad{r}} lies in the ideal generated by \\axiom{ts}.")) (|headReduce| ((|#5| |#5| $) "\\axiom{headReduce(\\spad{p},{}ts)} returns a polynomial \\axiom{\\spad{r}} such that \\axiom{headReduce?(\\spad{r},{}ts)} holds and there exists some product \\axiom{\\spad{h}} of \\axiom{initials(ts)} such that \\axiom{h*p - \\spad{r}} lies in the ideal generated by \\axiom{ts}.")) (|stronglyReduce| ((|#5| |#5| $) "\\axiom{stronglyReduce(\\spad{p},{}ts)} returns a polynomial \\axiom{\\spad{r}} such that \\axiom{stronglyReduced?(\\spad{r},{}ts)} holds and there exists some product \\axiom{\\spad{h}} of \\axiom{initials(ts)} such that \\axiom{h*p - \\spad{r}} lies in the ideal generated by \\axiom{ts}.")) (|rewriteSetWithReduction| (((|List| |#5|) (|List| |#5|) $ (|Mapping| |#5| |#5| |#5|) (|Mapping| (|Boolean|) |#5| |#5|)) "\\axiom{rewriteSetWithReduction(lp,{}ts,{}redOp,{}redOp?)} returns a list \\axiom{lq} of polynomials such that \\axiom{[reduce(\\spad{p},{}ts,{}redOp,{}redOp?) for \\spad{p} in lp]} and \\axiom{lp} have the same zeros inside the regular zero set of \\axiom{ts}. Moreover,{} for every polynomial \\axiom{\\spad{q}} in \\axiom{lq} and every polynomial \\axiom{\\spad{t}} in \\axiom{ts} \\axiom{redOp?(\\spad{q},{}\\spad{t})} holds and there exists a polynomial \\axiom{\\spad{p}} in the ideal generated by \\axiom{lp} and a product \\axiom{\\spad{h}} of \\axiom{initials(ts)} such that \\axiom{h*p - \\spad{r}} lies in the ideal generated by \\axiom{ts}. The operation \\axiom{redOp} must satisfy the following conditions. For every \\axiom{\\spad{p}} and \\axiom{\\spad{q}} we have \\axiom{redOp?(redOp(\\spad{p},{}\\spad{q}),{}\\spad{q})} and there exists an integer \\axiom{\\spad{e}} and a polynomial \\axiom{\\spad{f}} such that \\axiom{init(\\spad{q})^e*p = f*q + redOp(\\spad{p},{}\\spad{q})}.")) (|reduce| ((|#5| |#5| $ (|Mapping| |#5| |#5| |#5|) (|Mapping| (|Boolean|) |#5| |#5|)) "\\axiom{reduce(\\spad{p},{}ts,{}redOp,{}redOp?)} returns a polynomial \\axiom{\\spad{r}} such that \\axiom{redOp?(\\spad{r},{}\\spad{p})} holds for every \\axiom{\\spad{p}} of \\axiom{ts} and there exists some product \\axiom{\\spad{h}} of the initials of the members of \\axiom{ts} such that \\axiom{h*p - \\spad{r}} lies in the ideal generated by \\axiom{ts}. The operation \\axiom{redOp} must satisfy the following conditions. For every \\axiom{\\spad{p}} and \\axiom{\\spad{q}} we have \\axiom{redOp?(redOp(\\spad{p},{}\\spad{q}),{}\\spad{q})} and there exists an integer \\axiom{\\spad{e}} and a polynomial \\axiom{\\spad{f}} such that \\axiom{init(\\spad{q})^e*p = f*q + redOp(\\spad{p},{}\\spad{q})}.")) (|autoReduced?| (((|Boolean|) $ (|Mapping| (|Boolean|) |#5| (|List| |#5|))) "\\axiom{autoReduced?(ts,{}redOp?)} returns \\spad{true} iff every element of \\axiom{ts} is reduced \\spad{w}.\\spad{r}.\\spad{t} to every other in the sense of \\axiom{redOp?}")) (|initiallyReduced?| (((|Boolean|) $) "\\spad{initiallyReduced?(ts)} returns \\spad{true} iff for every element \\axiom{\\spad{p}} of \\axiom{\\spad{ts}} \\axiom{\\spad{p}} and all its iterated initials are reduced \\spad{w}.\\spad{r}.\\spad{t}. to the other elements of \\axiom{\\spad{ts}} with the same main variable.") (((|Boolean|) |#5| $) "\\axiom{initiallyReduced?(\\spad{p},{}ts)} returns \\spad{true} iff \\axiom{\\spad{p}} and all its iterated initials are reduced \\spad{w}.\\spad{r}.\\spad{t}. to the elements of \\axiom{ts} with the same main variable.")) (|headReduced?| (((|Boolean|) $) "\\spad{headReduced?(ts)} returns \\spad{true} iff the head of every element of \\axiom{\\spad{ts}} is reduced \\spad{w}.\\spad{r}.\\spad{t} to any other element of \\axiom{\\spad{ts}}.") (((|Boolean|) |#5| $) "\\axiom{headReduced?(\\spad{p},{}ts)} returns \\spad{true} iff the head of \\axiom{\\spad{p}} is reduced \\spad{w}.\\spad{r}.\\spad{t}. \\axiom{ts}.")) (|stronglyReduced?| (((|Boolean|) $) "\\axiom{stronglyReduced?(ts)} returns \\spad{true} iff every element of \\axiom{ts} is reduced \\spad{w}.\\spad{r}.\\spad{t} to any other element of \\axiom{ts}.") (((|Boolean|) |#5| $) "\\axiom{stronglyReduced?(\\spad{p},{}ts)} returns \\spad{true} iff \\axiom{\\spad{p}} is reduced \\spad{w}.\\spad{r}.\\spad{t}. \\axiom{ts}.")) (|reduced?| (((|Boolean|) |#5| $ (|Mapping| (|Boolean|) |#5| |#5|)) "\\axiom{reduced?(\\spad{p},{}ts,{}redOp?)} returns \\spad{true} iff \\axiom{\\spad{p}} is reduced \\spad{w}.\\spad{r}.\\spad{t}. in the sense of the operation \\axiom{redOp?},{} that is if for every \\axiom{\\spad{t}} in \\axiom{ts} \\axiom{redOp?(\\spad{p},{}\\spad{t})} holds.")) (|normalized?| (((|Boolean|) $) "\\axiom{normalized?(ts)} returns \\spad{true} iff for every axiom{\\spad{p}} in axiom{ts} we have \\axiom{normalized?(\\spad{p},{}us)} where \\axiom{us} is \\axiom{collectUnder(ts,{}mvar(\\spad{p}))}.") (((|Boolean|) |#5| $) "\\axiom{normalized?(\\spad{p},{}ts)} returns \\spad{true} iff \\axiom{\\spad{p}} and all its iterated initials have degree zero \\spad{w}.\\spad{r}.\\spad{t}. the main variables of the polynomials of \\axiom{ts}")) (|quasiComponent| (((|Record| (|:| |close| (|List| |#5|)) (|:| |open| (|List| |#5|))) $) "\\axiom{quasiComponent(ts)} returns \\axiom{[lp,{}lq]} where \\axiom{lp} is the list of the members of \\axiom{ts} and \\axiom{lq}is \\axiom{initials(ts)}.")) (|degree| (((|NonNegativeInteger|) $) "\\axiom{degree(ts)} returns the product of main degrees of the members of \\axiom{ts}.")) (|initials| (((|List| |#5|) $) "\\axiom{initials(ts)} returns the list of the non-constant initials of the members of \\axiom{ts}.")) (|basicSet| (((|Union| (|Record| (|:| |bas| $) (|:| |top| (|List| |#5|))) "failed") (|List| |#5|) (|Mapping| (|Boolean|) |#5|) (|Mapping| (|Boolean|) |#5| |#5|)) "\\axiom{basicSet(ps,{}pred?,{}redOp?)} returns the same as \\axiom{basicSet(qs,{}redOp?)} where \\axiom{qs} consists of the polynomials of \\axiom{ps} satisfying property \\axiom{pred?}.") (((|Union| (|Record| (|:| |bas| $) (|:| |top| (|List| |#5|))) "failed") (|List| |#5|) (|Mapping| (|Boolean|) |#5| |#5|)) "\\axiom{basicSet(ps,{}redOp?)} returns \\axiom{[bs,{}ts]} where \\axiom{concat(bs,{}ts)} is \\axiom{ps} and \\axiom{bs} is a basic set in Wu Wen Tsun sense of \\axiom{ps} \\spad{w}.\\spad{r}.\\spad{t} the reduction-test \\axiom{redOp?},{} if no non-zero constant polynomial lie in \\axiom{ps},{} otherwise \\axiom{\"failed\"} is returned.")) (|infRittWu?| (((|Boolean|) $ $) "\\axiom{infRittWu?(\\spad{ts1},{}\\spad{ts2})} returns \\spad{true} iff \\axiom{\\spad{ts2}} has higher rank than \\axiom{\\spad{ts1}} in Wu Wen Tsun sense."))) 
 NIL 
@@ -4482,7 +4482,7 @@ NIL
 NIL 
 (|UniqueFactorizationDomain|) 
 ((|constructor| (NIL "A constructive unique factorization domain,{} \\spadignore{i.e.} where we can constructively factor members into a product of a finite number of irreducible elements.")) (|factor| (((|Factored| $) $) "\\spad{factor(x)} returns the factorization of \\spad{x} into irreducibles.")) (|squareFreePart| (($ $) "\\spad{squareFreePart(x)} returns a product of prime factors of \\spad{x} each taken with multiplicity one.")) (|squareFree| (((|Factored| $) $) "\\spad{squareFree(x)} returns the square-free factorization of \\spad{x} \\spadignore{i.e.} such that the factors are pairwise relatively prime and each has multiple prime factors.")) (|prime?| (((|Boolean|) $) "\\spad{prime?(x)} tests if \\spad{x} can never be written as the product of two non-units of the ring,{} \\spadignore{i.e.} \\spad{x} is an irreducible element."))) 
-((|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|UInt16|) 
 ((|constructor| (NIL "This domain is a datatype for (unsigned) integer values of precision 16 bits."))) 
@@ -4502,15 +4502,15 @@ NIL
 NIL 
 (|UnivariateLaurentSeries| |Coef| |var| |cen|) 
 ((|constructor| (NIL "Dense Laurent series in one variable \\indented{2}{\\spadtype{UnivariateLaurentSeries} is a domain representing Laurent} \\indented{2}{series in one variable with coefficients in an arbitrary ring.\\space{2}The} \\indented{2}{parameters of the type specify the coefficient ring,{} the power series} \\indented{2}{variable,{} and the center of the power series expansion.\\space{2}For example,{}} \\indented{2}{\\spad{UnivariateLaurentSeries(Integer,x,3)} represents Laurent series in} \\indented{2}{\\spad{(x - 3)} with integer coefficients.}")) (|integrate| (($ $ (|Variable| |#2|)) "\\spad{integrate(f(x))} returns an anti-derivative of the power series \\spad{f(x)} with constant coefficient 0. We may integrate a series when we can divide coefficients by integers.")) (|coerce| (($ (|Variable| |#2|)) "\\spad{coerce(var)} converts the series variable \\spad{var} into a Laurent series."))) 
-(((|commutative| "*") OR #1=(|and| #2=(|has| |#1| #3=(|Field|)) (|has| #4=(|UnivariateTaylorSeries| |#1| |#2| |#3|) (|OrderedIntegralDomain|))) (|has| |#1| (|CommutativeRing|)) #5=(|and| #2# (|has| #4# (|PolynomialFactorizationExplicit|)))) (|noZeroDivisors| OR #1# (|has| |#1| (|IntegralDomain|)) #5#) (|canonicalUnitNormal| |has| |#1| . #6=(#3#)) (|canonicalsClosed| |has| |#1| . #6#) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| (QUOTE (|Algebra| (|Fraction| #2=(|Integer|))))) #3=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #4=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #4# #3#) (OR #5=(AND #6=(|HasCategory| |#1| (QUOTE (|Field|))) #7=(|HasCategory| #8=(|UnivariateTaylorSeries| |#1| |#2| |#3|) #9=(QUOTE (|CharacteristicNonZero|)))) #10=(|HasCategory| |#1| #9#)) (OR #11=(AND #6# (|HasCategory| #8# #12=(QUOTE (|CharacteristicZero|)))) #13=(AND #6# (|HasCategory| #8# (QUOTE (|OrderedIntegralDomain|)))) #14=(|HasCategory| |#1| #12#)) (OR #15=(AND #6# (|HasCategory| #8# #16=(QUOTE (|PartialDifferentialRing| #17=(|Symbol|))))) #18=(AND (|HasCategory| |#1| #16#) #19=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #20=(|devaluate| |#1|) #21=(QUOTE #2#) #20#))))) (OR #15# #22=(AND #6# (|HasCategory| #8# (QUOTE (|PartialDifferentialSpace| #17#)))) #18#) (OR #23=(AND #6# (|HasCategory| #8# (QUOTE (|DifferentialRing|)))) #19#) (OR #23# #24=(AND #6# (|HasCategory| #8# (QUOTE (|DifferentialSpace|)))) #19#) (|HasCategory| #2# (QUOTE (|SemiGroup|))) (OR #6# #3#) #6# #25=(AND #6# #26=(|HasCategory| #8# (QUOTE (|PolynomialFactorizationExplicit|)))) (AND #6# (|HasCategory| #8# (QUOTE (|RetractableTo| #17#)))) (AND #6# (|HasCategory| #8# (QUOTE (|ConvertibleTo| (|InputForm|))))) (AND #6# (|HasCategory| #8# (QUOTE (|RealConstant|)))) (OR #4# #6# #3#) #13# (OR #13# #27=(AND #6# (|HasCategory| #8# (QUOTE (|OrderedSet|))))) (OR #28=(AND #6# (|HasCategory| #8# (QUOTE (|RetractableTo| #2#)))) #1#) #28# (AND #6# (|HasCategory| #8# (QUOTE (|StepThrough|)))) (AND #6# (|HasCategory| #8# (|%list| (QUOTE |Eltable|) #29=(|%list| (QUOTE |UnivariateTaylorSeries|) #20# (|devaluate| |#2|) (|devaluate| |#3|)) #29#))) (AND #6# (|HasCategory| #8# (|%list| (QUOTE |Evalable|) #29#))) (AND #6# (|HasCategory| #8# (|%list| (QUOTE |InnerEvalable|) #30=(QUOTE #17#) #29#))) (AND #6# (|HasCategory| #8# (QUOTE (|LinearlyExplicitRingOver| #2#)))) (AND #6# (|HasCategory| #8# (QUOTE (|ConvertibleTo| (|Pattern| #2#))))) (AND #6# (|HasCategory| #8# (QUOTE (|ConvertibleTo| (|Pattern| #31=(|Float|)))))) (AND #6# (|HasCategory| #8# (QUOTE (|PatternMatchable| #2#)))) (AND #6# (|HasCategory| #8# (QUOTE (|PatternMatchable| #31#)))) (AND #32=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #20# #20# #21#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #20# #30#)))) #32# (OR (AND #1# (|HasCategory| |#1| (QUOTE (|AlgebraicallyClosedFunctionSpace| #2#))) (|HasCategory| |#1| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) (AND #1# (|HasSignature| |#1| (|%list| (QUOTE |integrate|) (|%list| #20# #20# #30#))) (|HasSignature| |#1| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #30#) #20#))))) (AND #6# (|HasCategory| #8# (QUOTE (|IntegerNumberSystem|)))) (AND #6# (|HasCategory| #8# (QUOTE (|EuclideanDomain|)))) #26# #7# #10# (OR #25# #13# #3#) (OR #25# #13# #4#) #22# #24# #27# (OR #11# #14#) #33=(AND #6# (|HasCategory| $ #9#) #26#) (OR #5# #33# #10#)) 
+(((|commutative| "*") OR #1=(|and| #2=(|has| |#1| #3=(|Field|)) (|has| #4=(|UnivariateTaylorSeries| |#1| |#2| |#3|) (|OrderedIntegralDomain|))) (|has| |#1| (|CommutativeRing|)) #5=(|and| #2# (|has| #4# (|PolynomialFactorizationExplicit|)))) (|noZeroDivisors| OR #1# (|has| |#1| (|IntegralDomain|)) #5#) (|canonicalUnitNormal| |has| |#1| #3#)) 
+(#1=(|HasCategory| |#1| (QUOTE (|Algebra| (|Fraction| #2=(|Integer|))))) #3=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #4=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #4# #3#) (OR #5=(AND #6=(|HasCategory| |#1| (QUOTE (|Field|))) #7=(|HasCategory| #8=(|UnivariateTaylorSeries| |#1| |#2| |#3|) #9=(QUOTE (|CharacteristicNonZero|)))) #10=(|HasCategory| |#1| #9#)) (OR #11=(AND #6# (|HasCategory| #8# #12=(QUOTE (|CharacteristicZero|)))) #13=(AND #6# (|HasCategory| #8# (QUOTE (|OrderedIntegralDomain|)))) #14=(|HasCategory| |#1| #12#)) (OR #15=(AND #6# (|HasCategory| #8# #16=(QUOTE (|PartialDifferentialRing| #17=(|Symbol|))))) #18=(AND (|HasCategory| |#1| #16#) #19=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #20=(|devaluate| |#1|) #21=(QUOTE #2#) #20#))))) (OR #15# #22=(AND #6# (|HasCategory| #8# (QUOTE (|PartialDifferentialSpace| #17#)))) #18#) (OR #23=(AND #6# (|HasCategory| #8# (QUOTE (|DifferentialRing|)))) #19#) (OR #23# #24=(AND #6# (|HasCategory| #8# (QUOTE (|DifferentialSpace|)))) #19#) (|HasCategory| #2# (QUOTE (|SemiGroup|))) (OR #6# #3#) #6# #25=(AND #6# #26=(|HasCategory| #8# (QUOTE (|PolynomialFactorizationExplicit|)))) (AND #6# (|HasCategory| #8# (QUOTE (|RetractableTo| #17#)))) (AND #6# (|HasCategory| #8# (QUOTE (|ConvertibleTo| (|InputForm|))))) (AND #6# (|HasCategory| #8# (QUOTE (|RealConstant|)))) (OR #4# #6# #3#) #13# (OR #13# #27=(AND #6# (|HasCategory| #8# (QUOTE (|OrderedSet|))))) (OR #28=(AND #6# (|HasCategory| #8# (QUOTE (|RetractableTo| #2#)))) #1#) #28# (AND #6# (|HasCategory| #8# (QUOTE (|StepThrough|)))) (AND #6# (|HasCategory| #8# (|%list| (QUOTE |Eltable|) #29=(|%list| (QUOTE |UnivariateTaylorSeries|) #20# (|devaluate| |#2|) (|devaluate| |#3|)) #29#))) (AND #6# (|HasCategory| #8# (|%list| (QUOTE |Evalable|) #29#))) (AND #6# (|HasCategory| #8# (|%list| (QUOTE |InnerEvalable|) #30=(QUOTE #17#) #29#))) (AND #6# (|HasCategory| #8# (QUOTE (|LinearlyExplicitRingOver| #2#)))) (AND #6# (|HasCategory| #8# (QUOTE (|ConvertibleTo| (|Pattern| #2#))))) (AND #6# (|HasCategory| #8# (QUOTE (|ConvertibleTo| (|Pattern| #31=(|Float|)))))) (AND #6# (|HasCategory| #8# (QUOTE (|PatternMatchable| #2#)))) (AND #6# (|HasCategory| #8# (QUOTE (|PatternMatchable| #31#)))) (AND #32=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #20# #20# #21#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #20# #30#)))) #32# (OR (AND #1# (|HasCategory| |#1| (QUOTE (|AlgebraicallyClosedFunctionSpace| #2#))) (|HasCategory| |#1| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) (AND #1# (|HasSignature| |#1| (|%list| (QUOTE |integrate|) (|%list| #20# #20# #30#))) (|HasSignature| |#1| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #30#) #20#))))) (AND #6# (|HasCategory| #8# (QUOTE (|IntegerNumberSystem|)))) (AND #6# (|HasCategory| #8# (QUOTE (|EuclideanDomain|)))) #26# #7# #10# (OR #25# #13# #3#) (OR #25# #13# #4#) #24# #22# #27# (OR #11# #14#) #33=(AND #6# (|HasCategory| $ #9#) #26#) (OR #5# #33# #10#)) 
 (|UnivariateLaurentSeriesFunctions2| |Coef1| |Coef2| |var1| |var2| |cen1| |cen2|) 
 ((|constructor| (NIL "Mapping package for univariate Laurent series \\indented{2}{This package allows one to apply a function to the coefficients of} \\indented{2}{a univariate Laurent series.}")) (|map| (((|UnivariateLaurentSeries| |#2| |#4| |#6|) (|Mapping| |#2| |#1|) (|UnivariateLaurentSeries| |#1| |#3| |#5|)) "\\spad{map(f,g(x))} applies the map \\spad{f} to the coefficients of the Laurent series \\spad{g(x)}."))) 
 NIL 
 NIL 
 (|UnivariateLaurentSeriesCategory| |Coef|) 
 ((|constructor| (NIL "\\spadtype{UnivariateLaurentSeriesCategory} is the category of Laurent series in one variable.")) (|integrate| (($ $ (|Symbol|)) "\\spad{integrate(f(x),y)} returns an anti-derivative of the power series \\spad{f(x)} with respect to the variable \\spad{y}.") (($ $ (|Symbol|)) "\\spad{integrate(f(x),y)} returns an anti-derivative of the power series \\spad{f(x)} with respect to the variable \\spad{y}.") (($ $) "\\spad{integrate(f(x))} returns an anti-derivative of the power series \\spad{f(x)} with constant coefficient 1. We may integrate a series when we can divide coefficients by integers.")) (|rationalFunction| (((|Fraction| (|Polynomial| |#1|)) $ (|Integer|) (|Integer|)) "\\spad{rationalFunction(f,k1,k2)} returns a rational function consisting of the sum of all terms of \\spad{f} of degree \\spad{d} with \\spad{k1 <= d <= k2}.") (((|Fraction| (|Polynomial| |#1|)) $ (|Integer|)) "\\spad{rationalFunction(f,k)} returns a rational function consisting of the sum of all terms of \\spad{f} of degree <= \\spad{k}.")) (|multiplyCoefficients| (($ (|Mapping| |#1| (|Integer|)) $) "\\spad{multiplyCoefficients(f,sum(n = n0..infinity,a[n] * x**n)) = sum(n = 0..infinity,f(n) * a[n] * x**n)}. This function is used when Puiseux series are represented by a Laurent series and an exponent.")) (|series| (($ (|Stream| (|Record| (|:| |k| (|Integer|)) (|:| |c| |#1|)))) "\\spad{series(st)} creates a series from a stream of non-zero terms,{} where a term is an exponent-coefficient pair. The terms in the stream should be ordered by increasing order of exponents."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| . #1=((|Field|))) (|canonicalsClosed| |has| |#1| . #1#) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (|Field|))) 
 NIL 
 (|UnivariateLaurentSeriesConstructorCategory&| S |Coef| UTS) 
 ((|constructor| (NIL "This is a category of univariate Laurent series constructed from univariate Taylor series. A Laurent series is represented by a pair \\spad{[n,f(x)]},{} where \\spad{n} is an arbitrary integer and \\spad{f(x)} is a Taylor series. This pair represents the Laurent series \\spad{x**n * f(x)}.")) (|taylorIfCan| (((|Union| |#3| "failed") $) "\\spad{taylorIfCan(f(x))} converts the Laurent series \\spad{f(x)} to a Taylor series,{} if possible. If this is not possible,{} \"failed\" is returned.")) (|taylor| ((|#3| $) "\\spad{taylor(f(x))} converts the Laurent series \\spad{f}(\\spad{x}) to a Taylor series,{} if possible. Error: if this is not possible.")) (|removeZeroes| (($ (|Integer|) $) "\\spad{removeZeroes(n,f(x))} removes up to \\spad{n} leading zeroes from the Laurent series \\spad{f(x)}. A Laurent series is represented by (1) an exponent and (2) a Taylor series which may have leading zero coefficients. When the Taylor series has a leading zero coefficient,{} the 'leading zero' is removed from the Laurent series as follows: the series is rewritten by increasing the exponent by 1 and dividing the Taylor series by its variable.") (($ $) "\\spad{removeZeroes(f(x))} removes leading zeroes from the representation of the Laurent series \\spad{f(x)}. A Laurent series is represented by (1) an exponent and (2) a Taylor series which may have leading zero coefficients. When the Taylor series has a leading zero coefficient,{} the 'leading zero' is removed from the Laurent series as follows: the series is rewritten by increasing the exponent by 1 and dividing the Taylor series by its variable. Note: \\spad{removeZeroes(f)} removes all leading zeroes from \\spad{f}")) (|taylorRep| ((|#3| $) "\\spad{taylorRep(f(x))} returns \\spad{g(x)},{} where \\spad{f = x**n * g(x)} is represented by \\spad{[n,g(x)]}.")) (|degree| (((|Integer|) $) "\\spad{degree(f(x))} returns the degree of the lowest order term of \\spad{f(x)},{} which may have zero as a coefficient.")) (|laurent| (($ (|Integer|) |#3|) "\\spad{laurent(n,f(x))} returns \\spad{x**n * f(x)}."))) 
@@ -4518,12 +4518,12 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|Field|)))) 
 (|UnivariateLaurentSeriesConstructorCategory| |Coef| UTS) 
 ((|constructor| (NIL "This is a category of univariate Laurent series constructed from univariate Taylor series. A Laurent series is represented by a pair \\spad{[n,f(x)]},{} where \\spad{n} is an arbitrary integer and \\spad{f(x)} is a Taylor series. This pair represents the Laurent series \\spad{x**n * f(x)}.")) (|taylorIfCan| (((|Union| |#2| "failed") $) "\\spad{taylorIfCan(f(x))} converts the Laurent series \\spad{f(x)} to a Taylor series,{} if possible. If this is not possible,{} \"failed\" is returned.")) (|taylor| ((|#2| $) "\\spad{taylor(f(x))} converts the Laurent series \\spad{f}(\\spad{x}) to a Taylor series,{} if possible. Error: if this is not possible.")) (|removeZeroes| (($ (|Integer|) $) "\\spad{removeZeroes(n,f(x))} removes up to \\spad{n} leading zeroes from the Laurent series \\spad{f(x)}. A Laurent series is represented by (1) an exponent and (2) a Taylor series which may have leading zero coefficients. When the Taylor series has a leading zero coefficient,{} the 'leading zero' is removed from the Laurent series as follows: the series is rewritten by increasing the exponent by 1 and dividing the Taylor series by its variable.") (($ $) "\\spad{removeZeroes(f(x))} removes leading zeroes from the representation of the Laurent series \\spad{f(x)}. A Laurent series is represented by (1) an exponent and (2) a Taylor series which may have leading zero coefficients. When the Taylor series has a leading zero coefficient,{} the 'leading zero' is removed from the Laurent series as follows: the series is rewritten by increasing the exponent by 1 and dividing the Taylor series by its variable. Note: \\spad{removeZeroes(f)} removes all leading zeroes from \\spad{f}")) (|taylorRep| ((|#2| $) "\\spad{taylorRep(f(x))} returns \\spad{g(x)},{} where \\spad{f = x**n * g(x)} is represented by \\spad{[n,g(x)]}.")) (|degree| (((|Integer|) $) "\\spad{degree(f(x))} returns the degree of the lowest order term of \\spad{f(x)},{} which may have zero as a coefficient.")) (|laurent| (($ (|Integer|) |#2|) "\\spad{laurent(n,f(x))} returns \\spad{x**n * f(x)}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| . #1=((|Field|))) (|canonicalsClosed| |has| |#1| . #1#) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (|Field|))) 
 NIL 
 (|UnivariateLaurentSeriesConstructor| |Coef| UTS) 
 ((|constructor| (NIL "This package enables one to construct a univariate Laurent series domain from a univariate Taylor series domain. Univariate Laurent series are represented by a pair \\spad{[n,f(x)]},{} where \\spad{n} is an arbitrary integer and \\spad{f(x)} is a Taylor series. This pair represents the Laurent series \\spad{x**n * f(x)}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| . #1=((|Field|))) (|canonicalsClosed| |has| |#1| . #1#) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#1| (QUOTE (|Algebra| (|Fraction| #2=(|Integer|))))) #3=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #4=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #4# #3#) (OR #5=(|HasCategory| |#1| #6=(QUOTE (|CharacteristicNonZero|))) #7=(AND #8=(|HasCategory| |#1| (QUOTE (|Field|))) #9=(|HasCategory| |#2| #6#))) (OR #10=(|HasCategory| |#1| #11=(QUOTE (|CharacteristicZero|))) #12=(AND #8# (|HasCategory| |#2| #11#)) #13=(AND #8# (|HasCategory| |#2| (QUOTE (|OrderedIntegralDomain|))))) (OR #14=(AND #8# (|HasCategory| |#2| #15=(QUOTE (|PartialDifferentialRing| #16=(|Symbol|))))) #17=(AND (|HasCategory| |#1| #15#) #18=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #19=(|devaluate| |#1|) #20=(QUOTE #2#) #19#))))) (OR #14# #21=(AND #8# (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #16#)))) #17#) (OR #18# #22=(AND #8# (|HasCategory| |#2| (QUOTE (|DifferentialRing|))))) (OR #18# #22# #23=(AND #8# (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))))) (|HasCategory| #2# (QUOTE (|SemiGroup|))) (OR #8# #3#) #8# (AND #8# #24=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|)))) (AND #8# (|HasCategory| |#2| (QUOTE (|RetractableTo| #16#)))) (AND #8# (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|InputForm|))))) (AND #8# (|HasCategory| |#2| (QUOTE (|RealConstant|)))) (OR #4# #8# #3#) #13# (OR #13# #25=(AND #8# (|HasCategory| |#2| (QUOTE (|OrderedSet|))))) (OR #1# #26=(AND #8# (|HasCategory| |#2| (QUOTE (|RetractableTo| #2#))))) #26# (AND #8# (|HasCategory| |#2| (QUOTE (|StepThrough|)))) (AND #8# (|HasCategory| |#2| (|%list| (QUOTE |Eltable|) #27=(|devaluate| |#2|) #27#))) (AND #8# (|HasCategory| |#2| (|%list| (QUOTE |Evalable|) #27#))) (AND #8# (|HasCategory| |#2| (|%list| (QUOTE |InnerEvalable|) #28=(QUOTE #16#) #27#))) (AND #8# (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #2#)))) (AND #8# (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Pattern| #2#))))) (AND #8# (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Pattern| #29=(|Float|)))))) (AND #8# (|HasCategory| |#2| (QUOTE (|PatternMatchable| #2#)))) (AND #8# (|HasCategory| |#2| (QUOTE (|PatternMatchable| #29#)))) (AND #30=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #19# #19# #20#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #19# #28#)))) #30# (OR (AND #1# (|HasCategory| |#1| (QUOTE (|AlgebraicallyClosedFunctionSpace| #2#))) (|HasCategory| |#1| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) (AND #1# (|HasSignature| |#1| (|%list| (QUOTE |integrate|) (|%list| #19# #19# #28#))) (|HasSignature| |#1| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #28#) #19#))))) #25# #24# (AND #8# (|HasCategory| |#2| (QUOTE (|IntegerNumberSystem|)))) (AND #8# (|HasCategory| |#2| (QUOTE (|EuclideanDomain|)))) #5# #9# (OR #18# #23#) (OR #21# #17#) #21# #23# (OR #10# #12#) #31=(AND #8# #24# (|HasCategory| $ #6#)) (OR #31# #5# #7#)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (|Field|))) 
+(#1=(|HasCategory| |#1| (QUOTE (|Algebra| (|Fraction| #2=(|Integer|))))) #3=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #4=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #4# #3#) (OR #5=(|HasCategory| |#1| #6=(QUOTE (|CharacteristicNonZero|))) #7=(AND #8=(|HasCategory| |#1| (QUOTE (|Field|))) #9=(|HasCategory| |#2| #6#))) (OR #10=(|HasCategory| |#1| #11=(QUOTE (|CharacteristicZero|))) #12=(AND #8# (|HasCategory| |#2| #11#)) #13=(AND #8# (|HasCategory| |#2| (QUOTE (|OrderedIntegralDomain|))))) (OR #14=(AND #8# (|HasCategory| |#2| #15=(QUOTE (|PartialDifferentialRing| #16=(|Symbol|))))) #17=(AND (|HasCategory| |#1| #15#) #18=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #19=(|devaluate| |#1|) #20=(QUOTE #2#) #19#))))) (OR #14# #21=(AND #8# (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #16#)))) #17#) (OR #18# #22=(AND #8# (|HasCategory| |#2| (QUOTE (|DifferentialRing|))))) (OR #18# #22# #23=(AND #8# (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))))) (|HasCategory| #2# (QUOTE (|SemiGroup|))) (OR #8# #3#) #8# (AND #8# #24=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|)))) (AND #8# (|HasCategory| |#2| (QUOTE (|RetractableTo| #16#)))) (AND #8# (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|InputForm|))))) (AND #8# (|HasCategory| |#2| (QUOTE (|RealConstant|)))) (OR #4# #8# #3#) #13# (OR #13# #25=(AND #8# (|HasCategory| |#2| (QUOTE (|OrderedSet|))))) (OR #1# #26=(AND #8# (|HasCategory| |#2| (QUOTE (|RetractableTo| #2#))))) #26# (AND #8# (|HasCategory| |#2| (QUOTE (|StepThrough|)))) (AND #8# (|HasCategory| |#2| (|%list| (QUOTE |Eltable|) #27=(|devaluate| |#2|) #27#))) (AND #8# (|HasCategory| |#2| (|%list| (QUOTE |Evalable|) #27#))) (AND #8# (|HasCategory| |#2| (|%list| (QUOTE |InnerEvalable|) #28=(QUOTE #16#) #27#))) (AND #8# (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #2#)))) (AND #8# (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Pattern| #2#))))) (AND #8# (|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Pattern| #29=(|Float|)))))) (AND #8# (|HasCategory| |#2| (QUOTE (|PatternMatchable| #2#)))) (AND #8# (|HasCategory| |#2| (QUOTE (|PatternMatchable| #29#)))) (AND #30=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #19# #19# #20#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #19# #28#)))) #30# (OR (AND #1# (|HasCategory| |#1| (QUOTE (|AlgebraicallyClosedFunctionSpace| #2#))) (|HasCategory| |#1| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) (AND #1# (|HasSignature| |#1| (|%list| (QUOTE |integrate|) (|%list| #19# #19# #28#))) (|HasSignature| |#1| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #28#) #19#))))) #25# #24# (AND #8# (|HasCategory| |#2| (QUOTE (|IntegerNumberSystem|)))) (AND #8# (|HasCategory| |#2| (QUOTE (|EuclideanDomain|)))) #5# #9# (OR #18# #23#) (OR #21# #17#) #23# #21# (OR #10# #12#) #31=(AND #8# #24# (|HasCategory| $ #6#)) (OR #31# #5# #7#)) 
 (|UnivariateFactorize| ZP) 
 ((|constructor| (NIL "Package for the factorization of univariate polynomials with integer coefficients. The factorization is done by \"lifting\" (HENSEL) the factorization over a finite field.")) (|henselFact| (((|Record| (|:| |contp| (|Integer|)) (|:| |factors| (|List| (|Record| (|:| |irr| |#1|) (|:| |pow| (|Integer|)))))) |#1| (|Boolean|)) "\\spad{henselFact(m,flag)} returns the factorization of \\spad{m},{} FinalFact is a Record \\spad{s}.\\spad{t}. FinalFact.contp=content \\spad{m},{} FinalFact.factors=List of irreducible factors of \\spad{m} with exponent ,{} if \\spad{flag} =true the polynomial is assumed square free.")) (|factorSquareFree| (((|Factored| |#1|) |#1|) "\\spad{factorSquareFree(m)} returns the factorization of \\spad{m} square free polynomial")) (|factor| (((|Factored| |#1|) |#1|) "\\spad{factor(m)} returns the factorization of \\spad{m}"))) 
 NIL 
@@ -4538,8 +4538,8 @@ NIL
 ((|HasCategory| |#1| (QUOTE (|OrderedRing|)))) 
 (|UnivariatePolynomial| |x| R) 
 ((|constructor| (NIL "This domain represents univariate polynomials in some symbol over arbitrary (not necessarily commutative) coefficient rings. The representation is sparse in the sense that only non-zero terms are represented.")) (|fmecg| (($ $ (|NonNegativeInteger|) |#2| $) "\\spad{fmecg(p1,e,r,p2)} finds \\spad{X} : \\spad{p1} - \\spad{r} * X**e * \\spad{p2}"))) 
-(((|commutative| "*") |has| |#2| (|CommutativeRing|)) (|noZeroDivisors| |has| |#2| (|IntegralDomain|)) (|additiveValuation| |has| |#2| (|Field|)) (|canonicalUnitNormal| |has| |#2| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
-(#1=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) #2=(|HasCategory| |#2| (QUOTE (|IntegralDomain|))) #3=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) (OR #3# #2#) (AND (|HasCategory| |#2| #4=(QUOTE (|PatternMatchable| #5=(|Float|)))) (|HasCategory| #6=(|SingletonAsOrderedSet|) #4#)) (AND (|HasCategory| |#2| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| #6# #7#)) (AND (|HasCategory| |#2| #9=(QUOTE (|ConvertibleTo| (|Pattern| #5#)))) (|HasCategory| #6# #9#)) (AND (|HasCategory| |#2| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #6# #10#)) (AND (|HasCategory| |#2| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #6# #11#)) (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #8#))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) #12=(|HasCategory| |#2| #13=(QUOTE (|CharacteristicNonZero|))) #14=(|HasCategory| |#2| (QUOTE (|Algebra| #15=(|Fraction| #8#)))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #8#))) (OR #14# #16=(|HasCategory| |#2| (QUOTE (|RetractableTo| #15#)))) #16# (OR #3# #17=(|HasCategory| |#2| (QUOTE (|Field|))) #18=(|HasCategory| |#2| (QUOTE (|GcdDomain|))) #2# #1#) (OR #17# #18# #2# #1#) (OR #17# #18# #1#) #17# (|HasCategory| |#2| (QUOTE (|StepThrough|))) (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #19=(|Symbol|)))) (|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #19#))) (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#2| (QUOTE (|DifferentialRing|))) (|HasAttribute| |#2| (QUOTE |canonicalUnitNormal|)) #18# #20=(AND #1# (|HasCategory| $ #13#)) (OR #20# #12#)) 
+(((|commutative| "*") |has| |#2| (|CommutativeRing|)) (|noZeroDivisors| |has| |#2| (|IntegralDomain|)) (|additiveValuation| |has| |#2| (|Field|)) (|canonicalUnitNormal| |has| |#2| (ATTRIBUTE |canonicalUnitNormal|))) 
+(#1=(|HasCategory| |#2| (QUOTE (|PolynomialFactorizationExplicit|))) #2=(|HasCategory| |#2| (QUOTE (|IntegralDomain|))) #3=(|HasCategory| |#2| (QUOTE (|CommutativeRing|))) (OR #3# #2#) (AND (|HasCategory| |#2| #4=(QUOTE (|PatternMatchable| #5=(|Float|)))) (|HasCategory| #6=(|SingletonAsOrderedSet|) #4#)) (AND (|HasCategory| |#2| #7=(QUOTE (|PatternMatchable| #8=(|Integer|)))) (|HasCategory| #6# #7#)) (AND (|HasCategory| |#2| #9=(QUOTE (|ConvertibleTo| (|Pattern| #5#)))) (|HasCategory| #6# #9#)) (AND (|HasCategory| |#2| #10=(QUOTE (|ConvertibleTo| (|Pattern| #8#)))) (|HasCategory| #6# #10#)) (AND (|HasCategory| |#2| #11=(QUOTE (|ConvertibleTo| (|InputForm|)))) (|HasCategory| #6# #11#)) (|HasCategory| |#2| (QUOTE (|LinearlyExplicitRingOver| #8#))) #12=(|HasCategory| |#2| (QUOTE (|Algebra| #13=(|Fraction| #8#)))) #14=(|HasCategory| |#2| #15=(QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|))) (|HasCategory| |#2| (QUOTE (|RetractableTo| #8#))) (OR #12# #16=(|HasCategory| |#2| (QUOTE (|RetractableTo| #13#)))) #16# (OR #3# #17=(|HasCategory| |#2| (QUOTE (|Field|))) #18=(|HasCategory| |#2| (QUOTE (|GcdDomain|))) #2# #1#) (OR #17# #18# #2# #1#) (OR #17# #18# #1#) #17# (|HasCategory| |#2| (QUOTE (|StepThrough|))) (|HasCategory| |#2| (QUOTE (|PartialDifferentialSpace| #19=(|Symbol|)))) (|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #19#))) (|HasCategory| |#2| (QUOTE (|DifferentialSpace|))) (|HasCategory| |#2| (QUOTE (|DifferentialRing|))) (|HasAttribute| |#2| (QUOTE |canonicalUnitNormal|)) #18# #20=(AND #1# (|HasCategory| $ #15#)) (OR #20# #14#)) 
 (|UnivariatePolynomialFunctions2| |x| R |y| S) 
 ((|constructor| (NIL "This package lifts a mapping from coefficient rings \\spad{R} to \\spad{S} to a mapping from \\spadtype{UnivariatePolynomial}(\\spad{x},{}\\spad{R}) to \\spadtype{UnivariatePolynomial}(\\spad{y},{}\\spad{S}). Note that the mapping is assumed to send zero to zero,{} since it will only be applied to the non-zero coefficients of the polynomial.")) (|map| (((|UnivariatePolynomial| |#3| |#4|) (|Mapping| |#4| |#2|) (|UnivariatePolynomial| |#1| |#2|)) "\\spad{map(func, poly)} creates a new polynomial by applying \\spad{func} to every non-zero coefficient of the polynomial poly."))) 
 NIL 
@@ -4566,7 +4566,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|Algebra| (|Fraction| (|Integer|))))) (|HasCategory| |#2| (QUOTE (|Field|))) (|HasCategory| |#2| (QUOTE (|GcdDomain|))) (|HasCategory| |#2| (QUOTE (|IntegralDomain|))) (|HasCategory| |#2| (QUOTE (|CommutativeRing|))) (|HasCategory| |#2| (QUOTE (|StepThrough|)))) 
 (|UnivariatePolynomialCategory| R) 
 ((|constructor| (NIL "The category of univariate polynomials over a ring \\spad{R}. No particular model is assumed - implementations can be either sparse or dense.")) (|integrate| (($ $) "\\spad{integrate(p)} integrates the univariate polynomial \\spad{p} with respect to its distinguished variable.")) (|additiveValuation| ((|attribute|) "euclideanSize(a*b) = euclideanSize(a) + euclideanSize(\\spad{b})")) (|separate| (((|Record| (|:| |primePart| $) (|:| |commonPart| $)) $ $) "\\spad{separate(p, q)} returns \\spad{[a, b]} such that polynomial \\spad{p = a b} and \\spad{a} is relatively prime to \\spad{q}.")) (|pseudoDivide| (((|Record| (|:| |coef| |#1|) (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\spad{pseudoDivide(p,q)} returns \\spad{[c, q, r]},{} when \\spad{p' := p*lc(q)**(deg p - deg q + 1) = c * p} is pseudo right-divided by \\spad{q},{} \\spadignore{i.e.} \\spad{p' = s q + r}.")) (|pseudoQuotient| (($ $ $) "\\spad{pseudoQuotient(p,q)} returns \\spad{r},{} the quotient when \\spad{p' := p*lc(q)**(deg p - deg q + 1)} is pseudo right-divided by \\spad{q},{} \\spadignore{i.e.} \\spad{p' = s q + r}.")) (|composite| (((|Union| (|Fraction| $) "failed") (|Fraction| $) $) "\\spad{composite(f, q)} returns \\spad{h} if \\spad{f} = \\spad{h}(\\spad{q}),{} and \"failed\" is no such \\spad{h} exists.") (((|Union| $ "failed") $ $) "\\spad{composite(p, q)} returns \\spad{h} if \\spad{p = h(q)},{} and \"failed\" no such \\spad{h} exists.")) (|subResultantGcd| (($ $ $) "\\spad{subResultantGcd(p,q)} computes the gcd of the polynomials \\spad{p} and \\spad{q} using the SubResultant GCD algorithm.")) (|order| (((|NonNegativeInteger|) $ $) "\\spad{order(p, q)} returns the largest \\spad{n} such that \\spad{q**n} divides polynomial \\spad{p} \\spadignore{i.e.} the order of \\spad{p(x)} at \\spad{q(x)=0}.")) (|elt| ((|#1| (|Fraction| $) |#1|) "\\spad{elt(a,r)} evaluates the fraction of univariate polynomials \\spad{a} with the distinguished variable replaced by the constant \\spad{r}.") (((|Fraction| $) (|Fraction| $) (|Fraction| $)) "\\spad{elt(a,b)} evaluates the fraction of univariate polynomials \\spad{a} with the distinguished variable replaced by \\spad{b}.")) (|resultant| ((|#1| $ $) "\\spad{resultant(p,q)} returns the resultant of the polynomials \\spad{p} and \\spad{q}.")) (|discriminant| ((|#1| $) "\\spad{discriminant(p)} returns the discriminant of the polynomial \\spad{p}.")) (|differentiate| (($ $ (|Mapping| |#1| |#1|) $) "\\spad{differentiate(p, d, x')} extends the \\spad{R}-derivation \\spad{d} to an extension \\spad{D} in \\spad{R[x]} where Dx is given by x',{} and returns \\spad{Dp}.")) (|pseudoRemainder| (($ $ $) "\\spad{pseudoRemainder(p,q)} = \\spad{r},{} for polynomials \\spad{p} and \\spad{q},{} returns the remainder when \\spad{p' := p*lc(q)**(deg p - deg q + 1)} is pseudo right-divided by \\spad{q},{} \\spadignore{i.e.} \\spad{p' = s q + r}.")) (|shiftLeft| (($ $ (|NonNegativeInteger|)) "\\spad{shiftLeft(p,n)} returns \\spad{p * monomial(1,n)}")) (|shiftRight| (($ $ (|NonNegativeInteger|)) "\\spad{shiftRight(p,n)} returns \\spad{monicDivide(p,monomial(1,n)).quotient}")) (|karatsubaDivide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ (|NonNegativeInteger|)) "\\spad{karatsubaDivide(p,n)} returns the same as \\spad{monicDivide(p,monomial(1,n))}")) (|monicDivide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\spad{monicDivide(p,q)} divide the polynomial \\spad{p} by the monic polynomial \\spad{q},{} returning the pair \\spad{[quotient, remainder]}. Error: if \\spad{q} isn't monic.")) (|divideExponents| (((|Union| $ "failed") $ (|NonNegativeInteger|)) "\\spad{divideExponents(p,n)} returns a new polynomial resulting from dividing all exponents of the polynomial \\spad{p} by the non negative integer \\spad{n},{} or \"failed\" if some exponent is not exactly divisible by \\spad{n}.")) (|multiplyExponents| (($ $ (|NonNegativeInteger|)) "\\spad{multiplyExponents(p,n)} returns a new polynomial resulting from multiplying all exponents of the polynomial \\spad{p} by the non negative integer \\spad{n}.")) (|unmakeSUP| (($ (|SparseUnivariatePolynomial| |#1|)) "\\spad{unmakeSUP(sup)} converts \\spad{sup} of type \\spadtype{SparseUnivariatePolynomial(R)} to be a member of the given type. Note: converse of makeSUP.")) (|makeSUP| (((|SparseUnivariatePolynomial| |#1|) $) "\\spad{makeSUP(p)} converts the polynomial \\spad{p} to be of type SparseUnivariatePolynomial over the same coefficients.")) (|vectorise| (((|Vector| |#1|) $ (|NonNegativeInteger|)) "\\spad{vectorise(p, n)} returns \\spad{[a0,...,a(n-1)]} where \\spad{p = a0 + a1*x + ... + a(n-1)*x**(n-1)} + higher order terms. The degree of polynomial \\spad{p} can be different from \\spad{n-1}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|additiveValuation| |has| |#1| (|Field|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|additiveValuation| |has| |#1| (|Field|)) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|))) 
 NIL 
 (|UnivariatePolynomialCategoryFunctions2| R PR S PS) 
 ((|constructor| (NIL "Mapping from polynomials over \\spad{R} to polynomials over \\spad{S} given a map from \\spad{R} to \\spad{S} assumed to send zero to zero.")) (|map| ((|#4| (|Mapping| |#3| |#1|) |#2|) "\\spad{map(f, p)} takes a function \\spad{f} from \\spad{R} to \\spad{S},{} and applies it to each (non-zero) coefficient of a polynomial \\spad{p} over \\spad{R},{} getting a new polynomial over \\spad{S}. Note: since the map is not applied to zero elements,{} it may map zero to zero."))) 
@@ -4578,7 +4578,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|PartialDifferentialRing| #1=(|Symbol|)))) (|HasSignature| |#2| (|%list| (QUOTE *) (|%list| #2=(|devaluate| |#2|) #3=(|devaluate| |#3|) #2#))) (|HasCategory| |#3| (QUOTE (|SemiGroup|))) (|HasSignature| |#2| (|%list| (QUOTE **) (|%list| #2# #2# #3#))) (|HasSignature| |#2| (|%list| (QUOTE |coerce|) (|%list| #2# (QUOTE #1#))))) 
 (|UnivariatePowerSeriesCategory| |Coef| |Expon|) 
 ((|constructor| (NIL "\\spadtype{UnivariatePowerSeriesCategory} is the most general univariate power series category with exponents in an ordered abelian monoid. Note: this category exports a substitution function if it is possible to multiply exponents. Note: this category exports a derivative operation if it is possible to multiply coefficients by exponents.")) (|eval| (((|Stream| |#1|) $ |#1|) "\\spad{eval(f,a)} evaluates a power series at a value in the ground ring by returning a stream of partial sums.")) (|extend| (($ $ |#2|) "\\spad{extend(f,n)} causes all terms of \\spad{f} of degree <= \\spad{n} to be computed.")) (|approximate| ((|#1| $ |#2|) "\\spad{approximate(f)} returns a truncated power series with the series variable viewed as an element of the coefficient domain.")) (|truncate| (($ $ |#2| |#2|) "\\spad{truncate(f,k1,k2)} returns a (finite) power series consisting of the sum of all terms of \\spad{f} of degree \\spad{d} with \\spad{k1 <= d <= k2}.") (($ $ |#2|) "\\spad{truncate(f,k)} returns a (finite) power series consisting of the sum of all terms of \\spad{f} of degree \\spad{<= k}.")) (|order| ((|#2| $ |#2|) "\\spad{order(f,n) = min(m,n)},{} where \\spad{m} is the degree of the lowest order non-zero term in \\spad{f}.") ((|#2| $) "\\spad{order(f)} is the degree of the lowest order non-zero term in \\spad{f}. This will result in an infinite loop if \\spad{f} has no non-zero terms.")) (|multiplyExponents| (($ $ (|PositiveInteger|)) "\\spad{multiplyExponents(f,n)} multiplies all exponents of the power series \\spad{f} by the positive integer \\spad{n}.")) (|center| ((|#1| $) "\\spad{center(f)} returns the point about which the series \\spad{f} is expanded.")) (|variable| (((|Symbol|) $) "\\spad{variable(f)} returns the (unique) power series variable of the power series \\spad{f}.")) (|terms| (((|Stream| (|Record| (|:| |k| |#2|) (|:| |c| |#1|))) $) "\\spad{terms(f(x))} returns a stream of non-zero terms,{} where a a term is an exponent-coefficient pair. The terms in the stream are ordered by increasing order of exponents."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|))) 
 NIL 
 (|UnivariatePolynomialSquareFree| RC P) 
 ((|constructor| (NIL "This package provides for square-free decomposition of univariate polynomials over arbitrary rings,{} \\spadignore{i.e.} a partial factorization such that each factor is a product of irreducibles with multiplicity one and the factors are pairwise relatively prime. If the ring has characteristic zero,{} the result is guaranteed to satisfy this condition. If the ring is an infinite ring of finite characteristic,{} then it may not be possible to decide when polynomials contain factors which are \\spad{p}th powers. In this case,{} the flag associated with that polynomial is set to \"nil\" (meaning that that polynomials are not guaranteed to be square-free).")) (|BumInSepFFE| (((|Record| (|:| |flg| (|Union| #1="nil" #2="sqfr" #3="irred" #4="prime")) (|:| |fctr| |#2|) (|:| |xpnt| (|Integer|))) (|Record| (|:| |flg| (|Union| #1# #2# #3# #4#)) (|:| |fctr| |#2|) (|:| |xpnt| (|Integer|)))) "\\spad{BumInSepFFE(f)} is a local function,{} exported only because it has multiple conditional definitions.")) (|squareFreePart| ((|#2| |#2|) "\\spad{squareFreePart(p)} returns a polynomial which has the same irreducible factors as the univariate polynomial \\spad{p},{} but each factor has multiplicity one.")) (|squareFree| (((|Factored| |#2|) |#2|) "\\spad{squareFree(p)} computes the square-free factorization of the univariate polynomial \\spad{p}. Each factor has no repeated roots,{} and the factors are pairwise relatively prime.")) (|gcd| (($ $ $) "\\spad{gcd(p,q)} computes the greatest-common-divisor of \\spad{p} and \\spad{q}."))) 
@@ -4586,7 +4586,7 @@ NIL
 NIL 
 (|UnivariatePuiseuxSeries| |Coef| |var| |cen|) 
 ((|constructor| (NIL "Dense Puiseux series in one variable \\indented{2}{\\spadtype{UnivariatePuiseuxSeries} is a domain representing Puiseux} \\indented{2}{series in one variable with coefficients in an arbitrary ring.\\space{2}The} \\indented{2}{parameters of the type specify the coefficient ring,{} the power series} \\indented{2}{variable,{} and the center of the power series expansion.\\space{2}For example,{}} \\indented{2}{\\spad{UnivariatePuiseuxSeries(Integer,x,3)} represents Puiseux series in} \\indented{2}{\\spad{(x - 3)} with \\spadtype{Integer} coefficients.}")) (|integrate| (($ $ (|Variable| |#2|)) "\\spad{integrate(f(x))} returns an anti-derivative of the power series \\spad{f(x)} with constant coefficient 0. We may integrate a series when we can divide coefficients by integers."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| . #1=((|Field|))) (|canonicalsClosed| |has| |#1| . #1#) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (|Field|))) 
 (#1=(|HasCategory| |#1| (QUOTE (|Algebra| #2=(|Fraction| #3=(|Integer|))))) #4=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #5=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #5# #4#) (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (AND (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #6=(|Symbol|)))) #7=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #8=(|devaluate| |#1|) #9=(|%list| (QUOTE |Fraction|) (QUOTE #3#)) #8#)))) #7# (|HasCategory| #2# (QUOTE (|SemiGroup|))) #10=(|HasCategory| |#1| (QUOTE (|Field|))) (OR #5# #10# #4#) (OR #10# #4#) (AND #11=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #8# #8# #9#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #8# #12=(QUOTE #6#))))) #11# (OR (AND #1# (|HasCategory| |#1| (QUOTE (|AlgebraicallyClosedFunctionSpace| #3#))) (|HasCategory| |#1| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) (AND #1# (|HasSignature| |#1| (|%list| (QUOTE |integrate|) (|%list| #8# #8# #12#))) (|HasSignature| |#1| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #12#) #8#)))))) 
 (|UnivariatePuiseuxSeriesFunctions2| |Coef1| |Coef2| |var1| |var2| |cen1| |cen2|) 
 ((|constructor| (NIL "Mapping package for univariate Puiseux series. This package allows one to apply a function to the coefficients of a univariate Puiseux series.")) (|map| (((|UnivariatePuiseuxSeries| |#2| |#4| |#6|) (|Mapping| |#2| |#1|) (|UnivariatePuiseuxSeries| |#1| |#3| |#5|)) "\\spad{map(f,g(x))} applies the map \\spad{f} to the coefficients of the Puiseux series \\spad{g(x)}."))) 
@@ -4594,7 +4594,7 @@ NIL
 NIL 
 (|UnivariatePuiseuxSeriesCategory| |Coef|) 
 ((|constructor| (NIL "\\spadtype{UnivariatePuiseuxSeriesCategory} is the category of Puiseux series in one variable.")) (|integrate| (($ $ (|Symbol|)) "\\spad{integrate(f(x),y)} returns an anti-derivative of the power series \\spad{f(x)} with respect to the variable \\spad{y}.") (($ $ (|Symbol|)) "\\spad{integrate(f(x),var)} returns an anti-derivative of the power series \\spad{f(x)} with respect to the variable \\spad{var}.") (($ $) "\\spad{integrate(f(x))} returns an anti-derivative of the power series \\spad{f(x)} with constant coefficient 1. We may integrate a series when we can divide coefficients by rational numbers.")) (|multiplyExponents| (($ $ (|Fraction| (|Integer|))) "\\spad{multiplyExponents(f,r)} multiplies all exponents of the power series \\spad{f} by the positive rational number \\spad{r}.")) (|series| (($ (|NonNegativeInteger|) (|Stream| (|Record| (|:| |k| (|Fraction| (|Integer|))) (|:| |c| |#1|)))) "\\spad{series(n,st)} creates a series from a common denomiator and a stream of non-zero terms,{} where a term is an exponent-coefficient pair. The terms in the stream should be ordered by increasing order of exponents and \\spad{n} should be a common denominator for the exponents in the stream of terms."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| . #1=((|Field|))) (|canonicalsClosed| |has| |#1| . #1#) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (|Field|))) 
 NIL 
 (|UnivariatePuiseuxSeriesConstructorCategory&| S |Coef| ULS) 
 ((|constructor| (NIL "This is a category of univariate Puiseux series constructed from univariate Laurent series. A Puiseux series is represented by a pair \\spad{[r,f(x)]},{} where \\spad{r} is a positive rational number and \\spad{f(x)} is a Laurent series. This pair represents the Puiseux series \\spad{f(x^r)}.")) (|laurentIfCan| (((|Union| |#3| "failed") $) "\\spad{laurentIfCan(f(x))} converts the Puiseux series \\spad{f(x)} to a Laurent series if possible. If this is not possible,{} \"failed\" is returned.")) (|laurent| ((|#3| $) "\\spad{laurent(f(x))} converts the Puiseux series \\spad{f(x)} to a Laurent series if possible. Error: if this is not possible.")) (|degree| (((|Fraction| (|Integer|)) $) "\\spad{degree(f(x))} returns the degree of the leading term of the Puiseux series \\spad{f(x)},{} which may have zero as a coefficient.")) (|laurentRep| ((|#3| $) "\\spad{laurentRep(f(x))} returns \\spad{g(x)} where the Puiseux series \\spad{f(x) = g(x^r)} is represented by \\spad{[r,g(x)]}.")) (|rationalPower| (((|Fraction| (|Integer|)) $) "\\spad{rationalPower(f(x))} returns \\spad{r} where the Puiseux series \\spad{f(x) = g(x^r)}.")) (|puiseux| (($ (|Fraction| (|Integer|)) |#3|) "\\spad{puiseux(r,f(x))} returns \\spad{f(x^r)}."))) 
@@ -4602,15 +4602,15 @@ NIL
 NIL 
 (|UnivariatePuiseuxSeriesConstructorCategory| |Coef| ULS) 
 ((|constructor| (NIL "This is a category of univariate Puiseux series constructed from univariate Laurent series. A Puiseux series is represented by a pair \\spad{[r,f(x)]},{} where \\spad{r} is a positive rational number and \\spad{f(x)} is a Laurent series. This pair represents the Puiseux series \\spad{f(x^r)}.")) (|laurentIfCan| (((|Union| |#2| "failed") $) "\\spad{laurentIfCan(f(x))} converts the Puiseux series \\spad{f(x)} to a Laurent series if possible. If this is not possible,{} \"failed\" is returned.")) (|laurent| ((|#2| $) "\\spad{laurent(f(x))} converts the Puiseux series \\spad{f(x)} to a Laurent series if possible. Error: if this is not possible.")) (|degree| (((|Fraction| (|Integer|)) $) "\\spad{degree(f(x))} returns the degree of the leading term of the Puiseux series \\spad{f(x)},{} which may have zero as a coefficient.")) (|laurentRep| ((|#2| $) "\\spad{laurentRep(f(x))} returns \\spad{g(x)} where the Puiseux series \\spad{f(x) = g(x^r)} is represented by \\spad{[r,g(x)]}.")) (|rationalPower| (((|Fraction| (|Integer|)) $) "\\spad{rationalPower(f(x))} returns \\spad{r} where the Puiseux series \\spad{f(x) = g(x^r)}.")) (|puiseux| (($ (|Fraction| (|Integer|)) |#2|) "\\spad{puiseux(r,f(x))} returns \\spad{f(x^r)}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| . #1=((|Field|))) (|canonicalsClosed| |has| |#1| . #1#) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (|Field|))) 
 NIL 
 (|UnivariatePuiseuxSeriesConstructor| |Coef| ULS) 
 ((|constructor| (NIL "This package enables one to construct a univariate Puiseux series domain from a univariate Laurent series domain. Univariate Puiseux series are represented by a pair \\spad{[r,f(x)]},{} where \\spad{r} is a positive rational number and \\spad{f(x)} is a Laurent series. This pair represents the Puiseux series \\spad{f(x^r)}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| . #1=((|Field|))) (|canonicalsClosed| |has| |#1| . #1#) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|canonicalUnitNormal| |has| |#1| (|Field|))) 
 (#1=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) #2=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (OR #2# #1#) (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (AND (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #3=(|Symbol|)))) #4=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #5=(|devaluate| |#1|) #6=(|%list| (QUOTE |Fraction|) (QUOTE #7=(|Integer|))) #5#)))) #4# (|HasCategory| #8=(|Fraction| #7#) (QUOTE (|SemiGroup|))) #9=(|HasCategory| |#1| (QUOTE (|Field|))) (OR #2# #9# #1#) (OR #9# #1#) (AND #10=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #5# #5# #6#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #5# #11=(QUOTE #3#))))) #10# (OR (AND #12=(|HasCategory| |#1| (QUOTE (|Algebra| #8#))) (|HasCategory| |#1| (QUOTE (|AlgebraicallyClosedFunctionSpace| #7#))) (|HasCategory| |#1| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) (AND #12# (|HasSignature| |#1| (|%list| (QUOTE |integrate|) (|%list| #5# #5# #11#))) (|HasSignature| |#1| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #11#) #5#))))) #12#) 
 (|UnivariatePuiseuxSeriesWithExponentialSingularity| R FE |var| |cen|) 
 ((|constructor| (NIL "UnivariatePuiseuxSeriesWithExponentialSingularity is a domain used to represent functions with essential singularities. Objects in this domain are sums,{} where each term in the sum is a univariate Puiseux series times the exponential of a univariate Puiseux series. Thus,{} the elements of this domain are sums of expressions of the form \\spad{g(x) * exp(f(x))},{} where \\spad{g}(\\spad{x}) is a univariate Puiseux series and \\spad{f}(\\spad{x}) is a univariate Puiseux series with no terms of non-negative degree.")) (|dominantTerm| (((|Union| (|Record| (|:| |%term| (|Record| (|:| |%coef| (|UnivariatePuiseuxSeries| |#2| |#3| |#4|)) (|:| |%expon| (|ExponentialOfUnivariatePuiseuxSeries| |#2| |#3| |#4|)) (|:| |%expTerms| (|List| (|Record| (|:| |k| (|Fraction| (|Integer|))) (|:| |c| |#2|)))))) (|:| |%type| (|String|))) "failed") $) "\\spad{dominantTerm(f(var))} returns the term that dominates the limiting behavior of \\spad{f(var)} as \\spad{var -> cen+} together with a \\spadtype{String} which briefly describes that behavior. The value of the \\spadtype{String} will be \\spad{\"zero\"} (resp. \\spad{\"infinity\"}) if the term tends to zero (resp. infinity) exponentially and will \\spad{\"series\"} if the term is a Puiseux series.")) (|limitPlus| (((|Union| (|OrderedCompletion| |#2|) "failed") $) "\\spad{limitPlus(f(var))} returns \\spad{limit(var -> cen+,f(var))}."))) 
-(((|commutative| "*") |has| #1=(|UnivariatePuiseuxSeries| |#2| |#3| |#4|) (|CommutativeRing|)) (|noZeroDivisors| |has| #1# (|IntegralDomain|)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| #1=(|UnivariatePuiseuxSeries| |#2| |#3| |#4|) (|CommutativeRing|)) (|noZeroDivisors| |has| #1# (|IntegralDomain|))) 
 (#1=(|HasCategory| #2=(|UnivariatePuiseuxSeries| |#2| |#3| |#4|) (QUOTE (|Algebra| #3=(|Fraction| #4=(|Integer|))))) (|HasCategory| #2# (QUOTE (|CharacteristicNonZero|))) (|HasCategory| #2# (QUOTE (|CharacteristicZero|))) (|HasCategory| #2# (QUOTE (|CommutativeRing|))) (OR #1# #5=(|HasCategory| #2# (QUOTE (|RetractableTo| #3#)))) #5# (|HasCategory| #2# (QUOTE (|RetractableTo| #4#))) (|HasCategory| #2# (QUOTE (|Field|))) (|HasCategory| #2# (QUOTE (|GcdDomain|))) (|HasCategory| #2# (QUOTE (|IntegralDomain|)))) 
 (|UnaryRecursiveAggregate&| A S) 
 ((|constructor| (NIL "A unary-recursive aggregate is a one where nodes may have either 0 or 1 children. This aggregate models,{} though not precisely,{} a linked list possibly with a single cycle. A node with one children models a non-empty list,{} with the \\spadfun{value} of the list designating the head,{} or \\spadfun{first},{} of the list,{} and the child designating the tail,{} or \\spadfun{rest},{} of the list. A node with no child then designates the empty list. Since these aggregates are recursive aggregates,{} they may be cyclic.")) (|split!| (($ $ (|Integer|)) "\\spad{split!(u,n)} splits \\spad{u} into two aggregates: \\axiom{\\spad{v} = rest(\\spad{u},{}\\spad{n})} and \\axiom{\\spad{w} = first(\\spad{u},{}\\spad{n})},{} returning \\axiom{\\spad{v}}. Note: afterwards \\axiom{rest(\\spad{u},{}\\spad{n})} returns \\axiom{empty()}.")) (|setlast!| ((|#2| $ |#2|) "\\spad{setlast!(u,x)} destructively changes the last element of \\spad{u} to \\spad{x}.")) (|setrest!| (($ $ $) "\\spad{setrest!(u,v)} destructively changes the rest of \\spad{u} to \\spad{v}.")) (|setelt| ((|#2| $ "last" |#2|) "\\spad{setelt(u,\"last\",x)} (also written: \\axiom{\\spad{u}.last := \\spad{b}}) is equivalent to \\axiom{setlast!(\\spad{u},{}\\spad{v})}.") (($ $ "rest" $) "\\spad{setelt(u,\"rest\",v)} (also written: \\axiom{\\spad{u}.rest := \\spad{v}}) is equivalent to \\axiom{setrest!(\\spad{u},{}\\spad{v})}.") ((|#2| $ "first" |#2|) "\\spad{setelt(u,\"first\",x)} (also written: \\axiom{\\spad{u}.first := \\spad{x}}) is equivalent to \\axiom{setfirst!(\\spad{u},{}\\spad{x})}.")) (|setfirst!| ((|#2| $ |#2|) "\\spad{setfirst!(u,x)} destructively changes the first element of a to \\spad{x}.")) (|cycleSplit!| (($ $) "\\spad{cycleSplit!(u)} splits the aggregate by dropping off the cycle. The value returned is the cycle entry,{} or nil if none exists. For example,{} if \\axiom{\\spad{w} = concat(\\spad{u},{}\\spad{v})} is the cyclic list where \\spad{v} is the head of the cycle,{} \\axiom{cycleSplit!(\\spad{w})} will drop \\spad{v} off \\spad{w} thus destructively changing \\spad{w} to \\spad{u},{} and returning \\spad{v}.")) (|concat!| (($ $ |#2|) "\\spad{concat!(u,x)} destructively adds element \\spad{x} to the end of \\spad{u}. Note: \\axiom{concat!(a,{}\\spad{x}) = setlast!(a,{}[\\spad{x}])}.") (($ $ $) "\\spad{concat!(u,v)} destructively concatenates \\spad{v} to the end of \\spad{u}. Note: \\axiom{concat!(\\spad{u},{}\\spad{v}) = setlast!(\\spad{u},{}\\spad{v})}.")) (|cycleTail| (($ $) "\\spad{cycleTail(u)} returns the last node in the cycle,{} or empty if none exists.")) (|cycleLength| (((|NonNegativeInteger|) $) "\\spad{cycleLength(u)} returns the length of a top-level cycle contained in aggregate \\spad{u},{} or 0 is \\spad{u} has no such cycle.")) (|cycleEntry| (($ $) "\\spad{cycleEntry(u)} returns the head of a top-level cycle contained in aggregate \\spad{u},{} or \\axiom{empty()} if none exists.")) (|third| ((|#2| $) "\\spad{third(u)} returns the third element of \\spad{u}. Note: \\axiom{third(\\spad{u}) = first(rest(rest(\\spad{u})))}.")) (|second| ((|#2| $) "\\spad{second(u)} returns the second element of \\spad{u}. Note: \\axiom{second(\\spad{u}) = first(rest(\\spad{u}))}.")) (|tail| (($ $) "\\spad{tail(u)} returns the last node of \\spad{u}. Note: if \\spad{u} is \\axiom{shallowlyMutable},{} \\axiom{setrest(tail(\\spad{u}),{}\\spad{v}) = concat(\\spad{u},{}\\spad{v})}.")) (|last| (($ $ (|NonNegativeInteger|)) "\\spad{last(u,n)} returns a copy of the last \\spad{n} (\\axiom{\\spad{n} >= 0}) nodes of \\spad{u}. Note: \\axiom{last(\\spad{u},{}\\spad{n})} is a list of \\spad{n} elements.") ((|#2| $) "\\spad{last(u)} resturn the last element of \\spad{u}. Note: for lists,{} \\axiom{last(\\spad{u}) = \\spad{u} . (maxIndex \\spad{u}) = \\spad{u} . (\\# \\spad{u} - 1)}.")) (|rest| (($ $ (|NonNegativeInteger|)) "\\spad{rest(u,n)} returns the \\axiom{\\spad{n}}th (\\spad{n} >= 0) node of \\spad{u}. Note: \\axiom{rest(\\spad{u},{}0) = \\spad{u}}.") (($ $) "\\spad{rest(u)} returns an aggregate consisting of all but the first element of \\spad{u} (equivalently,{} the next node of \\spad{u}).")) (|elt| ((|#2| $ "last") "\\spad{elt(u,\"last\")} (also written: \\axiom{\\spad{u} . last}) is equivalent to last \\spad{u}.") (($ $ "rest") "\\spad{elt(\\%,\"rest\")} (also written: \\axiom{\\spad{u}.rest}) is equivalent to \\axiom{rest \\spad{u}}.") ((|#2| $ "first") "\\spad{elt(u,\"first\")} (also written: \\axiom{\\spad{u} . first}) is equivalent to first \\spad{u}.")) (|first| (($ $ (|NonNegativeInteger|)) "\\spad{first(u,n)} returns a copy of the first \\spad{n} (\\axiom{\\spad{n} >= 0}) elements of \\spad{u}.") ((|#2| $) "\\spad{first(u)} returns the first element of \\spad{u} (equivalently,{} the value at the current node).")) (|concat| (($ |#2| $) "\\spad{concat(x,u)} returns aggregate consisting of \\spad{x} followed by the elements of \\spad{u}. Note: if \\axiom{\\spad{v} = concat(\\spad{x},{}\\spad{u})} then \\axiom{\\spad{x} = first \\spad{v}} and \\axiom{\\spad{u} = rest \\spad{v}}.") (($ $ $) "\\spad{concat(u,v)} returns an aggregate \\spad{w} consisting of the elements of \\spad{u} followed by the elements of \\spad{v}. Note: \\axiom{\\spad{v} = rest(\\spad{w},{}\\#a)}."))) 
@@ -4622,7 +4622,7 @@ NIL
 NIL 
 (|UnivariateTaylorSeries| |Coef| |var| |cen|) 
 ((|constructor| (NIL "Dense Taylor series in one variable \\spadtype{UnivariateTaylorSeries} is a domain representing Taylor series in one variable with coefficients in an arbitrary ring. The parameters of the type specify the coefficient ring,{} the power series variable,{} and the center of the power series expansion. For example,{} \\spadtype{UnivariateTaylorSeries}(Integer,{}\\spad{x},{}3) represents Taylor series in \\spad{(x - 3)} with \\spadtype{Integer} coefficients.")) (|integrate| (($ $ (|Variable| |#2|)) "\\spad{integrate(f(x),x)} returns an anti-derivative of the power series \\spad{f(x)} with constant coefficient 0. We may integrate a series when we can divide coefficients by integers.")) (|invmultisect| (($ (|Integer|) (|Integer|) $) "\\spad{invmultisect(a,b,f(x))} substitutes \\spad{x^((a+b)*n)} \\indented{1}{for \\spad{x^n} and multiples by \\spad{x^b}.}")) (|multisect| (($ (|Integer|) (|Integer|) $) "\\spad{multisect(a,b,f(x))} selects the coefficients of \\indented{1}{\\spad{x^((a+b)*n+a)},{} and changes this monomial to \\spad{x^n}.}")) (|revert| (($ $) "\\spad{revert(f(x))} returns a Taylor series \\spad{g(x)} such that \\spad{f(g(x)) = g(f(x)) = x}. Series \\spad{f(x)} should have constant coefficient 0 and invertible 1st order coefficient.")) (|generalLambert| (($ $ (|Integer|) (|Integer|)) "\\spad{generalLambert(f(x),a,d)} returns \\spad{f(x^a) + f(x^(a + d)) + \\indented{1}{f(x^(a + 2 d)) + ... }. \\spad{f(x)} should have zero constant} \\indented{1}{coefficient and \\spad{a} and \\spad{d} should be positive.}")) (|evenlambert| (($ $) "\\spad{evenlambert(f(x))} returns \\spad{f(x^2) + f(x^4) + f(x^6) + ...}. \\indented{1}{\\spad{f(x)} should have a zero constant coefficient.} \\indented{1}{This function is used for computing infinite products.} \\indented{1}{If \\spad{f(x)} is a Taylor series with constant term 1,{} then} \\indented{1}{\\spad{product(n=1..infinity,f(x^(2*n))) = exp(log(evenlambert(f(x))))}.}")) (|oddlambert| (($ $) "\\spad{oddlambert(f(x))} returns \\spad{f(x) + f(x^3) + f(x^5) + ...}. \\indented{1}{\\spad{f(x)} should have a zero constant coefficient.} \\indented{1}{This function is used for computing infinite products.} \\indented{1}{If \\spad{f(x)} is a Taylor series with constant term 1,{} then} \\indented{1}{\\spad{product(n=1..infinity,f(x^(2*n-1)))=exp(log(oddlambert(f(x))))}.}")) (|lambert| (($ $) "\\spad{lambert(f(x))} returns \\spad{f(x) + f(x^2) + f(x^3) + ...}. \\indented{1}{This function is used for computing infinite products.} \\indented{1}{\\spad{f(x)} should have zero constant coefficient.} \\indented{1}{If \\spad{f(x)} is a Taylor series with constant term 1,{} then} \\indented{1}{\\spad{product(n = 1..infinity,f(x^n)) = exp(log(lambert(f(x))))}.}")) (|lagrange| (($ $) "\\spad{lagrange(g(x))} produces the Taylor series for \\spad{f(x)} \\indented{1}{where \\spad{f(x)} is implicitly defined as \\spad{f(x) = x*g(f(x))}.}")) (|univariatePolynomial| (((|UnivariatePolynomial| |#2| |#1|) $ (|NonNegativeInteger|)) "\\spad{univariatePolynomial(f,k)} returns a univariate polynomial \\indented{1}{consisting of the sum of all terms of \\spad{f} of degree \\spad{<= k}.}")) (|coerce| (($ (|Variable| |#2|)) "\\spad{coerce(var)} converts the series variable \\spad{var} into a \\indented{1}{Taylor series.}") (($ (|UnivariatePolynomial| |#2| |#1|)) "\\spad{coerce(p)} converts a univariate polynomial \\spad{p} in the variable \\spad{var} to a univariate Taylor series in \\spad{var}."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|))) 
 (#1=(|HasCategory| |#1| (QUOTE (|Algebra| (|Fraction| #2=(|Integer|))))) #3=(|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (OR #4=(|HasCategory| |#1| (QUOTE (|CommutativeRing|))) #3#) #4# (|HasCategory| |#1| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#1| (QUOTE (|CharacteristicZero|))) (AND (|HasCategory| |#1| (QUOTE (|PartialDifferentialRing| #5=(|Symbol|)))) #6=(|HasSignature| |#1| (|%list| (QUOTE *) (|%list| #7=(|devaluate| |#1|) #8=(QUOTE #9=(|NonNegativeInteger|)) #7#)))) #6# (|HasCategory| #9# (QUOTE (|SemiGroup|))) (AND #10=(|HasSignature| |#1| (|%list| (QUOTE **) (|%list| #7# #7# #8#))) (|HasSignature| |#1| (|%list| (QUOTE |coerce|) (|%list| #7# #11=(QUOTE #5#))))) #10# (|HasCategory| |#1| (QUOTE (|Field|))) (OR (AND #1# (|HasCategory| |#1| (QUOTE (|AlgebraicallyClosedFunctionSpace| #2#))) (|HasCategory| |#1| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#1| (QUOTE (|TranscendentalFunctionCategory|)))) (AND #1# (|HasSignature| |#1| (|%list| (QUOTE |integrate|) (|%list| #7# #7# #11#))) (|HasSignature| |#1| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #11#) #7#)))))) 
 (|UnivariateTaylorSeriesFunctions2| |Coef1| |Coef2| UTS1 UTS2) 
 ((|constructor| (NIL "Mapping package for univariate Taylor series. \\indented{2}{This package allows one to apply a function to the coefficients of} \\indented{2}{a univariate Taylor series.}")) (|map| ((|#4| (|Mapping| |#2| |#1|) |#3|) "\\spad{map(f,g(x))} applies the map \\spad{f} to the coefficients of \\indented{1}{the Taylor series \\spad{g(x)}.}"))) 
@@ -4634,7 +4634,7 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|AlgebraicallyClosedFunctionSpace| #1=(|Integer|)))) (|HasCategory| |#2| (QUOTE (|PrimitiveFunctionCategory|))) (|HasCategory| |#2| (QUOTE (|TranscendentalFunctionCategory|))) (|HasSignature| |#2| (|%list| (QUOTE |variables|) (|%list| (|%list| (QUOTE |List|) #2=(QUOTE (|Symbol|))) #3=(|devaluate| |#2|)))) (|HasSignature| |#2| (|%list| (QUOTE |integrate|) (|%list| #3# #3# #2#))) (|HasCategory| |#2| (QUOTE (|Algebra| (|Fraction| #1#)))) (|HasCategory| |#2| (QUOTE (|Field|)))) 
 (|UnivariateTaylorSeriesCategory| |Coef|) 
 ((|constructor| (NIL "\\spadtype{UnivariateTaylorSeriesCategory} is the category of Taylor series in one variable.")) (|integrate| (($ $ (|Symbol|)) "\\spad{integrate(f(x),y)} returns an anti-derivative of the power series \\spad{f(x)} with respect to the variable \\spad{y}.") (($ $ (|Symbol|)) "\\spad{integrate(f(x),y)} returns an anti-derivative of the power series \\spad{f(x)} with respect to the variable \\spad{y}.") (($ $) "\\spad{integrate(f(x))} returns an anti-derivative of the power series \\spad{f(x)} with constant coefficient 0. We may integrate a series when we can divide coefficients by integers.")) (** (($ $ |#1|) "\\spad{f(x) ** a} computes a power of a power series. When the coefficient ring is a field,{} we may raise a series to an exponent from the coefficient ring provided that the constant coefficient of the series is 1.")) (|polynomial| (((|Polynomial| |#1|) $ (|NonNegativeInteger|) (|NonNegativeInteger|)) "\\spad{polynomial(f,k1,k2)} returns a polynomial consisting of the sum of all terms of \\spad{f} of degree \\spad{d} with \\spad{k1 <= d <= k2}.") (((|Polynomial| |#1|) $ (|NonNegativeInteger|)) "\\spad{polynomial(f,k)} returns a polynomial consisting of the sum of all terms of \\spad{f} of degree \\spad{<= k}.")) (|multiplyCoefficients| (($ (|Mapping| |#1| (|Integer|)) $) "\\spad{multiplyCoefficients(f,sum(n = 0..infinity,a[n] * x**n))} returns \\spad{sum(n = 0..infinity,f(n) * a[n] * x**n)}. This function is used when Laurent series are represented by a Taylor series and an order.")) (|quoByVar| (($ $) "\\spad{quoByVar(a0 + a1 x + a2 x**2 + ...)} returns \\spad{a1 + a2 x + a3 x**2 + ...} Thus,{} this function substracts the constant term and divides by the series variable. This function is used when Laurent series are represented by a Taylor series and an order.")) (|coefficients| (((|Stream| |#1|) $) "\\spad{coefficients(a0 + a1 x + a2 x**2 + ...)} returns a stream of coefficients: \\spad{[a0,a1,a2,...]}. The entries of the stream may be zero.")) (|series| (($ (|Stream| |#1|)) "\\spad{series([a0,a1,a2,...])} is the Taylor series \\spad{a0 + a1 x + a2 x**2 + ...}.") (($ (|Stream| (|Record| (|:| |k| (|NonNegativeInteger|)) (|:| |c| |#1|)))) "\\spad{series(st)} creates a series from a stream of non-zero terms,{} where a term is an exponent-coefficient pair. The terms in the stream should be ordered by increasing order of exponents."))) 
-(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|)) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") |has| |#1| (|CommutativeRing|)) (|noZeroDivisors| |has| |#1| (|IntegralDomain|))) 
 NIL 
 (|UnivariateTaylorSeriesODESolver| |Coef| UTS) 
 ((|constructor| (NIL "\\indented{1}{This package provides Taylor series solutions to regular} linear or non-linear ordinary differential equations of arbitrary order.")) (|mpsode| (((|List| |#2|) (|List| |#1|) (|List| (|Mapping| |#2| (|List| |#2|)))) "\\spad{mpsode(r,f)} solves the system of differential equations \\spad{dy[i]/dx =f[i] [x,y[1],y[2],...,y[n]]},{} \\spad{y[i](a) = r[i]} for \\spad{i} in 1..\\spad{n}.")) (|ode| ((|#2| (|Mapping| |#2| (|List| |#2|)) (|List| |#1|)) "\\spad{ode(f,cl)} is the solution to \\spad{y<n>=f(y,y',..,y<n-1>)} such that \\spad{y<i>(a) = cl.i} for \\spad{i} in 1..\\spad{n}.")) (|ode2| ((|#2| (|Mapping| |#2| |#2| |#2|) |#1| |#1|) "\\spad{ode2(f,c0,c1)} is the solution to \\spad{y'' = f(y,y')} such that \\spad{y(a) = c0} and \\spad{y'(a) = c1}.")) (|ode1| ((|#2| (|Mapping| |#2| |#2|) |#1|) "\\spad{ode1(f,c)} is the solution to \\spad{y' = f(y)} such that \\spad{y(a) = c}.")) (|fixedPointExquo| ((|#2| |#2| |#2|) "\\spad{fixedPointExquo(f,g)} computes the exact quotient of \\spad{f} and \\spad{g} using a fixed point computation.")) (|stFuncN| (((|Mapping| (|Stream| |#1|) (|List| (|Stream| |#1|))) (|Mapping| |#2| (|List| |#2|))) "\\spad{stFuncN(f)} is a local function xported due to compiler problem. This function is of no interest to the top-level user.")) (|stFunc2| (((|Mapping| (|Stream| |#1|) (|Stream| |#1|) (|Stream| |#1|)) (|Mapping| |#2| |#2| |#2|)) "\\spad{stFunc2(f)} is a local function exported due to compiler problem. This function is of no interest to the top-level user.")) (|stFunc1| (((|Mapping| (|Stream| |#1|) (|Stream| |#1|)) (|Mapping| |#2| |#2|)) "\\spad{stFunc1(f)} is a local function exported due to compiler problem. This function is of no interest to the top-level user."))) 
@@ -4649,7 +4649,7 @@ NIL
 NIL 
 NIL 
 (|Variable| |sym|) 
-((|constructor| (NIL "This domain implements variables")) (|variable| (((|Symbol|)) "\\spad{variable()} returns the symbol")) (|coerce| (((|Symbol|) $) "\\spad{coerce(x)} returns the symbol"))) 
+((|constructor| (NIL "This domain implements variables")) (|variable| (((|Symbol|)) "\\spad{variable()} returns the symbol"))) 
 NIL 
 NIL 
 (|VectorCategory&| S R) 
@@ -4673,7 +4673,7 @@ NIL
 NIL 
 NIL 
 (|TwoDimensionalViewport|) 
-((|constructor| (NIL "TwoDimensionalViewport creates viewports to display graphs.")) (|coerce| (((|OutputForm|) $) "\\spad{coerce(v)} returns the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport} as output of the domain \\spadtype{OutputForm}.")) (|key| (((|Integer|) $) "\\spad{key(v)} returns the process ID number of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport}.")) (|reset| (((|Void|) $) "\\spad{reset(v)} sets the current state of the graph characteristics of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} back to their initial settings.")) (|write| (((|String|) $ (|String|) (|List| (|String|))) "\\spad{write(v,s,lf)} takes the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} and creates a directory indicated by \\spad{s},{} which contains the graph data files for \\spad{v} and the optional file types indicated by the list \\spad{lf}.") (((|String|) $ (|String|) (|String|)) "\\spad{write(v,s,f)} takes the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} and creates a directory indicated by \\spad{s},{} which contains the graph data files for \\spad{v} and an optional file type \\spad{f}.") (((|String|) $ (|String|)) "\\spad{write(v,s)} takes the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} and creates a directory indicated by \\spad{s},{} which contains the graph data files for \\spad{v}.")) (|resize| (((|Void|) $ (|PositiveInteger|) (|PositiveInteger|)) "\\spad{resize(v,w,h)} displays the two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} with a width of \\spad{w} and a height of \\spad{h},{} keeping the upper left-hand corner position unchanged.")) (|update| (((|Void|) $ (|GraphImage|) (|PositiveInteger|)) "\\spad{update(v,gr,n)} drops the graph \\spad{gr} in slot \\spad{n} of viewport \\spad{v}. The graph \\spad{gr} must have been transmitted already and acquired an integer key.")) (|move| (((|Void|) $ (|NonNegativeInteger|) (|NonNegativeInteger|)) "\\spad{move(v,x,y)} displays the two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} with the upper left-hand corner of the viewport window at the screen coordinate position \\spad{x},{} \\spad{y}.")) (|show| (((|Void|) $ (|PositiveInteger|) (|String|)) "\\spad{show(v,n,s)} displays the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or does not display the graph if \\spad{s} is \"off\".")) (|translate| (((|Void|) $ (|PositiveInteger|) (|Float|) (|Float|)) "\\spad{translate(v,n,dx,dy)} displays the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} translated by \\spad{dx} in the \\spad{x}-coordinate direction from the center of the viewport,{} and by \\spad{dy} in the \\spad{y}-coordinate direction from the center. Setting \\spad{dx} and \\spad{dy} to \\spad{0} places the center of the graph at the center of the viewport.")) (|scale| (((|Void|) $ (|PositiveInteger|) (|Float|) (|Float|)) "\\spad{scale(v,n,sx,sy)} displays the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} scaled by the factor \\spad{sx} in the \\spad{x}-coordinate direction and by the factor \\spad{sy} in the \\spad{y}-coordinate direction.")) (|dimensions| (((|Void|) $ (|NonNegativeInteger|) (|NonNegativeInteger|) (|PositiveInteger|) (|PositiveInteger|)) "\\spad{dimensions(v,x,y,width,height)} sets the position of the upper left-hand corner of the two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} to the window coordinate \\spad{x},{} \\spad{y},{} and sets the dimensions of the window to that of \\spad{width},{} \\spad{height}. The new dimensions are not displayed until the function \\spadfun{makeViewport2D} is executed again for \\spad{v}.")) (|close| (((|Void|) $) "\\spad{close(v)} closes the viewport window of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} and terminates the corresponding process ID.")) (|controlPanel| (((|Void|) $ (|String|)) "\\spad{controlPanel(v,s)} displays the control panel of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or hides the control panel if \\spad{s} is \"off\".")) (|connect| (((|Void|) $ (|PositiveInteger|) (|String|)) "\\spad{connect(v,n,s)} displays the lines connecting the graph points in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or does not display the lines if \\spad{s} is \"off\".")) (|region| (((|Void|) $ (|PositiveInteger|) (|String|)) "\\spad{region(v,n,s)} displays the bounding box of the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or does not display the bounding box if \\spad{s} is \"off\".")) (|points| (((|Void|) $ (|PositiveInteger|) (|String|)) "\\spad{points(v,n,s)} displays the points of the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or does not display the points if \\spad{s} is \"off\".")) (|units| (((|Void|) $ (|PositiveInteger|) (|Palette|)) "\\spad{units(v,n,c)} displays the units of the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} with the units color set to the given palette color \\spad{c}.") (((|Void|) $ (|PositiveInteger|) (|String|)) "\\spad{units(v,n,s)} displays the units of the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or does not display the units if \\spad{s} is \"off\".")) (|axes| (((|Void|) $ (|PositiveInteger|) (|Palette|)) "\\spad{axes(v,n,c)} displays the axes of the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} with the axes color set to the given palette color \\spad{c}.") (((|Void|) $ (|PositiveInteger|) (|String|)) "\\spad{axes(v,n,s)} displays the axes of the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or does not display the axes if \\spad{s} is \"off\".")) (|getGraph| (((|GraphImage|) $ (|PositiveInteger|)) "\\spad{getGraph(v,n)} returns the graph which is of the domain \\spadtype{GraphImage} which is located in graph field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of the domain \\spadtype{TwoDimensionalViewport}.")) (|putGraph| (((|Void|) $ (|GraphImage|) (|PositiveInteger|)) "\\spad{putGraph(v,gi,n)} sets the graph field indicated by \\spad{n},{} of the indicated two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} to be the graph,{} \\spad{gi} of domain \\spadtype{GraphImage}. The contents of viewport,{} \\spad{v},{} will contain \\spad{gi} when the function \\spadfun{makeViewport2D} is called to create the an updated viewport \\spad{v}.")) (|title| (((|Void|) $ (|String|)) "\\spad{title(v,s)} changes the title which is shown in the two-dimensional viewport window,{} \\spad{v} of domain \\spadtype{TwoDimensionalViewport}.")) (|graphs| (((|Vector| (|Union| (|GraphImage|) "undefined")) $) "\\spad{graphs(v)} returns a vector,{} or list,{} which is a union of all the graphs,{} of the domain \\spadtype{GraphImage},{} which are allocated for the two-dimensional viewport,{} \\spad{v},{} of domain \\spadtype{TwoDimensionalViewport}. Those graphs which have no data are labeled \"undefined\",{} otherwise their contents are shown.")) (|graphStates| (((|Vector| (|Record| (|:| |scaleX| (|DoubleFloat|)) (|:| |scaleY| (|DoubleFloat|)) (|:| |deltaX| (|DoubleFloat|)) (|:| |deltaY| (|DoubleFloat|)) (|:| |points| (|Integer|)) (|:| |connect| (|Integer|)) (|:| |spline| (|Integer|)) (|:| |axes| (|Integer|)) (|:| |axesColor| (|Palette|)) (|:| |units| (|Integer|)) (|:| |unitsColor| (|Palette|)) (|:| |showing| (|Integer|)))) $) "\\spad{graphStates(v)} returns and shows a listing of a record containing the current state of the characteristics of each of the ten graph records in the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport}.")) (|graphState| (((|Void|) $ (|PositiveInteger|) (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|) (|Integer|) (|Integer|) (|Integer|) (|Integer|) (|Palette|) (|Integer|) (|Palette|) (|Integer|)) "\\spad{graphState(v,num,sX,sY,dX,dY,pts,lns,box,axes,axesC,un,unC,cP)} sets the state of the characteristics for the graph indicated by \\spad{num} in the given two-dimensional viewport \\spad{v},{} of domain \\spadtype{TwoDimensionalViewport},{} to the values given as parameters. The scaling of the graph in the \\spad{x} and \\spad{y} component directions is set to be \\spad{sX} and \\spad{sY}; the window translation in the \\spad{x} and \\spad{y} component directions is set to be \\spad{dX} and \\spad{dY}; The graph points,{} lines,{} bounding \\spad{box},{} \\spad{axes},{} or units will be shown in the viewport if their given parameters \\spad{pts},{} \\spad{lns},{} \\spad{box},{} \\spad{axes} or \\spad{un} are set to be \\spad{1},{} but will not be shown if they are set to \\spad{0}. The color of the \\spad{axes} and the color of the units are indicated by the palette colors \\spad{axesC} and \\spad{unC} respectively. To display the control panel when the viewport window is displayed,{} set \\spad{cP} to \\spad{1},{} otherwise set it to \\spad{0}.")) (|options| (($ $ (|List| (|DrawOption|))) "\\spad{options(v,lopt)} takes the given two-dimensional viewport,{} \\spad{v},{} of the domain \\spadtype{TwoDimensionalViewport} and returns \\spad{v} with it's draw options modified to be those which are indicated in the given list,{} \\spad{lopt} of domain \\spadtype{DrawOption}.") (((|List| (|DrawOption|)) $) "\\spad{options(v)} takes the given two-dimensional viewport,{} \\spad{v},{} of the domain \\spadtype{TwoDimensionalViewport} and returns a list containing the draw options from the domain \\spadtype{DrawOption} for \\spad{v}.")) (|makeViewport2D| (($ (|GraphImage|) (|List| (|DrawOption|))) "\\spad{makeViewport2D(gi,lopt)} creates and displays a viewport window of the domain \\spadtype{TwoDimensionalViewport} whose graph field is assigned to be the given graph,{} \\spad{gi},{} of domain \\spadtype{GraphImage},{} and whose options field is set to be the list of options,{} \\spad{lopt} of domain \\spadtype{DrawOption}.") (($ $) "\\spad{makeViewport2D(v)} takes the given two-dimensional viewport,{} \\spad{v},{} of the domain \\spadtype{TwoDimensionalViewport} and displays a viewport window on the screen which contains the contents of \\spad{v}.")) (|viewport2D| (($) "\\spad{viewport2D()} returns an undefined two-dimensional viewport of the domain \\spadtype{TwoDimensionalViewport} whose contents are empty.")) (|getPickedPoints| (((|List| (|Point| (|DoubleFloat|))) $) "\\spad{getPickedPoints(x)} returns a list of small floats for the points the user interactively picked on the viewport for full integration into the system,{} some design issues need to be addressed: \\spadignore{e.g.} how to go through the GraphImage interface,{} how to default to graphs,{} etc."))) 
+((|constructor| (NIL "TwoDimensionalViewport creates viewports to display graphs.")) (|key| (((|Integer|) $) "\\spad{key(v)} returns the process ID number of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport}.")) (|reset| (((|Void|) $) "\\spad{reset(v)} sets the current state of the graph characteristics of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} back to their initial settings.")) (|write| (((|String|) $ (|String|) (|List| (|String|))) "\\spad{write(v,s,lf)} takes the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} and creates a directory indicated by \\spad{s},{} which contains the graph data files for \\spad{v} and the optional file types indicated by the list \\spad{lf}.") (((|String|) $ (|String|) (|String|)) "\\spad{write(v,s,f)} takes the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} and creates a directory indicated by \\spad{s},{} which contains the graph data files for \\spad{v} and an optional file type \\spad{f}.") (((|String|) $ (|String|)) "\\spad{write(v,s)} takes the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} and creates a directory indicated by \\spad{s},{} which contains the graph data files for \\spad{v}.")) (|resize| (((|Void|) $ (|PositiveInteger|) (|PositiveInteger|)) "\\spad{resize(v,w,h)} displays the two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} with a width of \\spad{w} and a height of \\spad{h},{} keeping the upper left-hand corner position unchanged.")) (|update| (((|Void|) $ (|GraphImage|) (|PositiveInteger|)) "\\spad{update(v,gr,n)} drops the graph \\spad{gr} in slot \\spad{n} of viewport \\spad{v}. The graph \\spad{gr} must have been transmitted already and acquired an integer key.")) (|move| (((|Void|) $ (|NonNegativeInteger|) (|NonNegativeInteger|)) "\\spad{move(v,x,y)} displays the two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} with the upper left-hand corner of the viewport window at the screen coordinate position \\spad{x},{} \\spad{y}.")) (|show| (((|Void|) $ (|PositiveInteger|) (|String|)) "\\spad{show(v,n,s)} displays the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or does not display the graph if \\spad{s} is \"off\".")) (|translate| (((|Void|) $ (|PositiveInteger|) (|Float|) (|Float|)) "\\spad{translate(v,n,dx,dy)} displays the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} translated by \\spad{dx} in the \\spad{x}-coordinate direction from the center of the viewport,{} and by \\spad{dy} in the \\spad{y}-coordinate direction from the center. Setting \\spad{dx} and \\spad{dy} to \\spad{0} places the center of the graph at the center of the viewport.")) (|scale| (((|Void|) $ (|PositiveInteger|) (|Float|) (|Float|)) "\\spad{scale(v,n,sx,sy)} displays the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} scaled by the factor \\spad{sx} in the \\spad{x}-coordinate direction and by the factor \\spad{sy} in the \\spad{y}-coordinate direction.")) (|dimensions| (((|Void|) $ (|NonNegativeInteger|) (|NonNegativeInteger|) (|PositiveInteger|) (|PositiveInteger|)) "\\spad{dimensions(v,x,y,width,height)} sets the position of the upper left-hand corner of the two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} to the window coordinate \\spad{x},{} \\spad{y},{} and sets the dimensions of the window to that of \\spad{width},{} \\spad{height}. The new dimensions are not displayed until the function \\spadfun{makeViewport2D} is executed again for \\spad{v}.")) (|close| (((|Void|) $) "\\spad{close(v)} closes the viewport window of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} and terminates the corresponding process ID.")) (|controlPanel| (((|Void|) $ (|String|)) "\\spad{controlPanel(v,s)} displays the control panel of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or hides the control panel if \\spad{s} is \"off\".")) (|connect| (((|Void|) $ (|PositiveInteger|) (|String|)) "\\spad{connect(v,n,s)} displays the lines connecting the graph points in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or does not display the lines if \\spad{s} is \"off\".")) (|region| (((|Void|) $ (|PositiveInteger|) (|String|)) "\\spad{region(v,n,s)} displays the bounding box of the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or does not display the bounding box if \\spad{s} is \"off\".")) (|points| (((|Void|) $ (|PositiveInteger|) (|String|)) "\\spad{points(v,n,s)} displays the points of the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or does not display the points if \\spad{s} is \"off\".")) (|units| (((|Void|) $ (|PositiveInteger|) (|Palette|)) "\\spad{units(v,n,c)} displays the units of the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} with the units color set to the given palette color \\spad{c}.") (((|Void|) $ (|PositiveInteger|) (|String|)) "\\spad{units(v,n,s)} displays the units of the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or does not display the units if \\spad{s} is \"off\".")) (|axes| (((|Void|) $ (|PositiveInteger|) (|Palette|)) "\\spad{axes(v,n,c)} displays the axes of the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} with the axes color set to the given palette color \\spad{c}.") (((|Void|) $ (|PositiveInteger|) (|String|)) "\\spad{axes(v,n,s)} displays the axes of the graph in field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} if \\spad{s} is \"on\",{} or does not display the axes if \\spad{s} is \"off\".")) (|getGraph| (((|GraphImage|) $ (|PositiveInteger|)) "\\spad{getGraph(v,n)} returns the graph which is of the domain \\spadtype{GraphImage} which is located in graph field \\spad{n} of the given two-dimensional viewport,{} \\spad{v},{} which is of the domain \\spadtype{TwoDimensionalViewport}.")) (|putGraph| (((|Void|) $ (|GraphImage|) (|PositiveInteger|)) "\\spad{putGraph(v,gi,n)} sets the graph field indicated by \\spad{n},{} of the indicated two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport},{} to be the graph,{} \\spad{gi} of domain \\spadtype{GraphImage}. The contents of viewport,{} \\spad{v},{} will contain \\spad{gi} when the function \\spadfun{makeViewport2D} is called to create the an updated viewport \\spad{v}.")) (|title| (((|Void|) $ (|String|)) "\\spad{title(v,s)} changes the title which is shown in the two-dimensional viewport window,{} \\spad{v} of domain \\spadtype{TwoDimensionalViewport}.")) (|graphs| (((|Vector| (|Union| (|GraphImage|) "undefined")) $) "\\spad{graphs(v)} returns a vector,{} or list,{} which is a union of all the graphs,{} of the domain \\spadtype{GraphImage},{} which are allocated for the two-dimensional viewport,{} \\spad{v},{} of domain \\spadtype{TwoDimensionalViewport}. Those graphs which have no data are labeled \"undefined\",{} otherwise their contents are shown.")) (|graphStates| (((|Vector| (|Record| (|:| |scaleX| (|DoubleFloat|)) (|:| |scaleY| (|DoubleFloat|)) (|:| |deltaX| (|DoubleFloat|)) (|:| |deltaY| (|DoubleFloat|)) (|:| |points| (|Integer|)) (|:| |connect| (|Integer|)) (|:| |spline| (|Integer|)) (|:| |axes| (|Integer|)) (|:| |axesColor| (|Palette|)) (|:| |units| (|Integer|)) (|:| |unitsColor| (|Palette|)) (|:| |showing| (|Integer|)))) $) "\\spad{graphStates(v)} returns and shows a listing of a record containing the current state of the characteristics of each of the ten graph records in the given two-dimensional viewport,{} \\spad{v},{} which is of domain \\spadtype{TwoDimensionalViewport}.")) (|graphState| (((|Void|) $ (|PositiveInteger|) (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|) (|Integer|) (|Integer|) (|Integer|) (|Integer|) (|Palette|) (|Integer|) (|Palette|) (|Integer|)) "\\spad{graphState(v,num,sX,sY,dX,dY,pts,lns,box,axes,axesC,un,unC,cP)} sets the state of the characteristics for the graph indicated by \\spad{num} in the given two-dimensional viewport \\spad{v},{} of domain \\spadtype{TwoDimensionalViewport},{} to the values given as parameters. The scaling of the graph in the \\spad{x} and \\spad{y} component directions is set to be \\spad{sX} and \\spad{sY}; the window translation in the \\spad{x} and \\spad{y} component directions is set to be \\spad{dX} and \\spad{dY}; The graph points,{} lines,{} bounding \\spad{box},{} \\spad{axes},{} or units will be shown in the viewport if their given parameters \\spad{pts},{} \\spad{lns},{} \\spad{box},{} \\spad{axes} or \\spad{un} are set to be \\spad{1},{} but will not be shown if they are set to \\spad{0}. The color of the \\spad{axes} and the color of the units are indicated by the palette colors \\spad{axesC} and \\spad{unC} respectively. To display the control panel when the viewport window is displayed,{} set \\spad{cP} to \\spad{1},{} otherwise set it to \\spad{0}.")) (|options| (($ $ (|List| (|DrawOption|))) "\\spad{options(v,lopt)} takes the given two-dimensional viewport,{} \\spad{v},{} of the domain \\spadtype{TwoDimensionalViewport} and returns \\spad{v} with it's draw options modified to be those which are indicated in the given list,{} \\spad{lopt} of domain \\spadtype{DrawOption}.") (((|List| (|DrawOption|)) $) "\\spad{options(v)} takes the given two-dimensional viewport,{} \\spad{v},{} of the domain \\spadtype{TwoDimensionalViewport} and returns a list containing the draw options from the domain \\spadtype{DrawOption} for \\spad{v}.")) (|makeViewport2D| (($ (|GraphImage|) (|List| (|DrawOption|))) "\\spad{makeViewport2D(gi,lopt)} creates and displays a viewport window of the domain \\spadtype{TwoDimensionalViewport} whose graph field is assigned to be the given graph,{} \\spad{gi},{} of domain \\spadtype{GraphImage},{} and whose options field is set to be the list of options,{} \\spad{lopt} of domain \\spadtype{DrawOption}.") (($ $) "\\spad{makeViewport2D(v)} takes the given two-dimensional viewport,{} \\spad{v},{} of the domain \\spadtype{TwoDimensionalViewport} and displays a viewport window on the screen which contains the contents of \\spad{v}.")) (|viewport2D| (($) "\\spad{viewport2D()} returns an undefined two-dimensional viewport of the domain \\spadtype{TwoDimensionalViewport} whose contents are empty.")) (|getPickedPoints| (((|List| (|Point| (|DoubleFloat|))) $) "\\spad{getPickedPoints(x)} returns a list of small floats for the points the user interactively picked on the viewport for full integration into the system,{} some design issues need to be addressed: \\spadignore{e.g.} how to go through the GraphImage interface,{} how to default to graphs,{} etc."))) 
 NIL 
 NIL 
 (|ThreeDimensionalViewport|) 
@@ -4694,7 +4694,7 @@ NIL
 NIL 
 (|VectorSpace| S) 
 ((|constructor| (NIL "Vector Spaces (not necessarily finite dimensional) over a field.")) (|dimension| (((|CardinalNumber|)) "\\spad{dimension()} returns the dimensionality of the vector space.")) (/ (($ $ |#1|) "\\spad{x/y} divides the vector \\spad{x} by the scalar \\spad{y}."))) 
-((|leftUnitary| . T) (|rightUnitary| . T)) 
+NIL 
 NIL 
 (|WeierstrassPreparation| R) 
 ((|constructor| (NIL "This package implements the Weierstrass preparation theorem \\spad{f} or multivariate power series. weierstrass(\\spad{v},{}\\spad{p}) where \\spad{v} is a variable,{} and \\spad{p} is a TaylorSeries(\\spad{R}) in which the terms of lowest degree \\spad{s} must include c*v**s where \\spad{c} is a constant,{}\\spad{s>0},{} is a list of TaylorSeries coefficients A[\\spad{i}] of the equivalent polynomial A = A[0] + A[1]*v + A[2]\\spad{*v**2} + ... + A[\\spad{s}-1]*v**(\\spad{s}-1) + v**s such that p=A*B ,{} \\spad{B} being a TaylorSeries of minimum degree 0")) (|qqq| (((|Mapping| (|Stream| (|TaylorSeries| |#1|)) (|Stream| (|TaylorSeries| |#1|))) (|NonNegativeInteger|) (|TaylorSeries| |#1|) (|Stream| (|TaylorSeries| |#1|))) "\\spad{qqq(n,s,st)} is used internally.")) (|weierstrass| (((|List| (|TaylorSeries| |#1|)) (|Symbol|) (|TaylorSeries| |#1|)) "\\spad{weierstrass(v,ts)} where \\spad{v} is a variable and \\spad{ts} is \\indented{1}{a TaylorSeries,{} impements the Weierstrass Preparation} \\indented{1}{Theorem. The result is a list of TaylorSeries that} \\indented{1}{are the coefficients of the equivalent series.}")) (|clikeUniv| (((|Mapping| (|SparseUnivariatePolynomial| (|Polynomial| |#1|)) (|Polynomial| |#1|)) (|Symbol|)) "\\spad{clikeUniv(v)} is used internally.")) (|sts2stst| (((|Stream| (|Stream| (|Polynomial| |#1|))) (|Symbol|) (|Stream| (|Polynomial| |#1|))) "\\spad{sts2stst(v,s)} is used internally.")) (|cfirst| (((|Mapping| (|Stream| (|Polynomial| |#1|)) (|Stream| (|Polynomial| |#1|))) (|NonNegativeInteger|)) "\\spad{cfirst n} is used internally.")) (|crest| (((|Mapping| (|Stream| (|Polynomial| |#1|)) (|Stream| (|Polynomial| |#1|))) (|NonNegativeInteger|)) "\\spad{crest n} is used internally."))) 
@@ -4714,7 +4714,7 @@ NIL
 NIL 
 (|WeightedPolynomials| R |VarSet| E P |vl| |wl| |wtlevel|) 
 ((|constructor| (NIL "This domain represents truncated weighted polynomials over a general (not necessarily commutative) polynomial type. The variables must be specified,{} as must the weights. The representation is sparse in the sense that only non-zero terms are represented.")) (|changeWeightLevel| (((|Void|) (|NonNegativeInteger|)) "\\spad{changeWeightLevel(n)} changes the weight level to the new value given: NB: previously calculated terms are not affected")) (/ (((|Union| $ "failed") $ $) "\\spad{x/y} division (only works if minimum weight of divisor is zero,{} and if \\spad{R} is a Field)"))) 
-((|leftUnitary| |has| |#1| . #1=((|CommutativeRing|))) (|rightUnitary| |has| |#1| . #1#) (|unitsKnown| . T)) 
+NIL 
 ((|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|Field|)))) 
 (|WuWenTsunTriangularSet| R E V P) 
 ((|constructor| (NIL "A domain constructor of the category \\axiomType{GeneralTriangularSet}. The only requirement for a list of polynomials to be a member of such a domain is the following: no polynomial is constant and two distinct polynomials have distinct main variables. Such a triangular set may not be auto-reduced or consistent. The \\axiomOpFrom{construct}{WuWenTsunTriangularSet} operation does not check the previous requirement. Triangular sets are stored as sorted lists \\spad{w}.\\spad{r}.\\spad{t}. the main variables of their members. Furthermore,{} this domain exports operations dealing with the characteristic set method of Wu Wen Tsun and some optimizations mainly proposed by Dong Ming Wang.\\newline References : \\indented{1}{[1] \\spad{W}. \\spad{T}. WU \"A Zero Structure Theorem for polynomial equations solving\"} \\indented{6}{MM Research Preprints,{} 1987.} \\indented{1}{[2] \\spad{D}. \\spad{M}. WANG \"An implementation of the characteristic set method in Maple\"} \\indented{6}{Proc. \\spad{DISCO'92}. Bath,{} England.}")) (|characteristicSerie| (((|List| $) (|List| |#4|)) "\\axiom{characteristicSerie(ps)} returns the same as \\axiom{characteristicSerie(ps,{}initiallyReduced?,{}initiallyReduce)}.") (((|List| $) (|List| |#4|) (|Mapping| (|Boolean|) |#4| |#4|) (|Mapping| |#4| |#4| |#4|)) "\\axiom{characteristicSerie(ps,{}redOp?,{}redOp)} returns a list \\axiom{lts} of triangular sets such that the zero set of \\axiom{ps} is the union of the regular zero sets of the members of \\axiom{lts}. This is made by the Ritt and Wu Wen Tsun process applying the operation \\axiom{characteristicSet(ps,{}redOp?,{}redOp)} to compute characteristic sets in Wu Wen Tsun sense.")) (|characteristicSet| (((|Union| $ "failed") (|List| |#4|)) "\\axiom{characteristicSet(ps)} returns the same as \\axiom{characteristicSet(ps,{}initiallyReduced?,{}initiallyReduce)}.") (((|Union| $ "failed") (|List| |#4|) (|Mapping| (|Boolean|) |#4| |#4|) (|Mapping| |#4| |#4| |#4|)) "\\axiom{characteristicSet(ps,{}redOp?,{}redOp)} returns a non-contradictory characteristic set of \\axiom{ps} in Wu Wen Tsun sense \\spad{w}.\\spad{r}.\\spad{t} the reduction-test \\axiom{redOp?} (using \\axiom{redOp} to reduce polynomials \\spad{w}.\\spad{r}.\\spad{t} a \\axiom{redOp?} basic set),{} if no non-zero constant polynomial appear during those reductions,{} else \\axiom{\"failed\"} is returned. The operations \\axiom{redOp} and \\axiom{redOp?} must satisfy the following conditions: \\axiom{redOp?(redOp(\\spad{p},{}\\spad{q}),{}\\spad{q})} holds for every polynomials \\axiom{\\spad{p},{}\\spad{q}} and there exists an integer \\axiom{\\spad{e}} and a polynomial \\axiom{\\spad{f}} such that we have \\axiom{init(\\spad{q})^e*p = f*q + redOp(\\spad{p},{}\\spad{q})}.")) (|medialSet| (((|Union| $ "failed") (|List| |#4|)) "\\axiom{medial(ps)} returns the same as \\axiom{medialSet(ps,{}initiallyReduced?,{}initiallyReduce)}.") (((|Union| $ "failed") (|List| |#4|) (|Mapping| (|Boolean|) |#4| |#4|) (|Mapping| |#4| |#4| |#4|)) "\\axiom{medialSet(ps,{}redOp?,{}redOp)} returns \\axiom{bs} a basic set (in Wu Wen Tsun sense \\spad{w}.\\spad{r}.\\spad{t} the reduction-test \\axiom{redOp?}) of some set generating the same ideal as \\axiom{ps} (with rank not higher than any basic set of \\axiom{ps}),{} if no non-zero constant polynomials appear during the computatioms,{} else \\axiom{\"failed\"} is returned. In the former case,{} \\axiom{bs} has to be understood as a candidate for being a characteristic set of \\axiom{ps}. In the original algorithm,{} \\axiom{bs} is simply a basic set of \\axiom{ps}."))) 
@@ -4722,11 +4722,11 @@ NIL
 ((AND #1=(|HasCategory| |#4| (QUOTE (|SetCategory|))) (|HasCategory| |#4| (|%list| (QUOTE |Evalable|) #2=(|devaluate| |#4|)))) (|HasCategory| |#4| (QUOTE (|ConvertibleTo| (|InputForm|)))) #3=(|HasCategory| |#4| (QUOTE (|BasicType|))) (|HasCategory| |#1| (QUOTE (|IntegralDomain|))) (|HasCategory| |#3| (QUOTE (|Finite|))) (|HasCategory| |#4| (QUOTE (|CoercibleTo| (|OutputForm|)))) #1# (AND #3# #4=(|HasCategory| $ (|%list| (QUOTE |FiniteAggregate|) #2#))) #4#) 
 (|XAlgebra| R) 
 ((|constructor| (NIL "This is the category of algebras over non-commutative rings. It is used by constructors of non-commutative algebras such as: \\indented{4}{\\spadtype{XPolynomialRing}.} \\indented{4}{\\spadtype{XFreeAlgebra}} Author: Michel Petitot (petitot@lifl.fr)"))) 
-((|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+NIL 
 NIL 
 (|XDistributedPolynomial| |vl| R) 
 ((|constructor| (NIL "\\indented{2}{This type supports distributed multivariate polynomials} whose variables do not commute. The coefficient ring may be non-commutative too. However,{} coefficients and variables commute."))) 
-((|unitsKnown| . T) (|noZeroDivisors| |has| |#2| (ATTRIBUTE |noZeroDivisors|)) (|leftUnitary| . T) (|rightUnitary| . T)) 
+((|noZeroDivisors| |has| |#2| (ATTRIBUTE |noZeroDivisors|))) 
 ((|HasCategory| |#2| (QUOTE (|CommutativeRing|))) (|HasAttribute| |#2| (QUOTE |noZeroDivisors|))) 
 (|XExponentialPackage| R |VarSet| XPOLY) 
 ((|constructor| (NIL "This package provides computations of logarithms and exponentials for polynomials in non-commutative variables. \\newline Author: Michel Petitot (petitot@lifl.fr).")) (|Hausdorff| ((|#3| |#3| |#3| (|NonNegativeInteger|)) "\\axiom{Hausdorff(a,{}\\spad{b},{}\\spad{n})} returns log(exp(a)*exp(\\spad{b})) truncated at order \\axiom{\\spad{n}}.")) (|log| ((|#3| |#3| (|NonNegativeInteger|)) "\\axiom{log(\\spad{p},{} \\spad{n})} returns the logarithm of \\axiom{\\spad{p}} truncated at order \\axiom{\\spad{n}}.")) (|exp| ((|#3| |#3| (|NonNegativeInteger|)) "\\axiom{exp(\\spad{p},{} \\spad{n})} returns the exponential of \\axiom{\\spad{p}} truncated at order \\axiom{\\spad{n}}."))) 
@@ -4738,31 +4738,31 @@ NIL
 ((|HasCategory| |#2| (QUOTE (|Finite|))) (|HasCategory| |#2| (QUOTE (|CharacteristicNonZero|))) (|HasCategory| |#2| (QUOTE (|CharacteristicZero|)))) 
 (|ExtensionField| F) 
 ((|constructor| (NIL "ExtensionField {\\em F} is the category of fields which extend the field \\spad{F}")) (|Frobenius| (($ $ (|NonNegativeInteger|)) "\\spad{Frobenius(a,s)} returns \\spad{a**(q**s)} where \\spad{q} is the size()\\$\\spad{F}.") (($ $) "\\spad{Frobenius(a)} returns \\spad{a ** q} where \\spad{q} is the \\spad{size()\\$F}.")) (|transcendenceDegree| (((|NonNegativeInteger|)) "\\spad{transcendenceDegree()} returns the transcendence degree of the field extension,{} 0 if the extension is algebraic.")) (|extensionDegree| (((|OnePointCompletion| (|PositiveInteger|))) "\\spad{extensionDegree()} returns the degree of the field extension if the extension is algebraic,{} and \\spad{infinity} if it is not.")) (|degree| (((|OnePointCompletion| (|PositiveInteger|)) $) "\\spad{degree(a)} returns the degree of minimal polynomial of an element \\spad{a} if \\spad{a} is algebraic with respect to the ground field \\spad{F},{} and \\spad{infinity} otherwise.")) (|inGroundField?| (((|Boolean|) $) "\\spad{inGroundField?(a)} tests whether an element \\spad{a} is already in the ground field \\spad{F}.")) (|transcendent?| (((|Boolean|) $) "\\spad{transcendent?(a)} tests whether an element \\spad{a} is transcendent with respect to the ground field \\spad{F}.")) (|algebraic?| (((|Boolean|) $) "\\spad{algebraic?(a)} tests whether an element \\spad{a} is algebraic with respect to the ground field \\spad{F}."))) 
-((|canonicalsClosed| . T) (|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+((|canonicalUnitNormal| . T) (|noZeroDivisors| . T) ((|commutative| "*") . T)) 
 NIL 
 (|XFreeAlgebra| |vl| R) 
 ((|constructor| (NIL "This category specifies opeations for polynomials and formal series with non-commutative variables.")) (|varList| (((|List| |#1|) $) "\\spad{varList(x)} returns the list of variables which appear in \\spad{x}.")) (|sh| (($ $ (|NonNegativeInteger|)) "\\spad{sh(x,n)} returns the shuffle power of \\spad{x} to the \\spad{n}.") (($ $ $) "\\spad{sh(x,y)} returns the shuffle-product of \\spad{x} by \\spad{y}. This multiplication is associative and commutative.")) (|quasiRegular| (($ $) "\\spad{quasiRegular(x)} return \\spad{x} minus its constant term.")) (|quasiRegular?| (((|Boolean|) $) "\\spad{quasiRegular?(x)} return \\spad{true} if \\spad{constant(x)} is zero.")) (|constant| ((|#2| $) "\\spad{constant(x)} returns the constant term of \\spad{x}.")) (|constant?| (((|Boolean|) $) "\\spad{constant?(x)} returns \\spad{true} if \\spad{x} is constant.")) (|coerce| (($ |#1|) "\\spad{coerce(v)} returns \\spad{v}.")) (|mirror| (($ $) "\\spad{mirror(x)} returns \\spad{Sum(r_i mirror(w_i))} if \\spad{x} writes \\spad{Sum(r_i w_i)}.")) (|monomial?| (((|Boolean|) $) "\\spad{monomial?(x)} returns \\spad{true} if \\spad{x} is a monomial")) (|monom| (($ (|OrderedFreeMonoid| |#1|) |#2|) "\\spad{monom(w,r)} returns the product of the word \\spad{w} by the coefficient \\spad{r}.")) (|rquo| (($ $ $) "\\spad{rquo(x,y)} returns the right simplification of \\spad{x} by \\spad{y}.") (($ $ (|OrderedFreeMonoid| |#1|)) "\\spad{rquo(x,w)} returns the right simplification of \\spad{x} by \\spad{w}.") (($ $ |#1|) "\\spad{rquo(x,v)} returns the right simplification of \\spad{x} by the variable \\spad{v}.")) (|lquo| (($ $ $) "\\spad{lquo(x,y)} returns the left simplification of \\spad{x} by \\spad{y}.") (($ $ (|OrderedFreeMonoid| |#1|)) "\\spad{lquo(x,w)} returns the left simplification of \\spad{x} by the word \\spad{w}.") (($ $ |#1|) "\\spad{lquo(x,v)} returns the left simplification of \\spad{x} by the variable \\spad{v}.")) (|coef| ((|#2| $ $) "\\spad{coef(x,y)} returns scalar product of \\spad{x} by \\spad{y},{} the set of words being regarded as an orthogonal basis.") ((|#2| $ (|OrderedFreeMonoid| |#1|)) "\\spad{coef(x,w)} returns the coefficient of the word \\spad{w} in \\spad{x}.")) (|mindegTerm| (((|Record| (|:| |k| (|OrderedFreeMonoid| |#1|)) (|:| |c| |#2|)) $) "\\spad{mindegTerm(x)} returns the term whose word is \\spad{mindeg(x)}.")) (|mindeg| (((|OrderedFreeMonoid| |#1|) $) "\\spad{mindeg(x)} returns the little word which appears in \\spad{x}. Error if \\spad{x=0}.")) (* (($ $ |#2|) "\\spad{x * r} returns the product of \\spad{x} by \\spad{r}. Usefull if \\spad{R} is a non-commutative Ring.") (($ |#1| $) "\\spad{v * x} returns the product of a variable \\spad{x} by \\spad{x}."))) 
-((|noZeroDivisors| |has| |#2| (ATTRIBUTE |noZeroDivisors|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| |has| |#2| (ATTRIBUTE |noZeroDivisors|))) 
 NIL 
 (|XPBWPolynomial| |VarSet| R) 
-((|constructor| (NIL "This domain constructor implements polynomials in non-commutative variables written in the Poincare-Birkhoff-Witt basis from the Lyndon basis. These polynomials can be used to compute Baker-Campbell-Hausdorff relations. \\newline Author: Michel Petitot (petitot@lifl.fr).")) (|log| (($ $ (|NonNegativeInteger|)) "\\axiom{log(\\spad{p},{}\\spad{n})} returns the logarithm of \\axiom{\\spad{p}} (truncated up to order \\axiom{\\spad{n}}).")) (|exp| (($ $ (|NonNegativeInteger|)) "\\axiom{exp(\\spad{p},{}\\spad{n})} returns the exponential of \\axiom{\\spad{p}} (truncated up to order \\axiom{\\spad{n}}).")) (|product| (($ $ $ (|NonNegativeInteger|)) "\\axiom{product(a,{}\\spad{b},{}\\spad{n})} returns \\axiom{a*b} (truncated up to order \\axiom{\\spad{n}}).")) (|LiePolyIfCan| (((|Union| (|LiePolynomial| |#1| |#2|) "failed") $) "\\axiom{LiePolyIfCan(\\spad{p})} return \\axiom{\\spad{p}} if \\axiom{\\spad{p}} is a Lie polynomial.")) (|coerce| (((|XRecursivePolynomial| |#1| |#2|) $) "\\axiom{coerce(\\spad{p})} returns \\axiom{\\spad{p}} as a recursive polynomial.") (((|XDistributedPolynomial| |#1| |#2|) $) "\\axiom{coerce(\\spad{p})} returns \\axiom{\\spad{p}} as a distributed polynomial.") (($ (|LiePolynomial| |#1| |#2|)) "\\axiom{coerce(\\spad{p})} returns \\axiom{\\spad{p}}."))) 
-((|noZeroDivisors| |has| |#2| (ATTRIBUTE |noZeroDivisors|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
+((|constructor| (NIL "This domain constructor implements polynomials in non-commutative variables written in the Poincare-Birkhoff-Witt basis from the Lyndon basis. These polynomials can be used to compute Baker-Campbell-Hausdorff relations. \\newline Author: Michel Petitot (petitot@lifl.fr).")) (|log| (($ $ (|NonNegativeInteger|)) "\\axiom{log(\\spad{p},{}\\spad{n})} returns the logarithm of \\axiom{\\spad{p}} (truncated up to order \\axiom{\\spad{n}}).")) (|exp| (($ $ (|NonNegativeInteger|)) "\\axiom{exp(\\spad{p},{}\\spad{n})} returns the exponential of \\axiom{\\spad{p}} (truncated up to order \\axiom{\\spad{n}}).")) (|product| (($ $ $ (|NonNegativeInteger|)) "\\axiom{product(a,{}\\spad{b},{}\\spad{n})} returns \\axiom{a*b} (truncated up to order \\axiom{\\spad{n}}).")) (|LiePolyIfCan| (((|Union| (|LiePolynomial| |#1| |#2|) "failed") $) "\\axiom{LiePolyIfCan(\\spad{p})} return \\axiom{\\spad{p}} if \\axiom{\\spad{p}} is a Lie polynomial.")) (|coerce| (($ (|LiePolynomial| |#1| |#2|)) "\\axiom{coerce(\\spad{p})} returns \\axiom{\\spad{p}}."))) 
+((|noZeroDivisors| |has| |#2| (ATTRIBUTE |noZeroDivisors|))) 
 ((|HasCategory| |#2| (QUOTE (|CommutativeRing|))) (|HasCategory| |#2| (QUOTE (|Module| (|Fraction| (|Integer|))))) (|HasAttribute| |#2| (QUOTE |noZeroDivisors|))) 
 (|XPolynomial| R) 
 ((|constructor| (NIL "\\indented{2}{This type supports multivariate polynomials} whose set of variables is \\spadtype{Symbol}. The representation is recursive. The coefficient ring may be non-commutative and the variables do not commute. However,{} coefficients and variables commute."))) 
-((|noZeroDivisors| |has| |#1| (ATTRIBUTE |noZeroDivisors|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| |has| |#1| (ATTRIBUTE |noZeroDivisors|))) 
 ((|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasAttribute| |#1| (QUOTE |noZeroDivisors|))) 
 (|XPolynomialsCat| |vl| R) 
 ((|constructor| (NIL "The Category of polynomial rings with non-commutative variables. The coefficient ring may be non-commutative too. However coefficients commute with vaiables.")) (|trunc| (($ $ (|NonNegativeInteger|)) "\\spad{trunc(p,n)} returns the polynomial \\spad{p} truncated at order \\spad{n}.")) (|degree| (((|NonNegativeInteger|) $) "\\spad{degree(p)} returns the degree of \\spad{p}. \\indented{1}{Note that the degree of a word is its length.}")) (|maxdeg| (((|OrderedFreeMonoid| |#1|) $) "\\spad{maxdeg(p)} returns the greatest leading word in the support of \\spad{p}."))) 
-((|noZeroDivisors| |has| |#2| (ATTRIBUTE |noZeroDivisors|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| |has| |#2| (ATTRIBUTE |noZeroDivisors|))) 
 NIL 
 (|XPolynomialRing| R E) 
 ((|constructor| (NIL "This domain represents generalized polynomials with coefficients (from a not necessarily commutative ring),{} and words belonging to an arbitrary \\spadtype{OrderedMonoid}. This type is used,{} for instance,{} by the \\spadtype{XDistributedPolynomial} domain constructor where the Monoid is free.")) (|canonicalUnitNormal| ((|attribute|) "canonicalUnitNormal guarantees that the function unitCanonical returns the same representative for all associates of any particular element.")) (/ (($ $ |#1|) "\\spad{p/r} returns \\spad{p*(1/r)}.")) (|quasiRegular| (($ $) "\\spad{quasiRegular(x)} return \\spad{x} minus its constant term.")) (|quasiRegular?| (((|Boolean|) $) "\\spad{quasiRegular?(x)} return \\spad{true} if \\spad{constant(p)} is zero.")) (|constant| ((|#1| $) "\\spad{constant(p)} return the constant term of \\spad{p}.")) (|constant?| (((|Boolean|) $) "\\spad{constant?(p)} tests whether the polynomial \\spad{p} belongs to the coefficient ring.")) (|coef| ((|#1| $ |#2|) "\\spad{coef(p,e)} extracts the coefficient of the monomial \\spad{e}. Returns zero if \\spad{e} is not present.")) (|reductum| (($ $) "\\spad{reductum(p)} returns \\spad{p} minus its leading term. An error is produced if \\spad{p} is zero.")) (|mindeg| ((|#2| $) "\\spad{mindeg(p)} returns the smallest word occurring in the polynomial \\spad{p} with a non-zero coefficient. An error is produced if \\spad{p} is zero.")) (|maxdeg| ((|#2| $) "\\spad{maxdeg(p)} returns the greatest word occurring in the polynomial \\spad{p} with a non-zero coefficient. An error is produced if \\spad{p} is zero.")) (|#| (((|NonNegativeInteger|) $) "\\spad{\\# p} returns the number of terms in \\spad{p}.")) (* (($ $ |#1|) "\\spad{p*r} returns the product of \\spad{p} by \\spad{r}."))) 
-((|unitsKnown| . T) (|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|noZeroDivisors| |has| |#1| (ATTRIBUTE |noZeroDivisors|)) (|leftUnitary| . T) (|rightUnitary| . T)) 
-((|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|Field|))) (|HasAttribute| |#1| (QUOTE |unitsKnown|)) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) (|HasAttribute| |#1| (QUOTE |noZeroDivisors|))) 
+((|canonicalUnitNormal| |has| |#1| (ATTRIBUTE |canonicalUnitNormal|)) (|noZeroDivisors| |has| |#1| (ATTRIBUTE |noZeroDivisors|))) 
+((|HasCategory| |#1| (QUOTE (|CommutativeRing|))) (|HasCategory| |#1| (QUOTE (|Field|))) (|HasAttribute| |#1| (QUOTE |canonicalUnitNormal|)) (|HasAttribute| |#1| (QUOTE |noZeroDivisors|))) 
 (|XRecursivePolynomial| |VarSet| R) 
 ((|constructor| (NIL "\\indented{2}{This type supports multivariate polynomials} whose variables do not commute. The representation is recursive. The coefficient ring may be non-commutative. Coefficients and variables commute.")) (|RemainderList| (((|List| (|Record| (|:| |k| |#1|) (|:| |c| $))) $) "\\spad{RemainderList(p)} returns the regular part of \\spad{p} as a list of terms.")) (|unexpand| (($ (|XDistributedPolynomial| |#1| |#2|)) "\\spad{unexpand(p)} returns \\spad{p} in recursive form.")) (|expand| (((|XDistributedPolynomial| |#1| |#2|) $) "\\spad{expand(p)} returns \\spad{p} in distributed form."))) 
-((|noZeroDivisors| |has| |#2| (ATTRIBUTE |noZeroDivisors|)) (|leftUnitary| . T) (|rightUnitary| . T) (|unitsKnown| . T)) 
+((|noZeroDivisors| |has| |#2| (ATTRIBUTE |noZeroDivisors|))) 
 ((|HasCategory| |#2| (QUOTE (|CommutativeRing|))) (|HasAttribute| |#2| (QUOTE |noZeroDivisors|))) 
 (|YoungDiagram|) 
 ((|constructor| (NIL "This domain provides representations of Young diagrams.")) (|shape| (((|Partition|) $) "\\spad{shape x} returns the partition shaping \\spad{x}.")) (|youngDiagram| (($ (|List| (|PositiveInteger|))) "\\spad{youngDiagram l} returns an object representing a Young diagram with shape given by the list of integers \\spad{l}"))) 
@@ -4782,7 +4782,7 @@ NIL
 NIL 
 (|IntegerMod| |p|) 
 ((|constructor| (NIL "IntegerMod(\\spad{n}) creates the ring of integers reduced modulo the integer \\spad{n}."))) 
-(((|commutative| "*") . T) (|rightUnitary| . T) (|leftUnitary| . T) (|unitsKnown| . T)) 
+(((|commutative| "*") . T)) 
 NIL 
 NIL 
 NIL 
@@ -4800,4 +4800,4 @@ NIL
 NIL 
 NIL 
 NIL 
-((|Union| NIL 1915133 1915138 1915143 1915148) (|Record| NIL 1915113 1915118 1915123 1915128) (|Mapping| NIL 1915093 1915098 1915103 1915108) (|Enumeration| NIL 1915073 1915078 1915083 1915088) (|IntegerMod| "ZMOD.spad" 1914843 1914863 1914979 1915068) (|IntegerLinearDependence| "ZLINDEP.spad" 1913921 1913952 1914833 1914838) (|ZeroDimensionalSolvePackage| "ZDSOLVE.spad" 1903858 1903904 1913911 1913916) (|ParadoxicalCombinatorsForStreams| "YSTREAM.spad" 1903324 1903364 1903848 1903853) (|YoungDiagram| "YDIAGRAM.spad" 1902949 1902967 1903314 1903319) (|XRecursivePolynomial| "XRPOLY.spad" 1902075 1902112 1902728 1902850) (|XPolynomialRing| "XPR.spad" 1899849 1899874 1901651 1901842) (|XPolynomialsCat| "XPOLYC.spad" 1899103 1899131 1899722 1899844) (|XPolynomial| "XPOLY.spad" 1898573 1898592 1898882 1899004) (|XPBWPolynomial| "XPBWPOLY.spad" 1896941 1896972 1898287 1898409) (|XFreeAlgebra| "XFALG.spad" 1894060 1894085 1896814 1896936) (|ExtensionField| "XF.spad" 1892444 1892466 1893890 1894055) (|ExtensionField&| "XF.spad" 1890840 1890865 1892289 1892294) (|XExponentialPackage| "XEXPPKG.spad" 1890083 1890125 1890830 1890835) (|XDistributedPolynomial| "XDPOLY.spad" 1889601 1889636 1889862 1889984) (|XAlgebra| "XALG.spad" 1889240 1889256 1889533 1889596) (|WuWenTsunTriangularSet| "WUTSET.spad" 1885122 1885158 1888772 1888777) (|WeightedPolynomials| "WP.spad" 1884254 1884314 1884921 1885031) (|WhileAst| "WHILEAST.spad" 1884047 1884061 1884244 1884249) (|WhereAst| "WHEREAST.spad" 1883713 1883727 1884037 1884042) (|WildFunctionFieldIntegralBasis| "WFFINTBS.spad" 1881353 1881398 1883703 1883708) (|WeierstrassPreparation| "WEIER.spad" 1879556 1879586 1881343 1881348) (|VectorSpace| "VSPACE.spad" 1879204 1879223 1879507 1879551) (|VectorSpace&| "VSPACE.spad" 1878888 1878910 1879194 1879199) (|Void| "VOID.spad" 1878564 1878574 1878878 1878883) (|ViewDefaultsPackage| "VIEWDEF.spad" 1873749 1873774 1878554 1878559) (|ThreeDimensionalViewport| "VIEW3D.spad" 1857689 1857719 1873739 1873744) (|TwoDimensionalViewport| "VIEW2D.spad" 1845569 1845597 1857679 1857684) (|ViewportPackage| "VIEW.spad" 1843277 1843298 1845559 1845564) (|VectorFunctions2| "VECTOR2.spad" 1841903 1841929 1843267 1843272) (|Vector| "VECTOR.spad" 1840758 1840772 1841012 1841017) (|VectorCategory| "VECTCAT.spad" 1838681 1838703 1840748 1840753) (|VectorCategory&| "VECTCAT.spad" 1836333 1836358 1838403 1838408) (|Variable| "VARIABLE.spad" 1836108 1836128 1836323 1836328) (|UnionType| "UTYPE.spad" 1835746 1835761 1836098 1836103) (|UTSodetools| "UTSODETL.spad" 1835025 1835053 1835690 1835695) (|UnivariateTaylorSeriesODESolver| "UTSODE.spad" 1833213 1833261 1835015 1835020) (|UnivariateTaylorSeriesCategory| "UTSCAT.spad" 1830597 1830640 1833043 1833208) (|UnivariateTaylorSeriesCategory&| "UTSCAT.spad" 1827634 1827680 1830083 1830088) (|UnivariateTaylorSeriesFunctions2| "UTS2.spad" 1827200 1827264 1827624 1827629) (|UnivariateTaylorSeries| "UTS.spad" 1822370 1822417 1825909 1826074) (|UnaryRecursiveAggregate| "URAGG.spad" 1817071 1817102 1822360 1822365) (|UnaryRecursiveAggregate&| "URAGG.spad" 1811685 1811719 1816977 1816982) (|UnivariatePuiseuxSeriesWithExponentialSingularity| "UPXSSING.spad" 1809483 1809555 1810965 1811170) (|UnivariatePuiseuxSeriesConstructor| "UPXSCONS.spad" 1807652 1807703 1808056 1808311) (|UnivariatePuiseuxSeriesConstructorCategory| "UPXSCCA.spad" 1806078 1806137 1807392 1807647) (|UnivariatePuiseuxSeriesConstructorCategory&| "UPXSCCA.spad" 1804751 1804813 1806068 1806073) (|UnivariatePuiseuxSeriesCategory| "UPXSCAT.spad" 1803206 1803250 1804491 1804746) (|UnivariatePuiseuxSeriesFunctions2| "UPXS2.spad" 1802719 1802802 1803196 1803201) (|UnivariatePuiseuxSeries| "UPXS.spad" 1800436 1800484 1801292 1801547) (|UnivariatePolynomialSquareFree| "UPSQFREE.spad" 1798824 1798865 1800426 1800431) (|UnivariatePowerSeriesCategory| "UPSCAT.spad" 1796525 1796575 1798654 1798819) (|UnivariatePowerSeriesCategory&| "UPSCAT.spad" 1794031 1794084 1796163 1796168) (|UnivariatePolynomialCategoryFunctions2| "UPOLYC2.spad" 1793467 1793521 1794021 1794026) (|UnivariatePolynomialCategory| "UPOLYC.spad" 1788398 1788434 1793185 1793462) (|UnivariatePolynomialCategory&| "UPOLYC.spad" 1783310 1783349 1788100 1788105) (|UnivariatePolynomialMultiplicationPackage| "UPMP.spad" 1782204 1782255 1783300 1783305) (|UnivariatePolynomialDivisionPackage| "UPDIVP.spad" 1781737 1781783 1782194 1782199) (|UnivariatePolynomialDecompositionPackage| "UPDECOMP.spad" 1779961 1780012 1781727 1781732) (|UnivariatePolynomialCommonDenominator| "UPCDEN.spad" 1779144 1779194 1779951 1779956) (|UnivariatePolynomialFunctions2| "UP2.spad" 1778481 1778529 1779134 1779139) (|UnivariatePolynomial| "UP.spad" 1776195 1776227 1776599 1776876) (|UniversalSegmentFunctions2| "UNISEG2.spad" 1775660 1775696 1776142 1776147) (|UniversalSegment| "UNISEG.spad" 1774983 1775007 1775562 1775567) (|UnivariateFactorize| "UNIFACT.spad" 1774070 1774098 1774973 1774978) (|UnivariateLaurentSeriesConstructor| "ULSCONS.spad" 1770482 1770533 1770883 1771138) (|UnivariateLaurentSeriesConstructorCategory| "ULSCCAT.spad" 1768074 1768133 1770222 1770477) (|UnivariateLaurentSeriesConstructorCategory&| "ULSCCAT.spad" 1765876 1765938 1768027 1768032) (|UnivariateLaurentSeriesCategory| "ULSCAT.spad" 1763982 1764026 1765616 1765871) (|UnivariateLaurentSeriesFunctions2| "ULS2.spad" 1763466 1763549 1763972 1763977) (|UnivariateLaurentSeries| "ULS.spad" 1759021 1759069 1759986 1760435) (|UInt8| "UINT8.spad" 1758896 1758907 1759011 1759016) (|UInt64| "UINT64.spad" 1758769 1758781 1758886 1758891) (|UInt32| "UINT32.spad" 1758642 1758654 1758759 1758764) (|UInt16| "UINT16.spad" 1758515 1758527 1758632 1758637) (|UniqueFactorizationDomain| "UFD.spad" 1757515 1757546 1758398 1758510) (|UniqueFactorizationDomain&| "UFD.spad" 1756619 1756653 1757505 1757510) (|UserDefinedVariableOrdering| "UDVO.spad" 1755476 1755509 1756609 1756614) (|UserDefinedPartialOrdering| "UDPO.spad" 1753026 1753060 1755424 1755429) (|TypeAst| "TYPEAST.spad" 1752941 1752954 1753016 1753021) (|Type| "TYPE.spad" 1752872 1752882 1752931 1752936) (|TwoFactorize| "TWOFACT.spad" 1751519 1751539 1752862 1752867) (|Tuple| "TUPLE.spad" 1750999 1751012 1751406 1751411) (|TubePlotTools| "TUBETOOL.spad" 1747856 1747875 1750989 1750994) (|TubePlot| "TUBE.spad" 1746498 1746520 1747846 1747851) (|TriangularSetCategory| "TSETCAT.spad" 1734573 1734608 1746488 1746493) (|TriangularSetCategory&| "TSETCAT.spad" 1722607 1722645 1734525 1734530) (|TaylorSeries| "TS.spad" 1721136 1721161 1722111 1722276) (|TranscendentalManipulations| "TRMANIP.spad" 1715555 1715592 1720899 1720904) (|TriangularMatrixOperations| "TRIMAT.spad" 1714495 1714543 1715545 1715550) (|TrigonometricManipulations| "TRIGMNIP.spad" 1713003 1713039 1714485 1714490) (|TrigonometricFunctionCategory| "TRIGCAT.spad" 1712489 1712524 1712993 1712998) (|TrigonometricFunctionCategory&| "TRIGCAT.spad" 1711972 1712010 1712479 1712484) (|Tree| "TREE.spad" 1710614 1710626 1711647 1711652) (|TranscendentalFunctionCategory| "TRANFUN.spad" 1710426 1710462 1710604 1710609) (|TranscendentalFunctionCategory&| "TRANFUN.spad" 1710235 1710274 1710416 1710421) (|TopLevelThreeSpace| "TOPSP.spad" 1709894 1709918 1710225 1710230) (|ToolsForSign| "TOOLSIGN.spad" 1709548 1709568 1709884 1709889) (|TextFile| "TEXTFILE.spad" 1708104 1708118 1709538 1709543) (|TexFormat1| "TEX1.spad" 1707653 1707671 1708094 1708099) (|TexFormat| "TEX.spad" 1704841 1704856 1707643 1707648) (|TabulatedComputationPackage| "TBCMPPK.spad" 1702918 1702965 1704831 1704836) (|TableAggregate| "TBAGG.spad" 1702172 1702206 1702908 1702913) (|TableAggregate&| "TBAGG.spad" 1701423 1701460 1702162 1702167) (|TangentExpansions| "TANEXP.spad" 1700817 1700842 1701413 1701418) (|TermAlgebraOperator| "TALGOP.spad" 1700525 1700552 1700807 1700812) (|Tableau| "TABLEAU.spad" 1700002 1700017 1700515 1700520) (|Table| "TABLE.spad" 1698806 1698831 1699078 1699083) (|TableauxBumpers| "TABLBUMP.spad" 1695573 1695596 1698796 1698801) (|System| "SYSTEM.spad" 1694798 1694810 1695563 1695568) (|SystemSolvePackage| "SYSSOLP.spad" 1692266 1692292 1694788 1694793) (|SystemPointer| "SYSPTR.spad" 1692155 1692174 1692256 1692261) (|SystemNonNegativeInteger| "SYSNNI.spad" 1691357 1691389 1692145 1692150) (|SystemInteger| "SYSINT.spad" 1690751 1690772 1691347 1691352) (|Syntax| "SYNTAX.spad" 1687082 1687094 1690741 1690746) (|SymbolTable| "SYMTAB.spad" 1685142 1685159 1687072 1687077) (|TheSymbolTable| "SYMS.spad" 1681160 1681180 1685132 1685137) (|SymmetricPolynomial| "SYMPOLY.spad" 1680197 1680224 1680295 1680529) (|SymmetricFunctions| "SYMFUNC.spad" 1679683 1679709 1680187 1680192) (|Symbol| "SYMBOL.spad" 1677175 1677187 1679673 1679678) (|SparseUnivariateTaylorSeries| "SUTS.spad" 1674440 1674493 1675884 1676049) (|SparseUnivariatePuiseuxSeries| "SUPXS.spad" 1672138 1672192 1673013 1673268) (|SupFractionFactorizer| "SUPFRACF.spad" 1671225 1671261 1672128 1672133) (|SparseUnivariatePolynomialFunctions2| "SUP2.spad" 1670584 1670630 1671215 1671220) (|SparseUnivariatePolynomial| "SUP.spad" 1667906 1667940 1668702 1668979) (|RationalFunctionSum| "SUMRF.spad" 1666864 1666891 1667896 1667901) (|FunctionSpaceSum| "SUMFS.spad" 1666484 1666510 1666854 1666859) (|SparseUnivariateLaurentSeries| "SULS.spad" 1662002 1662056 1662986 1663441) (|SuchThatAst| "syntax.spad" 1661763 1661780 1661992 1661997) (|SuchThat| "SUCH.spad" 1661448 1661468 1661753 1661758) (|SubSpace| "SUBSPACE.spad" 1653574 1653594 1661438 1661443) (|SubResultantPackage| "SUBRESP.spad" 1652715 1652745 1653517 1653522) (|StreamTranscendentalFunctionsNonCommutative| "STTFNC.spad" 1649143 1649199 1652705 1652710) (|StreamTranscendentalFunctions| "STTF.spad" 1645216 1645258 1649133 1649138) (|StreamTaylorSeriesOperations| "STTAYLOR.spad" 1637848 1637884 1645103 1645108) (|StringTable| "STRTBL.spad" 1636790 1636815 1636947 1636952) (|String| "STRING.spad" 1635831 1635843 1636219 1636224) (|StreamFunctions3| "STREAM3.spad" 1635391 1635419 1635821 1635826) (|StreamFunctions2| "STREAM2.spad" 1634506 1634532 1635381 1635386) (|StreamFunctions1| "STREAM1.spad" 1634199 1634223 1634496 1634501) (|Stream| "STREAM.spad" 1631200 1631214 1633694 1633699) (|StreamInfiniteProduct| "STINPROD.spad" 1630118 1630152 1631190 1631195) (|StepAst| "STEPAST.spad" 1629348 1629361 1630108 1630113) (|StepThrough| "STEP.spad" 1628657 1628674 1629338 1629343) (|SparseTable| "STBL.spad" 1627558 1627594 1627733 1627738) (|StreamAggregate| "STAGG.spad" 1626245 1626268 1627548 1627553) (|StreamAggregate&| "STAGG.spad" 1624929 1624955 1626235 1626240) (|Stack| "STACK.spad" 1624423 1624436 1624675 1624680) (|SemiRing| "SRING.spad" 1624178 1624192 1624413 1624418) (|SquareFreeRegularTriangularSet| "SREGSET.spad" 1621781 1621825 1623710 1623715) (|SquareFreeRegularSetDecompositionPackage| "SRDCMPK.spad" 1620321 1620378 1621771 1621776) (|StringAggregate| "SRAGG.spad" 1615514 1615535 1620311 1620316) (|StringAggregate&| "SRAGG.spad" 1610704 1610728 1615504 1615509) (|SquareMatrix| "SQMATRIX.spad" 1608624 1608651 1609549 1609667) (|SplittingTree| "SPLTREE.spad" 1603417 1603440 1608223 1608228) (|SplittingNode| "SPLNODE.spad" 1600027 1600050 1603407 1603412) (|SpecialFunctionCategory| "SPFCAT.spad" 1598816 1598845 1600017 1600022) (|SpecialOutputPackage| "SPECOUT.spad" 1597351 1597377 1598806 1598811) (|SpadAstExports| "SPADXPT.spad" 1589431 1589451 1597341 1597346) (|SpadParser| "spad-parser.spad" 1588889 1588905 1589421 1589426) (|SpadAst| "SPADAST.spad" 1588586 1588599 1588879 1588884) (|ThreeSpaceCategory| "SPACEC.spad" 1572786 1572812 1588576 1588581) (|ThreeSpace| "SPACE3.spad" 1572555 1572573 1572776 1572781) (|SortPackage| "SORTPAK.spad" 1572088 1572109 1572503 1572508) (|TransSolvePackage| "SOLVETRA.spad" 1569837 1569862 1572078 1572083) (|TransSolvePackageService| "SOLVESER.spad" 1568272 1568304 1569827 1569832) (|RadicalSolvePackage| "SOLVERAD.spad" 1564282 1564309 1568262 1568267) (|PolynomialSolveByFormulas| "SOLVEFOR.spad" 1562726 1562762 1564272 1564277) (|SquareFreeNormalizedTriangularSetCategory| "SNTSCAT.spad" 1562310 1562365 1562716 1562721) (|SparseMultivariateTaylorSeries| "SMTS.spad" 1560510 1560563 1561814 1561979) (|SparseMultivariatePolynomial| "SMP.spad" 1558580 1558625 1558995 1559229) (|SmithNormalForm| "SMITH.spad" 1557413 1557450 1558570 1558575) (|SquareMatrixCategory| "SMATCAT.spad" 1555502 1555549 1557345 1557408) (|SquareMatrixCategory&| "SMATCAT.spad" 1553510 1553560 1555356 1555361) (|ShallowlyMutableAggregate| "aggcat.spad" 1553174 1553207 1553500 1553505) (|StackAggregate| "SKAGG.spad" 1552154 1552176 1553164 1553169) (|SingleInteger| "SINT.spad" 1551338 1551357 1551915 1552149) (|SimplifyAlgebraicNumberConvertPackage| "SIMPAN.spad" 1551032 1551075 1551328 1551333) (|RationalFunctionSign| "SIGNRF.spad" 1550140 1550168 1551022 1551027) (|ElementaryFunctionSign| "SIGNEF.spad" 1549411 1549443 1550130 1550135) (|SignatureAst| "syntax.spad" 1548819 1548837 1549401 1549406) (|Signature| "SIG.spad" 1548175 1548190 1548809 1548814) (|SturmHabichtPackage| "SHP.spad" 1546096 1546127 1548124 1548129) (|SplitHomogeneousDirectProduct| "SHDP.spad" 1542652 1542705 1543195 1543326) (|SemiGroup| "SGROUP.spad" 1542254 1542269 1542642 1542647) (|SemiGroup&| "SGROUP.spad" 1541853 1541871 1542244 1542249) (|SemiGroupOperatorCategory| "catdef.spad" 1541545 1541579 1541678 1541848) (|SemiGroupOperation| "catdef.spad" 1541090 1541117 1541370 1541540) (|SymmetricGroupCombinatoricFunctions| "SGCF.spad" 1534197 1534238 1541080 1541085) (|SquareFreeRegularTriangularSetCategory| "SFRTCAT.spad" 1533130 1533182 1534187 1534192) (|SquareFreeRegularTriangularSetGcdPackage| "SFRGCD.spad" 1532156 1532213 1533120 1533125) (|SquareFreeQuasiComponentPackage| "SFQCMPK.spad" 1526941 1526989 1532146 1532151) (|SExpressionOf| "SEXOF.spad" 1526774 1526824 1526931 1526936) (|SExpressionCategory| "SEXCAT.spad" 1524586 1524642 1526764 1526769) (|SExpression| "SEX.spad" 1524470 1524487 1524576 1524581) (|SetOfMIntegersInOneToN| "SETMN.spad" 1522911 1522947 1524460 1524465) (|SetCategory| "SETCAT.spad" 1522388 1522405 1522901 1522906) (|SetCategory&| "SETCAT.spad" 1521862 1521882 1522378 1522383) (|SetAggregate| "SETAGG.spad" 1518386 1518406 1521826 1521857) (|SetAggregate&| "SETAGG.spad" 1514933 1514956 1518376 1518381) (|Set| "SET.spad" 1513312 1513323 1514411 1514442) (|SequenceAst| "syntax.spad" 1513007 1513024 1513302 1513307) (|SegmentExpansionCategory| "SEGXCAT.spad" 1512142 1512176 1512997 1513002) (|SegmentCategory| "SEGCAT.spad" 1511055 1511078 1512132 1512137) (|SegmentBindingFunctions2| "SEGBIND2.spad" 1510732 1510766 1511045 1511050) (|SegmentBinding| "SEGBIND.spad" 1510467 1510489 1510667 1510672) (|SegmentAst| "SEGAST.spad" 1510190 1510206 1510457 1510462) (|SegmentFunctions2| "SEG2.spad" 1509602 1509629 1510137 1510142) (|Segment| "SEG.spad" 1509394 1509409 1509504 1509509) (|SequentialDifferentialVariable| "SDVAR.spad" 1508643 1508681 1509384 1509389) (|SequentialDifferentialPolynomial| "SDPOL.spad" 1506534 1506574 1506854 1507088) (|StructuralConstantsPackage| "SCPKG.spad" 1504600 1504634 1506524 1506529) (|Scope| "SCOPE.spad" 1503775 1503786 1504590 1504595) (|SortedCache| "SCACHE.spad" 1502463 1502482 1503765 1503770) (|SpadSyntaxCategory| "SASTCAT.spad" 1502357 1502381 1502453 1502458) (|SingletonAsOrderedSet| "SAOS.spad" 1502211 1502238 1502347 1502352) (|SAERationalFunctionAlgFactor| "SAERFFC.spad" 1501899 1501944 1502201 1502206) (|SimpleAlgebraicExtensionAlgFactor| "SAEFACT.spad" 1501570 1501620 1501889 1501894) (|SimpleAlgebraicExtension| "SAE.spad" 1499888 1499925 1500520 1500735) (|RationalUnivariateRepresentationPackage| "RURPK.spad" 1497511 1497563 1499878 1499883) (|Ruleset| "RULESET.spad" 1496964 1496988 1497501 1497506) (|RuleCalled| "RULECOLD.spad" 1496809 1496829 1496954 1496959) (|RewriteRule| "RULE.spad" 1495053 1495081 1496799 1496804) (|RuntimeValue| "RTVALUE.spad" 1494779 1494797 1495043 1495048) (|RestrictAst| "syntax.spad" 1494488 1494505 1494769 1494774) (|RegularTriangularSetGcdPackage| "RSETGCD.spad" 1490903 1490950 1494478 1494483) (|RegularTriangularSetCategory| "RSETCAT.spad" 1480868 1480910 1490893 1490898) (|RegularTriangularSetCategory&| "RSETCAT.spad" 1470830 1470875 1480858 1480863) (|RegularSetDecompositionPackage| "RSDCMPK.spad" 1469303 1469350 1470820 1470825) (|RealRootCharacterizationCategory| "RRCC.spad" 1467658 1467717 1469293 1469298) (|RealRootCharacterizationCategory&| "RRCC.spad" 1466010 1466072 1467648 1467653) (|RepeatAst| "RPTAST.spad" 1465706 1465721 1466000 1466005) (|RecursivePolynomialCategory| "RPOLCAT.spad" 1445079 1445118 1465467 1465701) (|RecursivePolynomialCategory&| "RPOLCAT.spad" 1424254 1424296 1444645 1444650) (|RomanNumeral| "ROMAN.spad" 1423468 1423486 1424015 1424249) (|RightOpenIntervalRootCharacterization| "ROIRC.spad" 1422514 1422580 1423458 1423463) (|RealNumberSystem| "RNS.spad" 1421405 1421427 1422344 1422509) (|RealNumberSystem&| "RNS.spad" 1420453 1420478 1421395 1421400) (|RangeBinding| "RNGBIND.spad" 1419596 1419619 1420400 1420405) (|Rng| "RNG.spad" 1419204 1419213 1419586 1419591) (|Rng&| "RNG.spad" 1418809 1418821 1419194 1419199) (|RightModule| "RMODULE.spad" 1418582 1418601 1418799 1418804) (|RectangularMatrixCategoryFunctions2| "RMCAT2.spad" 1417970 1418059 1418572 1418577) (|RectangularMatrix| "RMATRIX.spad" 1417028 1417061 1417385 1417429) (|RectangularMatrixCategory| "RMATCAT.spad" 1412770 1412823 1416979 1417023) (|RectangularMatrixCategory&| "RMATCAT.spad" 1408365 1408421 1412577 1412582) (|RightLinearSet| "RLINSET.spad" 1408058 1408080 1408355 1408360) (|RationalInterpolation| "RINTERP.spad" 1407932 1407966 1408048 1408053) (|Ring| "RING.spad" 1407394 1407404 1407905 1407927) (|Ring&| "RING.spad" 1406870 1406883 1407384 1407389) (|RandomIntegerDistributions| "RIDIST.spad" 1406239 1406271 1406860 1406865) (|RegularChain| "RGCHAIN.spad" 1404691 1404716 1405594 1405599) (|RGBColorSpace| "RGBCSPC.spad" 1404470 1404492 1404681 1404686) (|RGBColorModel| "RGBCMDL.spad" 1404022 1404044 1404460 1404465) (|RationalFunctionFactorizer| "RFFACTOR.spad" 1403461 1403495 1404012 1404017) (|RationalFunctionFactor| "RFFACT.spad" 1403177 1403208 1403451 1403456) (|RandomFloatDistributions| "RFDIST.spad" 1402152 1402182 1403167 1403172) (|RationalFunction| "RF.spad" 1399813 1399837 1402142 1402147) (|RetractSolvePackage| "RETSOL.spad" 1399216 1399245 1399803 1399808) (|RetractableTo| "RETRACT.spad" 1398634 1398655 1399206 1399211) (|RetractableTo&| "RETRACT.spad" 1398049 1398073 1398624 1398629) (|ReturnAst| "RETAST.spad" 1397855 1397870 1398039 1398044) (|ResidueRing| "RESRING.spad" 1397166 1397217 1397761 1397850) (|ResolveLatticeCompletion| "RESLATC.spad" 1396469 1396501 1397156 1397161) (|RepeatedSquaring| "REPSQ.spad" 1396187 1396211 1396459 1396464) (|RepeatedDoubling| "REPDB.spad" 1395881 1395905 1396177 1396182) (|RepresentationPackage2| "REP2.spad" 1385585 1385615 1395732 1395737) (|RepresentationPackage1| "REP1.spad" 1379778 1379808 1385527 1385532) (|RadicalEigenPackage| "REP.spad" 1377316 1377341 1379768 1379773) (|RegularTriangularSet| "REGSET.spad" 1375022 1375056 1376848 1376853) (|Reference| "REF.spad" 1374534 1374551 1375012 1375017) (|ReductionOfOrder| "REDORDER.spad" 1373731 1373757 1374524 1374529) (|RealClosure| "RECLOS.spad" 1372649 1372677 1373361 1373526) (|RealSolvePackage| "REALSOLV.spad" 1371776 1371798 1372639 1372644) (|RealZeroPackageQ| "REAL0Q.spad" 1369061 1369089 1371766 1371771) (|RealZeroPackage| "REAL0.spad" 1365893 1365920 1369051 1369056) (|RealConstant| "REAL.spad" 1365756 1365774 1365883 1365888) (|ReduceAst| "RDUCEAST.spad" 1365471 1365486 1365746 1365751) (|ReducedDivisor| "RDIV.spad" 1365115 1365151 1365461 1365466) (|RandomDistributions| "RDIST.spad" 1364666 1364693 1365105 1365110) (|TranscendentalRischDESystem| "RDETRS.spad" 1363510 1363548 1364656 1364661) (|TranscendentalRischDE| "RDETR.spad" 1361635 1361667 1363500 1363505) (|ElementaryRischDESystem| "RDEEFS.spad" 1360718 1360751 1361625 1361630) (|ElementaryRischDE| "RDEEF.spad" 1359718 1359745 1360708 1360713) (|RealClosedField| "RCFIELD.spad" 1356852 1356873 1359548 1359713) (|RealClosedField&| "RCFIELD.spad" 1354143 1354167 1356842 1356847) (|RecursiveAggregate| "RCAGG.spad" 1352064 1352090 1354133 1354138) (|RecursiveAggregate&| "RCAGG.spad" 1349855 1349884 1351927 1351932) (|RationalRetractions| "RATRET.spad" 1349199 1349226 1349845 1349850) (|RationalFactorize| "RATFACT.spad" 1348877 1348903 1349189 1349194) (|RandomNumberSource| "RANDSRC.spad" 1348181 1348205 1348867 1348872) (|RadixUtilities| "RADUTIL.spad" 1347926 1347946 1348171 1348176) (|RadixExpansion| "RADIX.spad" 1344822 1344847 1346379 1346544) (|RadicalFunctionField| "RADFF.spad" 1343571 1343621 1343703 1343932) (|RadicalCategory| "RADCAT.spad" 1343154 1343175 1343561 1343566) (|RadicalCategory&| "RADCAT.spad" 1342734 1342758 1343144 1343149) (|Queue| "QUEUE.spad" 1342219 1342232 1342480 1342485) (|QuaternionCategoryFunctions2| "QUATCT2.spad" 1341814 1341858 1342209 1342214) (|QuaternionCategory| "QUATCAT.spad" 1339926 1339952 1341701 1341809) (|QuaternionCategory&| "QUATCAT.spad" 1337742 1337771 1339520 1339525) (|Quaternion| "QUAT.spad" 1336226 1336244 1336576 1336684) (|QueueAggregate| "QUAGG.spad" 1335070 1335092 1336216 1336221) (|QuasiquoteAst| "QQUTAST.spad" 1334828 1334847 1335060 1335065) (|QuadraticForm| "QFORM.spad" 1334436 1334461 1334818 1334823) (|QuotientFieldCategoryFunctions2| "QFCAT2.spad" 1334100 1334145 1334426 1334431) (|QuotientFieldCategory| "QFCAT.spad" 1332712 1332741 1333930 1334095) (|QuotientFieldCategory&| "QFCAT.spad" 1330841 1330873 1332062 1332067) (|QueryEquation| "QEQUAT.spad" 1330389 1330408 1330831 1330836) (|QuasiComponentPackage| "QCMPACK.spad" 1325285 1325323 1330379 1330384) (|QuasiAlgebraicSet2| "QALGSET2.spad" 1323265 1323299 1325275 1325280) (|QuasiAlgebraicSet| "QALGSET.spad" 1319326 1319373 1323150 1323155) (|PAdicWildFunctionFieldIntegralBasis| "PWFFINTB.spad" 1316713 1316763 1319316 1319321) (|PushVariables| "PUSHVAR.spad" 1316041 1316071 1316703 1316708) (|PartialTranscendentalFunctions| "PTRANFN.spad" 1312149 1312187 1316031 1316036) (|PointPackage| "PTPACK.spad" 1309227 1309247 1312139 1312144) (|PointFunctions2| "PTFUNC2.spad" 1309037 1309064 1309217 1309222) (|PointCategory| "PTCAT.spad" 1308303 1308324 1309027 1309032) (|PolynomialSquareFree| "PSQFR.spad" 1307600 1307642 1308293 1308298) (|PseudoLinearNormalForm| "PSEUDLIN.spad" 1306466 1306496 1307590 1307595) (|PolynomialSetUtilitiesPackage| "PSETPK.spad" 1293108 1293151 1306308 1306313) (|PolynomialSetCategory| "PSETCAT.spad" 1287499 1287541 1293098 1293103) (|PolynomialSetCategory&| "PSETCAT.spad" 1281841 1281886 1287443 1287448) (|PlottableSpaceCurveCategory| "PSCURVE.spad" 1280815 1280848 1281831 1281836) (|PowerSeriesCategory| "PSCAT.spad" 1279513 1279559 1280645 1280810) (|PowerSeriesCategory&| "PSCAT.spad" 1278368 1278417 1279503 1279508) (|Partition| "PRTITION.spad" 1277059 1277074 1278358 1278363) (|PretendAst| "PRTDAST.spad" 1276770 1276786 1277049 1277054) (|PseudoRemainderSequence| "PRS.spad" 1266360 1266398 1276719 1276724) (|PriorityQueueAggregate| "PRQAGG.spad" 1265797 1265827 1266350 1266355) (|PropositionalLogic| "PROPLOG.spad" 1265385 1265409 1265787 1265792) (|PropositionalFormulaFunctions2| "PROPFUN2.spad" 1264980 1265021 1265375 1265380) (|PropositionalFormulaFunctions1| "PROPFUN1.spad" 1264358 1264397 1264970 1264975) (|PropositionalFormula| "PROPFRML.spad" 1262908 1262937 1264348 1264353) (|Property| "PROPERTY.spad" 1262398 1262412 1262898 1262903) (|Product| "PRODUCT.spad" 1261269 1261286 1261558 1261623) (|PrintPackage| "PRINT.spad" 1261011 1261029 1261259 1261264) (|IntegerPrimesPackage| "PRIMES.spad" 1259254 1259282 1261001 1261006) (|PrimitiveElement| "PRIMELT.spad" 1257365 1257389 1259244 1259249) (|PrimitiveFunctionCategory| "PRIMCAT.spad" 1256985 1257016 1257355 1257360) (|PrimitiveArrayFunctions2| "PRIMARR2.spad" 1255730 1255764 1256975 1256980) (|PrimitiveArray| "PRIMARR.spad" 1254942 1254964 1255124 1255129) (|PrecomputedAssociatedEquations| "PREASSOC.spad" 1254296 1254336 1254932 1254937) (|PolynomialRing| "PR.spad" 1252729 1252753 1253440 1253674) (|PlottablePlaneCurveCategory| "PPCURVE.spad" 1251841 1251874 1252719 1252724) (|PortNumber| "PORTNUM.spad" 1251624 1251640 1251831 1251836) (|PolynomialRoots| "POLYROOT.spad" 1250457 1250488 1251573 1251578) (|PolynomialCategoryLifting| "POLYLIFT.spad" 1249699 1249745 1250447 1250452) (|PolynomialCategoryQuotientFunctions| "POLYCATQ.spad" 1247796 1247847 1249689 1249694) (|PolynomialCategory| "POLYCAT.spad" 1241175 1241212 1247557 1247791) (|PolynomialCategory&| "POLYCAT.spad" 1234118 1234158 1240503 1240508) (|PolynomialToUnivariatePolynomial| "POLY2UP.spad" 1233540 1233584 1234108 1234113) (|PolynomialFunctions2| "POLY2.spad" 1233119 1233149 1233530 1233535) (|Polynomial| "POLY.spad" 1231074 1231092 1231597 1231831) (|RealPolynomialUtilitiesPackage| "POLUTIL.spad" 1230002 1230059 1231021 1231026) (|PolToPol| "POLTOPOL.spad" 1228744 1228765 1229992 1229997) (|Point| "POINT.spad" 1227763 1227776 1227853 1227858) (|PolynomialNumberTheoryFunctions| "PNTHEORY.spad" 1224436 1224473 1227753 1227758) (|PatternMatchTools| "PMTOOLS.spad" 1223196 1223225 1224426 1224431) (|PatternMatchSymbol| "PMSYM.spad" 1222729 1222755 1223186 1223191) (|PatternMatchQuotientFieldCategory| "PMQFCAT.spad" 1222289 1222334 1222719 1222724) (|FunctionSpaceAttachPredicates| "PMPREDFS.spad" 1221732 1221773 1222279 1222284) (|AttachPredicates| "PMPRED.spad" 1221209 1221233 1221722 1221727) (|PatternMatchPolynomialCategory| "PMPLCAT.spad" 1220244 1220290 1221124 1221129) (|PatternMatchListAggregate| "PMLSAGG.spad" 1219806 1219843 1220234 1220239) (|PatternMatchKernel| "PMKERNEL.spad" 1219369 1219397 1219796 1219801) (|PatternMatchIntegerNumberSystem| "PMINS.spad" 1218920 1218959 1219359 1219364) (|PatternMatchFunctionSpace| "PMFS.spad" 1218478 1218515 1218910 1218915) (|PatternMatchPushDown| "PMDOWN.spad" 1217750 1217782 1218468 1218473) (|FunctionSpaceAssertions| "PMASSFS.spad" 1216708 1216741 1217740 1217745) (|PatternMatchAssertions| "PMASS.spad" 1215706 1215734 1216698 1216703) (|PlotTools| "PLOTTOOL.spad" 1215479 1215494 1215696 1215701) (|Plot3D| "PLOT3D.spad" 1211939 1211951 1215469 1215474) (|PlotFunctions1| "PLOT1.spad" 1211100 1211122 1211929 1211934) (|Plot| "PLOT.spad" 1206021 1206031 1211090 1211095) (|ParametricLinearEquations| "PLEQN.spad" 1193400 1193450 1206011 1206016) (|PolynomialInterpolationAlgorithms| "PINTERPA.spad" 1193157 1193200 1193390 1193395) (|PolynomialInterpolation| "PINTERP.spad" 1192762 1192798 1193147 1193152) (|PrincipalIdealDomain| "PID.spad" 1191675 1191701 1192645 1192757) (|PiCoercions| "PICOERCE.spad" 1191323 1191342 1191665 1191670) (|PositiveInteger| "PI.spad" 1190919 1190940 1191289 1191318) (|PolyGroebner| "PGROEB.spad" 1189522 1189542 1190909 1190914) (|PermutationGroupExamples| "PGE.spad" 1181173 1181203 1189512 1189517) (|PolynomialGcdPackage| "PGCD.spad" 1180109 1180144 1181163 1181168) (|PartialFractionPackage| "PFRPAC.spad" 1179238 1179268 1180099 1180104) (|PartialFraction| "PFR.spad" 1175856 1175879 1179068 1179233) (|PointsOfFiniteOrderTools| "PFOTOOLS.spad" 1175092 1175130 1175846 1175851) (|PointsOfFiniteOrderRational| "PFOQ.spad" 1174437 1174480 1175082 1175087) (|PointsOfFiniteOrder| "PFO.spad" 1173843 1173883 1174427 1174432) (|PolynomialFactorizationExplicit| "PFECAT.spad" 1171481 1171518 1173726 1173838) (|PolynomialFactorizationExplicit&| "PFECAT.spad" 1169170 1169210 1171418 1171423) (|PolynomialFactorizationByRecursionUnivariate| "PFBRU.spad" 1167016 1167070 1169160 1169165) (|PolynomialFactorizationByRecursion| "PFBR.spad" 1164544 1164599 1167006 1167011) (|PrimeField| "PF.spad" 1163999 1164019 1164238 1164403) (|PermutationGroup| "PERMGRP.spad" 1158755 1158779 1163989 1163994) (|PermutationCategory| "PERMCAT.spad" 1157392 1157419 1158728 1158750) (|Permanent| "PERMAN.spad" 1155941 1155962 1157382 1157387) (|Permutation| "PERM.spad" 1151781 1151800 1155813 1155835) (|PendantTree| "PENDTREE.spad" 1151167 1151186 1151456 1151461) (|PartialDifferentialSpace| "PDSPC.spad" 1149958 1149990 1151157 1151162) (|PartialDifferentialSpace&| "PDSPC.spad" 1148746 1148781 1149948 1149953) (|PartialDifferentialRing| "PDRING.spad" 1148560 1148591 1148719 1148741) (|PartialDifferentialModule| "PDMOD.spad" 1148336 1148371 1148511 1148555) (|PolynomialDecomposition| "PDECOMP.spad" 1147789 1147823 1148326 1148331) (|PartialDifferentialDomain| "PDDOM.spad" 1147204 1147240 1147779 1147784) (|PartialDifferentialDomain&| "PDDOM.spad" 1146616 1146655 1147194 1147199) (|PolynomialComposition| "PCOMP.spad" 1146450 1146482 1146606 1146611) (|PoincareBirkhoffWittLyndonBasis| "PBWLB.spad" 1145019 1145065 1146440 1146445) (|PatternFunctions2| "PATTERN2.spad" 1144742 1144769 1145009 1145014) (|PatternFunctions1| "PATTERN1.spad" 1143075 1143102 1144732 1144737) (|Pattern| "PATTERN.spad" 1137645 1137660 1143065 1143070) (|PatternMatchResultFunctions2| "PATRES2.spad" 1137291 1137331 1137635 1137640) (|PatternMatchResult| "PATRES.spad" 1134858 1134886 1137281 1137286) (|PatternMatch| "PATMATCH.spad" 1133184 1133225 1134705 1134710) (|PatternMatchable| "PATMAB.spad" 1132599 1132623 1133174 1133179) (|PatternMatchListResult| "PATLRES.spad" 1131665 1131699 1132589 1132594) (|Patternable| "PATAB.spad" 1131420 1131439 1131655 1131660) (|PartitionsAndPermutations| "PARTPERM.spad" 1129453 1129484 1131410 1131415) (|ParametricSurface| "PARSURF.spad" 1128872 1128915 1129443 1129448) (|ParametricSurfaceFunctions2| "PARSU2.spad" 1128644 1128685 1128862 1128867) (|Parser| "script-parser.spad" 1128160 1128172 1128634 1128639) (|ParametricSpaceCurve| "PARSCURV.spad" 1127576 1127622 1128150 1128155) (|ParametricSpaceCurveFunctions2| "PARSC2.spad" 1127339 1127383 1127566 1127571) (|ParametricPlaneCurve| "PARPCURV.spad" 1126783 1126829 1127329 1127334) (|ParametricPlaneCurveFunctions2| "PARPC2.spad" 1126546 1126590 1126773 1126778) (|ParameterAst| "PARAMAST.spad" 1125664 1125682 1126536 1126541) (|PolynomialAN2Expression| "PAN2EXPR.spad" 1125055 1125084 1125654 1125659) (|Palette| "PALETTE.spad" 1124164 1124177 1125045 1125050) (|Pair| "PAIR.spad" 1123393 1123408 1123964 1123969) (|PAdicRationalConstructor| "PADICRC.spad" 1120585 1120625 1121770 1121935) (|PAdicRational| "PADICRAT.spad" 1118704 1118727 1118928 1119093) (|PAdicIntegerCategory| "PADICCT.spad" 1117192 1117222 1118587 1118699) (|PAdicInteger| "PADIC.spad" 1116842 1116864 1117075 1117187) (|PadeApproximantPackage| "PADEPAC.spad" 1115511 1115550 1116832 1116837) (|PadeApproximants| "PADE.spad" 1114249 1114279 1115501 1115506) (|OrdinaryWeightedPolynomials| "OWP.spad" 1113413 1113468 1114048 1114158) (|OverloadSet| "OVERSET.spad" 1112977 1112994 1113403 1113408) (|OrderedVariableList| "OVAR.spad" 1112741 1112781 1112967 1112972) (|OutputForm| "OUTFORM.spad" 1102141 1102157 1112731 1112736) (|OutputBinaryFile| "OUTBFILE.spad" 1101561 1101583 1102131 1102136) (|OutputByteConduit| "OUTBCON.spad" 1100616 1100639 1101551 1101556) (|OutputByteConduit&| "OUTBCON.spad" 1099668 1099694 1100606 1100611) (|OutputPackage| "OUT.spad" 1098775 1098794 1099658 1099663) (|OrdSetInts| "OSI.spad" 1098242 1098258 1098765 1098770) (|OrderedSemiGroup| "OSGROUP.spad" 1098146 1098168 1098232 1098237) (|OrthogonalPolynomialFunctions| "ORTHPOL.spad" 1096613 1096650 1098072 1098077) (|UnivariateSkewPolynomial| "OREUP.spad" 1095991 1096043 1096242 1096305) (|SparseUnivariateSkewPolynomial| "ORESUP.spad" 1095211 1095265 1095620 1095683) (|UnivariateSkewPolynomialCategoryOps| "OREPCTO.spad" 1093052 1093097 1095116 1095121) (|UnivariateSkewPolynomialCategory| "OREPCAT.spad" 1087185 1087225 1092984 1093047) (|UnivariateSkewPolynomialCategory&| "OREPCAT.spad" 1081196 1081239 1086998 1087003) (|OrderedType| "ORDTYPE.spad" 1080424 1080441 1081186 1081191) (|OrderedType&| "ORDTYPE.spad" 1079649 1079669 1080414 1080419) (|OrderedStructure| "ORDSTRCT.spad" 1079404 1079433 1079581 1079586) (|OrderedSet| "ORDSET.spad" 1079096 1079112 1079394 1079399) (|OrderedRing| "ORDRING.spad" 1078897 1078914 1079069 1079091) (|OrderedMonoid| "ORDMON.spad" 1078741 1078760 1078887 1078892) (|OrderingFunctions| "ORDFUNS.spad" 1077858 1077889 1078731 1078736) (|OrderedFinite| "ORDFIN.spad" 1077667 1077686 1077848 1077853) (|OrderedCompletionFunctions2| "ORDCOMP2.spad" 1076935 1076972 1077657 1077662) (|OrderedCompletion| "ORDCOMP.spad" 1075485 1075510 1076582 1076627) (|OperatorSignature| "OPSIG.spad" 1075132 1075155 1075475 1075480) (|OperationsQuery| "OPQUERY.spad" 1074700 1074721 1075122 1075127) (|OperatorCategory| "OPERCAT.spad" 1074152 1074176 1074690 1074695) (|OperatorCategory&| "OPERCAT.spad" 1073601 1073628 1074142 1074147) (|Operator| "OP.spad" 1073246 1073262 1073332 1073442) (|OnePointCompletionFunctions2| "ONECOMP2.spad" 1072644 1072682 1073236 1073241) (|OnePointCompletion| "ONECOMP.spad" 1071473 1071499 1072291 1072336) (|OrderedMultisetAggregate| "OMSAGG.spad" 1071247 1071279 1071437 1071468) (|OppositeMonogenicLinearOperator| "OMLO.spad" 1070600 1070641 1071082 1071145) (|OrderedIntegralDomain| "OINTDOM.spad" 1070301 1070328 1070483 1070595) (|OrderedFreeMonoid| "OFMONOID.spad" 1068417 1068442 1070249 1070254) (|OrderlyDifferentialVariable| "ODVAR.spad" 1067653 1067688 1068407 1068412) (|OrdinaryDifferentialRing| "ODR.spad" 1067193 1067241 1067383 1067611) (|OrderlyDifferentialPolynomial| "ODPOL.spad" 1065040 1065077 1065407 1065641) (|OrderedDirectProduct| "ODP.spad" 1061748 1061786 1062139 1062270) (|ODETools| "ODETOOLS.spad" 1060395 1060416 1061738 1061743) (|SystemODESolver| "ODESYS.spad" 1058080 1058106 1060385 1060390) (|RationalRicDE| "ODERTRIC.spad" 1054083 1054107 1058014 1058019) (|ReduceLODE| "ODERED.spad" 1053478 1053506 1054073 1054078) (|RationalLODE| "ODERAT.spad" 1051105 1051128 1053468 1053473) (|PrimitiveRatRicDE| "ODEPRRIC.spad" 1048187 1048220 1051095 1051100) (|PrimitiveRatDE| "ODEPRIM.spad" 1045577 1045607 1048177 1048182) (|PureAlgebraicLODE| "ODEPAL.spad" 1044952 1044987 1045567 1045572) (|ODEIntegration| "ODEINT.spad" 1044379 1044403 1044942 1044947) (|ElementaryFunctionODESolver| "ODEEF.spad" 1039853 1039890 1044369 1044374) (|ConstantLODE| "ODECONST.spad" 1039392 1039416 1039843 1039848) (|OctonionCategoryFunctions2| "OCTCT2.spad" 1039009 1039051 1039382 1039387) (|Octonion| "OCT.spad" 1037385 1037401 1038105 1038168) (|OrderedCancellationAbelianMonoid| "OCAMON.spad" 1037203 1037241 1037375 1037380) (|OctonionCategory| "OC.spad" 1034961 1034985 1037135 1037198) (|OctonionCategory&| "OC.spad" 1032382 1032409 1034559 1034564) (|OrderedAbelianSemiGroup| "OASGP.spad" 1032176 1032205 1032372 1032377) (|OrderedAbelianMonoidSup| "OAMONS.spad" 1031677 1031706 1032166 1032171) (|OrderedAbelianMonoid| "OAMON.spad" 1031417 1031443 1031667 1031672) (|OrderedAbelianMonoid&| "OAMON.spad" 1031154 1031183 1031407 1031412) (|OrderedAbelianGroup| "OAGROUP.spad" 1030675 1030700 1031144 1031149) (|OrderedAbelianGroup&| "OAGROUP.spad" 1030193 1030221 1030665 1030670) (|NumericTubePlot| "NUMTUBE.spad" 1029771 1029800 1030183 1030188) (|NumericalQuadrature| "NUMQUAD.spad" 1017730 1017755 1029761 1029766) (|NumericalOrdinaryDifferentialEquations| "NUMODE.spad" 1009046 1009090 1017720 1017725) (|NumberFormats| "NUMFMT.spad" 1007875 1007894 1009036 1009041) (|Numeric| "NUMERIC.spad" 999979 999994 1007675 1007680) (|NormalizedTriangularSetCategory| "NTSCAT.spad" 998480 998525 999969 999974) (|NumberTheoreticPolynomialFunctions| "NTPOLFN.spad" 998008 998050 998406 998411) (|NewSparseUnivariatePolynomialFunctions2| "NSUP2.spad" 997363 997412 997998 998003) (|NewSparseUnivariatePolynomial| "NSUP.spad" 991034 991071 995481 995758) (|NewSparseMultivariatePolynomial| "NSMP.spad" 988810 988858 989131 989365) (|NumericRealEigenPackage| "NREP.spad" 987191 987226 988800 988805) (|NPCoef| "NPCOEF.spad" 986433 986457 987181 987186) (|NormRetractPackage| "NORMRETR.spad" 986019 986070 986423 986428) (|NormalizationPackage| "NORMPK.spad" 983943 983980 986009 986014) (|NormInMonogenicAlgebra| "NORMMA.spad" 983611 983657 983933 983938) (|NoneFunctions1| "NONE1.spad" 983275 983297 983601 983606) (|None| "NONE.spad" 983014 983024 983265 983270) (|NonLinearFirstOrderODESolver| "NODE1.spad" 982479 982517 983004 983009) (|NonNegativeInteger| "NNI.spad" 981350 981374 982445 982474) (|NonLinearSolvePackage| "NLINSOL.spad" 979957 979986 981340 981345) (|NumberFieldIntegralBasis| "NFINTBAS.spad" 977499 977534 979947 979952) (|NetworkClientSocket| "NETCLT.spad" 977456 977484 977489 977494) (|NonCommutativeOperatorDivision| "NCODIV.spad" 975656 975696 977446 977451) (|NumericContinuedFraction| "NCNTFRAC.spad" 975280 975312 975646 975651) (|NumericComplexEigenPackage| "NCEP.spad" 973422 973460 975270 975275) (|NonAssociativeRing| "NASRING.spad" 973010 973034 973412 973417) (|NonAssociativeRing&| "NASRING.spad" 972595 972622 973000 973005) (|NonAssociativeRng| "NARNG.spad" 971980 972003 972585 972590) (|NonAssociativeRng&| "NARNG.spad" 971362 971388 971970 971975) (|NonAssociativeAlgebra| "NAALG.spad" 970891 970920 971313 971357) (|NonAssociativeAlgebra&| "NAALG.spad" 970456 970488 970881 970886) (|MultivariateSquareFree| "MULTSQFR.spad" 967394 967431 970446 970451) (|MultivariateFactorize| "MULTFACT.spad" 966758 966794 967384 967389) (|MultivariateTaylorSeriesCategory| "MTSCAT.spad" 964754 964805 966588 966753) (|MergeThing| "MTHING.spad" 964405 964423 964744 964749) (|MoreSystemCommands| "MSYSCMD.spad" 963823 963847 964395 964400) (|MultisetAggregate| "MSETAGG.spad" 963649 963674 963787 963818) (|Multiset| "MSET.spad" 961490 961506 963243 963274) (|MonoidRing| "MRING.spad" 958509 958529 961103 961213) (|MonoidRingFunctions2| "MRF2.spad" 958053 958085 958499 958504) (|MRationalFactorize| "MRATFAC.spad" 957583 957616 958043 958048) (|MPolyCatRationalFunctionFactorizer| "MPRFF.spad" 955591 955642 957573 957578) (|MultivariatePolynomial| "MPOLY.spad" 953672 953707 954051 954285) (|MPolyCatPolyFactorizer| "MPCPF.spad" 952916 952955 953662 953667) (|MPolyCatFunctions3| "MPC3.spad" 952717 952773 952906 952911) (|MPolyCatFunctions2| "MPC2.spad" 952355 952404 952707 952712) (|MonomialExtensionTools| "MONOTOOL.spad" 950690 950723 952345 952350) (|MonoidOperatorCategory| "catdef.spad" 950097 950128 950338 950685) (|MonoidOperation| "catdef.spad" 949503 949527 949772 950092) (|Monoid| "MONOID.spad" 948820 948832 949493 949498) (|Monoid&| "MONOID.spad" 948134 948149 948810 948815) (|MonogenicAlgebra| "MONOGEN.spad" 946788 946815 947914 948129) (|MonogenicAlgebra&| "MONOGEN.spad" 945519 945549 946648 946653) (|MonadWithUnit| "MONADWU.spad" 943588 943607 945509 945514) (|MonadWithUnit&| "MONADWU.spad" 941654 941676 943578 943583) (|Monad| "MONAD.spad" 940811 940822 941644 941649) (|Monad&| "MONAD.spad" 939965 939979 940801 940806) (|MoebiusTransform| "MOEBIUS.spad" 938684 938708 939938 939960) (|Module| "MODULE.spad" 938533 938547 938635 938679) (|Module&| "MODULE.spad" 938418 938435 938523 938528) (|ModularRing| "MODRING.spad" 937729 937785 938391 938413) (|ModuleOperator| "MODOP.spad" 936283 936307 937460 937570) (|ModuleMonomial| "MODMONOM.spad" 936002 936032 936273 936278) (|ModMonic| "MODMON.spad" 933306 933324 934027 934304) (|ModularField| "MODFIELD.spad" 932578 932635 933136 933301) (|MathMLFormat| "MMLFORM.spad" 931428 931446 932568 932573) (|MultipleMap| "MMAP.spad" 931161 931204 931418 931423) (|MonogenicLinearOperator| "MLO.spad" 929575 929606 931093 931156) (|MultivariateLifting| "MLIFT.spad" 928170 928204 929565 929570) (|MakeUnaryCompiledFunction| "MKUCFUNC.spad" 927686 927723 928160 928165) (|MakeRecord| "MKRECORD.spad" 927266 927287 927676 927681) (|MakeFunction| "MKFUNC.spad" 926663 926683 927256 927261) (|MakeFloatCompiledFunction| "MKFLCFN.spad" 925608 925641 926653 926658) (|MakeBinaryCompiledFunction| "MKBCFUNC.spad" 925079 925121 925598 925603) (|ModularHermitianRowReduction| "MHROWRED.spad" 923564 923600 925069 925074) (|MultFiniteFactorize| "MFINFACT.spad" 922951 922986 923554 923559) (|MeshCreationRoutinesForThreeDimensions| "MESH.spad" 920710 920754 922941 922946) (|ModularDistinctDegreeFactorizer| "MDDFACT.spad" 918900 918939 920700 920705) (|MultiDictionary| "MDAGG.spad" 918188 918211 918890 918895) (|MatrixCommonDenominator| "MCDEN.spad" 917377 917410 918178 918183) (|Maybe| "MAYBE.spad" 916674 916688 917367 917372) (|StorageEfficientMatrixOperations| "MATSTOR.spad" 913960 914000 916664 916669) (|Matrix| "MATRIX.spad" 912939 912953 913427 913432) (|MatrixLinearAlgebraFunctions| "MATLIN.spad" 910253 910303 912795 912800) (|MatrixCategoryFunctions2| "MATCAT2.spad" 909513 909583 910243 910248) (|MatrixCategory| "MATCAT.spad" 901219 901253 909503 909508) (|MatrixCategory&| "MATCAT.spad" 892738 892775 901025 901030) (|MappingPackage3| "MAPPKG3.spad" 891640 891667 892728 892733) (|MappingPackage2| "MAPPKG2.spad" 890965 890990 891630 891635) (|MappingPackage1| "MAPPKG1.spad" 889780 889803 890955 890960) (|MappingAst| "MAPPAST.spad" 889111 889127 889770 889775) (|MappingPackageInternalHacks3| "MAPHACK3.spad" 888897 888937 889101 889106) (|MappingPackageInternalHacks2| "MAPHACK2.spad" 888640 888678 888887 888892) (|MappingPackageInternalHacks1| "MAPHACK1.spad" 888258 888294 888630 888635) (|Magma| "MAGMA.spad" 886061 886081 888248 888253) (|MacroAst| "MACROAST.spad" 885650 885664 886051 886056) (|LazyStreamAggregate| "LZSTAGG.spad" 882887 882914 885640 885645) (|LazyStreamAggregate&| "LZSTAGG.spad" 880121 880151 882877 882882) (|LyndonWord| "LWORD.spad" 876858 876883 880111 880116) (|ConstructAst| "LSTAST.spad" 876632 876650 876848 876853) (|LieSquareMatrix| "LSQM.spad" 875186 875213 875593 875656) (|LinearSystemPolynomialPackage| "LSPP.spad" 874694 874738 875176 875181) (|LinearSystemMatrixPackage1| "LSMP1.spad" 872517 872551 874684 874689) (|LinearSystemMatrixPackage| "LSMP.spad" 871355 871402 872507 872512) (|ListAggregate| "LSAGG.spad" 871035 871056 871345 871350) (|ListAggregate&| "LSAGG.spad" 870712 870736 871025 871030) (|LiePolynomial| "LPOLY.spad" 869630 869660 870535 870621) (|LinearPolynomialEquationByFractions| "LPEFRAC.spad" 868868 868911 869620 869625) (|Logic| "LOGIC.spad" 868407 868418 868858 868863) (|Logic&| "LOGIC.spad" 867943 867957 868397 868402) (|LinearOrdinaryDifferentialOperatorsOps| "LODOOPS.spad" 866837 866885 867933 867938) (|LinearOrdinaryDifferentialOperatorFactorizer| "LODOF.spad" 865822 865877 866771 866776) (|LinearOrdinaryDifferentialOperatorCategory| "LODOCAT.spad" 864424 864474 865754 865817) (|LinearOrdinaryDifferentialOperatorCategory&| "LODOCAT.spad" 863044 863097 864377 864382) (|LinearOrdinaryDifferentialOperator2| "LODO2.spad" 862233 862278 862673 862736) (|LinearOrdinaryDifferentialOperator1| "LODO1.spad" 861549 861592 861862 861925) (|LinearOrdinaryDifferentialOperator| "LODO.spad" 860849 860898 861178 861241) (|ElementaryFunctionLODESolver| "LODEEF.spad" 859629 859669 860839 860844) (|Localize| "LO.spad" 858990 859010 859529 859573) (|LinearAggregate| "LNAGG.spad" 855164 855187 858980 858985) (|LinearAggregate&| "LNAGG.spad" 851251 851277 855070 855075) (|ListMonoidOps| "LMOPS.spad" 848008 848036 851241 851246) (|LeftModule| "LMODULE.spad" 847784 847802 847998 848003) (|ListMultiDictionary| "LMDICT.spad" 847126 847153 847391 847396) (|LeftLinearSet| "LLINSET.spad" 846822 846843 847116 847121) (|Literal| "LITERAL.spad" 846723 846739 846812 846817) (|ListFunctions3| "LIST3.spad" 846022 846048 846713 846718) (|ListToMap| "LIST2MAP.spad" 842942 842961 846012 846017) (|ListFunctions2| "LIST2.spad" 841632 841656 842932 842937) (|List| "LIST.spad" 839681 839693 841026 841031) (|LinearSet| "LINSET.spad" 839453 839470 839671 839676) (|LinearForm| "LINFORM.spad" 838891 838911 839404 839448) (|LinearlyExplicitRingOver| "LINEXP.spad" 837612 837644 838881 838886) (|LinearElement| "LINELT.spad" 836947 836970 837470 837514) (|LinearDependence| "LINDEP.spad" 835808 835834 836885 836890) (|LinearBasis| "LINBASIS.spad" 835435 835459 835798 835803) (|RationalFunctionLimitPackage| "LIMITRF.spad" 833356 833392 835425 835430) (|PowerSeriesLimitPackage| "LIMITPS.spad" 832245 832279 833346 833351) (|LieAlgebra| "LIECAT.spad" 831704 831722 832154 832240) (|LieAlgebra&| "LIECAT.spad" 831204 831225 831657 831662) (|AssociatedLieAlgebra| "LIE.spad" 829374 829404 830666 830885) (|Library| "LIB.spad" 828142 828155 828593 828598) (|LinGroebnerPackage| "LGROBP.spad" 825483 825514 828132 828137) (|LiouvillianFunctionCategory| "LFCAT.spad" 824517 824550 825473 825478) (|LiouvillianFunction| "LF.spad" 823459 823488 824507 824512) (|LexTriangularPackage| "LEXTRIPK.spad" 819064 819097 823449 823454) (|LieExponentials| "LEXP.spad" 817063 817103 819037 819059) (|LetAst| "LETAST.spad" 816758 816770 817053 817058) (|LeadingCoefDetermination| "LEADCDET.spad" 815142 815181 816748 816753) (|LazardSetSolvingPackage| "LAZM3PK.spad" 813865 813908 815132 815137) (|LaurentPolynomial| "LAUPOL.spad" 812329 812357 813244 813356) (|LaplaceTransform| "LAPLACE.spad" 811902 811928 812319 812324) (|LeftAlgebra| "LALG.spad" 811662 811681 811875 811897) (|LeftAlgebra&| "LALG.spad" 811436 811458 811652 811657) (|LocalAlgebra| "LA.spad" 810833 810857 811325 811388) (|ConvertibleFrom| "KVTFROM.spad" 810563 810586 810823 810828) (|KleeneTrivalentLogic| "KTVLOGIC.spad" 810089 810115 810553 810558) (|CoercibleFrom| "KRCFROM.spad" 809824 809845 810079 810084) (|Kovacic| "KOVACIC.spad" 808554 808572 809814 809819) (|ConvertibleTo| "KONVERT.spad" 808265 808286 808544 808549) (|CoercibleTo| "KOERCE.spad" 807993 808012 808255 808260) (|KernelFunctions2| "KERNEL2.spad" 807682 807708 807983 807988) (|Kernel| "KERNEL.spad" 806340 806354 807473 807478) (|KeyedDictionary| "KDAGG.spad" 805446 805481 806330 806335) (|KeyedDictionary&| "KDAGG.spad" 804549 804587 805436 805441) (|KeyedAccessFile| "KAFILE.spad" 803474 803503 803722 803727) (|JVMOpcode| "JVMOP.spad" 803380 803395 803464 803469) (|JVMMethodAccess| "JVMMDACC.spad" 802421 802442 803370 803375) (|JVMFieldAccess| "JVMFDACC.spad" 801725 801745 802411 802416) (|JVMConstantTag| "JVMCSTTG.spad" 800442 800462 801715 801720) (|JVMClassFileAccess| "JVMCFACC.spad" 799872 799896 800432 800437) (|JVMBytecode| "JVMBCODE.spad" 799774 799791 799862 799867) (|AssociatedJordanAlgebra| "JORDAN.spad" 797754 797787 799236 799455) (|JoinAst| "JOINAST.spad" 797451 797464 797744 797749) (|IndexedAggregate| "IXAGG.spad" 795570 795608 797441 797446) (|IndexedAggregate&| "IXAGG.spad" 793451 793492 795325 795330) (|InfiniteTuple| "ITUPLE.spad" 792732 792753 793441 793446) (|InnerTrigonometricManipulations| "ITRIGMNP.spad" 791554 791598 792722 792727) (|InfiniteTupleFunctions3| "ITFUN3.spad" 791039 791074 791544 791549) (|InfiniteTupleFunctions2| "ITFUN2.spad" 790762 790795 791029 791034) (|InternalTypeForm| "ITFORM.spad" 790103 790125 790752 790757) (|InnerTaylorSeries| "ITAYLOR.spad" 788009 788039 789894 790052) (|InnerSparseUnivariatePowerSeries| "ISUPS.spad" 780571 780616 787138 787303) (|InnerPolySum| "ISUMP.spad" 780062 780088 780561 780566) (|IsAst| "ISAST.spad" 779778 779789 780052 780057) (|InternalRationalUnivariateRepresentationPackage| "IRURPK.spad" 778450 778514 779768 779773) (|IrrRepSymNatPackage| "IRSN.spad" 776437 776462 778440 778445) (|IntegrationResultRFToFunction| "IRRF2F.spad" 774887 774924 776377 776382) (|IrredPolyOverFiniteField| "IRREDFFX.spad" 774466 774499 774877 774882) (|IntegerRoots| "IROOT.spad" 772795 772815 774456 774461) (|InternalRepresentationForm| "IRFORM.spad" 772095 772127 772785 772790) (|IntegrationResultToFunction| "IR2F.spad" 771288 771325 772085 772090) (|IntegrationResultFunctions2| "IR2.spad" 770295 770332 771278 771283) (|IntegrationResult| "IR.spad" 768069 768094 770126 770170) (|InternalPrintPackage| "IPRNTPK.spad" 767811 767837 768059 768064) (|InnerPrimeField| "IPF.spad" 767252 767277 767505 767670) (|InnerPAdicInteger| "IPADIC.spad" 766963 767004 767135 767247) (|IP4Address| "IP4ADDR.spad" 766512 766528 766953 766958) (|IOMode| "IOMODE.spad" 766030 766042 766502 766507) (|InputOutputBinaryFile| "IOBFILE.spad" 765396 765423 766020 766025) (|InputOutputByteConduit| "IOBCON.spad" 765241 765269 765386 765391) (|InverseLaplaceTransform| "INVLAPLA.spad" 764873 764906 765231 765236) (|TranscendentalIntegration| "INTTR.spad" 758248 758284 764863 764868) (|IntegrationTools| "INTTOOLS.spad" 755987 756013 757816 757821) (|IntegerSolveLinearPolynomialEquation| "INTSLPE.spad" 755281 755323 755977 755982) (|Interval| "INTRVL.spad" 754790 754806 755144 755276) (|RationalFunctionIntegration| "INTRF.spad" 753201 753236 754780 754785) (|IntegerRetractions| "INTRET.spad" 752617 752643 753191 753196) (|RationalIntegration| "INTRAT.spad" 751339 751369 752607 752612) (|PatternMatchIntegration| "INTPM.spad" 749784 749817 751059 751064) (|PureAlgebraicIntegration| "INTPAF.spad" 747602 747638 749673 749678) (|TranscendentalHermiteIntegration| "INTHERTR.spad" 746850 746893 747592 747597) (|AlgebraicHermiteIntegration| "INTHERAL.spad" 746499 746544 746840 746845) (|IntegerNumberTheoryFunctions| "INTHEORY.spad" 742912 742946 746489 746494) (|GenusZeroIntegration| "INTG0.spad" 736622 736654 742801 742806) (|IntegerFactorizationPackage| "INTFACT.spad" 735664 735699 736612 736617) (|ElementaryIntegration| "INTEF.spad" 734060 734091 735654 735659) (|IntegralDomain| "INTDOM.spad" 732628 732648 733943 734055) (|IntegralDomain&| "INTDOM.spad" 731300 731323 732618 732623) (|IntervalCategory| "INTCAT.spad" 729502 729526 731163 731295) (|IntegerBits| "INTBIT.spad" 729000 729017 729492 729497) (|AlgebraicIntegrate| "INTALG.spad" 728176 728215 728990 728995) (|AlgebraicIntegration| "INTAF.spad" 727662 727692 728166 728171) (|InnerTable| "INTABL.spad" 726567 726606 726738 726743) (|Int8| "INT8.spad" 726445 726455 726557 726562) (|Int64| "INT64.spad" 726321 726332 726435 726440) (|Int32| "INT32.spad" 726197 726208 726311 726316) (|Int16| "INT16.spad" 726073 726084 726187 726192) (|Integer| "INT.spad" 725489 725502 725834 726068) (|IntegerNumberSystem| "INS.spad" 722896 722921 725312 725484) (|IntegerNumberSystem&| "INS.spad" 720467 720495 722886 722891) (|InnerPolySign| "INPSIGN.spad" 719926 719950 720457 720462) (|InfiniteProductPrimeField| "INPRODPF.spad" 718999 719041 719916 719921) (|InfiniteProductFiniteField| "INPRODFF.spad" 718063 718111 718989 718994) (|InnerMultFact| "INNMFACT.spad" 717027 717055 718053 718058) (|InnerModularGcd| "INMODGCD.spad" 716518 716561 717017 717022) (|InnerNumericFloatSolvePackage| "INFSP.spad" 714792 714837 716508 716513) (|InfiniteProductCharacteristicZero| "INFPROD0.spad" 713841 713891 714782 714787) (|InputFormFunctions1| "INFORM1.spad" 713449 713476 713831 713836) (|InputForm| "INFORM.spad" 710653 710668 713439 713444) (|Infinity| "INFINITY.spad" 710199 710213 710643 710648) (|InetClientStreamSocket| "INETCLTS.spad" 710156 710184 710189 710194) (|InnerNumericEigenPackage| "INEP.spad" 708684 708724 710146 710151) (|IndexedExponents| "INDE.spad" 708304 708335 708579 708584) (|IncrementingMaps| "INCRMAPS.spad" 707727 707751 708294 708299) (|InputBinaryFile| "INBFILE.spad" 706810 706831 707717 707722) (|InnerNormalBasisFieldFunctions| "INBFF.spad" 702632 702671 706800 706805) (|InputByteConduit| "INBCON.spad" 700884 700906 702622 702627) (|InputByteConduit&| "INBCON.spad" 699133 699158 700874 700879) (|InAst| "INAST.spad" 698791 698802 699123 699128) (|ImportAst| "IMPTAST.spad" 698492 698507 698781 698786) (|InnerMatrixQuotientFieldFunctions| "IMATQF.spad" 697505 697580 698398 698403) (|InnerMatrixLinearAlgebraFunctions| "IMATLIN.spad" 696045 696100 697411 697416) (|InnerFiniteField| "IFF.spad" 695405 695435 695690 695855) (|IfAst| "IFAST.spad" 695016 695027 695395 695400) (|IndexedFlexibleArray| "IFARRAY.spad" 692694 692727 694410 694415) (|InnerFreeAbelianMonoid| "IFAMON.spad" 692518 692555 692632 692637) (|InnerEvalable| "IEVALAB.spad" 691920 691943 692508 692513) (|InnerEvalable&| "IEVALAB.spad" 691319 691345 691910 691915) (|IndexedProductTerm| "indexedp.spad" 690859 690887 691309 691314) (|IndexedDirectProductOrderedAbelianMonoidSup| "IDPOAMS.spad" 690497 690550 690772 690777) (|IndexedDirectProductOrderedAbelianMonoid| "IDPOAM.spad" 690102 690152 690410 690415) (|IndexedDirectProductObject| "IDPO.spad" 689493 689529 690015 690020) (|IndexedDirectProductCategory| "IDPC.spad" 688365 688403 689483 689488) (|IndexedDirectProductAbelianMonoid| "IDPAM.spad" 688002 688045 688278 688283) (|IndexedDirectProductAbelianGroup| "IDPAG.spad" 687642 687684 687915 687920) (|Identifier| "IDENT.spad" 687286 687302 687632 687637) (|IdempotentOperatorCategory| "catdef.spad" 687037 687072 687173 687281) (|IdealDecompositionPackage| "IDECOMP.spad" 684253 684294 687027 687032) (|PolynomialIdeals| "IDEAL.spad" 679191 679240 684187 684192) (|InnerCommonDenominator| "ICDEN.spad" 678384 678420 679181 679186) (|IndexCard| "ICARD.spad" 677770 677785 678374 678379) (|IntegralBasisPolynomialTools| "IBPTOOLS.spad" 676351 676394 677760 677765) (|IndexedBits| "boolean.spad" 675699 675721 675841 675846) (|IntegralBasisTools| "IBATOOL.spad" 672672 672703 675689 675694) (|ChineseRemainderToolsForIntegralBases| "IBACHIN.spad" 671144 671194 672662 672667) (|InnerTwoDimensionalArray| "array2.spad" 670681 670725 670890 670895) (|IndexedOneDimensionalArray| "IARRAY1.spad" 669905 669944 670075 670080) (|InnerAlgebraicNumber| "IAN.spad" 668179 668205 669646 669811) (|InnerAlgFactor| "IALGFACT.spad" 667782 667823 668169 668174) (|HyperbolicFunctionCategory| "HYPCAT.spad" 667182 667214 667772 667777) (|HyperbolicFunctionCategory&| "HYPCAT.spad" 666579 666614 667172 667177) (|Hostname| "HOSTNAME.spad" 666389 666403 666569 666574) (|HomotopicTo| "HOMOTOP.spad" 666123 666142 666379 666384) (|HomogeneousAggregate| "HOAGG.spad" 665805 665833 666113 666118) (|HomogeneousAggregate&| "HOAGG.spad" 665269 665300 665580 665585) (|HexadecimalExpansion| "HEXADEC.spad" 663339 663365 663722 663887) (|HeuGcd| "HEUGCD.spad" 662426 662441 663329 663334) (|HyperellipticFiniteDivisor| "HELLFDIV.spad" 662012 662056 662416 662421) (|Heap| "HEAP.spad" 661541 661553 661758 661763) (|HeadAst| "HEADAST.spad" 661077 661090 661531 661536) (|HomogeneousDirectProduct| "HDP.spad" 657777 657815 658176 658307) (|HomogeneousDistributedMultivariatePolynomial| "HDMP.spad" 655579 655636 656237 656471) (|HallBasis| "HB.spad" 653847 653862 655569 655574) (|HashTable| "HASHTBL.spad" 652705 652743 652923 652928) (|HasAst| "HASAST.spad" 652417 652429 652695 652700) (|Pi| "HACKPI.spad" 651836 651844 652247 652412) (|GeneralTriangularSet| "GTSET.spad" 650643 650677 651368 651373) (|GeneralSparseTable| "GSTBL.spad" 649529 649580 649719 649724) (|GeneralUnivariatePowerSeries| "GSERIES.spad" 647257 647310 648102 648357) (|Group| "GROUP.spad" 646520 646531 647230 647252) (|Group&| "GROUP.spad" 645797 645811 646510 646515) (|GroebnerSolve| "GROEBSOL.spad" 644284 644312 645787 645792) (|GradedModule| "GRMOD.spad" 642855 642877 644274 644279) (|GradedModule&| "GRMOD.spad" 641423 641448 642845 642850) (|GraphImage| "GRIMAGE.spad" 634328 634344 641413 641418) (|GraphicsDefaults| "GRDEF.spad" 632693 632715 634318 634323) (|GrayCode| "GRAY.spad" 631158 631172 632683 632688) (|GradedAlgebra| "GRALG.spad" 630242 630265 631148 631153) (|GradedAlgebra&| "GRALG.spad" 629323 629349 630232 630237) (|GeneralPolynomialSet| "GPOLSET.spad" 628665 628706 628895 628900) (|GosperSummationMethod| "GOSPER.spad" 627923 627960 628655 628660) (|GeneralModulePolynomial| "GMODPOL.spad" 627033 627081 627874 627918) (|GeneralHenselPackage| "GHENSEL.spad" 626098 626130 627023 627028) (|GenerateUnivariatePowerSeries| "GENUPS.spad" 622364 622404 626088 626093) (|GenUFactorize| "GENUFACT.spad" 621930 621951 622354 622359) (|GeneralPolynomialGcdPackage| "GENPGCD.spad" 621507 621549 621920 621925) (|GeneralizedMultivariateFactorize| "GENMFACT.spad" 620929 620978 621497 621502) (|GenExEuclid| "GENEEZ.spad" 618879 618901 620919 620924) (|GeneralDistributedMultivariatePolynomial| "GDMP.spad" 616527 616582 617339 617573) (|GenericNonAssociativeAlgebra| "GCNAALG.spad" 610365 610418 616262 616379) (|GcdDomain| "GCDDOM.spad" 609507 609522 610248 610360) (|GcdDomain&| "GCDDOM.spad" 608753 608771 609497 609502) (|GroebnerInternalPackage| "GBINTERN.spad" 604752 604811 608743 608748) (|GroebnerFactorizationPackage| "GBF.spad" 600509 600573 604742 604747) (|EuclideanGroebnerBasisPackage| "GBEUCLID.spad" 598364 598429 600499 600504) (|GroebnerPackage| "GB.spad" 595874 595925 598317 598322) (|GaussianFactorizationPackage| "GAUSSFAC.spad" 595161 595195 595864 595869) (|GaloisGroupUtilities| "GALUTIL.spad" 593452 593480 595100 595105) (|GaloisGroupPolynomialUtilities| "GALPOLYU.spad" 591878 591919 593442 593447) (|GaloisGroupFactorizationUtilities| "GALFACTU.spad" 590064 590110 591868 591873) (|GaloisGroupFactorizer| "GALFACT.spad" 580258 580288 590054 590059) (|FunctionDescriptor| "FUNDESC.spad" 579920 579944 580248 580253) (|Functorial| "catdef.spad" 579523 579541 579910 579915) (|FunctionCalled| "FUNCTION.spad" 579360 579384 579513 579518) (|FortranType| "FT.spad" 577651 577668 579350 579355) (|FunctionSpaceUnivariatePolynomialFactor| "FSUPFACT.spad" 576507 576559 577576 577581) (|FortranScalarType| "FST.spad" 574578 574601 576497 576502) (|FunctionSpaceReduce| "FSRED.spad" 574045 574074 574568 574573) (|FunctionSpacePrimitiveElement| "FSPRMELT.spad" 572865 572904 573979 573984) (|FunctionalSpecialFunction| "FSPECF.spad" 570937 570972 572855 572860) (|FunctionSpaceIntegration| "FSINT.spad" 570579 570613 570927 570932) (|FourierSeries| "FSERIES.spad" 569721 569744 570361 570499) (|FunctionSpaceComplexIntegration| "FSCINT.spad" 569013 569054 569711 569716) (|FiniteSetAggregateFunctions2| "FSAGG2.spad" 567722 567764 569003 569008) (|FiniteSetAggregate| "FSAGG.spad" 566831 566857 567686 567717) (|FiniteSetAggregate&| "FSAGG.spad" 565881 565910 566739 566744) (|FunctionSpaceToUnivariatePowerSeries| "FS2UPS.spad" 560362 560430 565871 565876) (|FunctionSpaceToExponentialExpansion| "FS2EXPXP.spad" 559470 559526 560352 560357) (|FunctionSpaceFunctions2| "FS2.spad" 559104 559141 559460 559465) (|FunctionSpace| "FS.spad" 553253 553274 558771 559099) (|FunctionSpace&| "FS.spad" 547184 547208 552705 552710) (|FactoredFunctionUtilities| "FRUTIL.spad" 546115 546148 547174 547179) (|FramedNonAssociativeAlgebra| "FRNAALG.spad" 541331 541366 546021 546110) (|FramedNonAssociativeAlgebra&| "FRNAALG.spad" 536591 536629 541284 541289) (|FramedNonAssociativeAlgebraFunctions2| "FRNAAF2.spad" 536004 536057 536581 536586) (|FramedModule| "FRMOD.spad" 535395 535431 535922 535927) (|FractionalIdealFunctions2| "FRIDEAL2.spad" 534976 535031 535385 535390) (|FractionalIdeal| "FRIDEAL.spad" 534185 534215 534949 534971) (|FullyRetractableTo| "FRETRCT.spad" 533688 533714 534175 534180) (|FullyRetractableTo&| "FRETRCT.spad" 533064 533093 533554 533559) (|FramedAlgebra| "FRAMALG.spad" 531409 531433 532996 533059) (|FramedAlgebra&| "FRAMALG.spad" 529809 529836 531399 531404) (|FractionFunctions2| "FRAC2.spad" 529398 529426 529799 529804) (|Fraction| "FRAC.spad" 527110 527126 527503 527797) (|FactoredFunctions2| "FR2.spad" 526430 526458 527100 527105) (|Factored| "FR.spad" 520369 520385 525332 525444) (|FloatingPointSystem| "FPS.spad" 517111 517136 520179 520364) (|FloatingPointSystem&| "FPS.spad" 513931 513959 517002 517007) (|FieldOfPrimeCharacteristic| "FPC.spad" 512881 512913 513761 513926) (|FieldOfPrimeCharacteristic&| "FPC.spad" 511988 512023 512871 512876) (|FullyPatternMatchable| "FPATMAB.spad" 511731 511760 511978 511983) (|FullPartialFractionExpansion| "FPARFRAC.spad" 510551 510590 511721 511726) (|FindOrderFinite| "FORDER.spad" 510233 510266 510541 510546) (|FreeNilpotentLie| "FNLA.spad" 509626 509662 510184 510228) (|FileNameCategory| "FNCAT.spad" 508207 508229 509616 509621) (|FileName| "FNAME.spad" 508093 508107 508197 508202) (|FreeMonoid| "FMONOID.spad" 507758 507776 508041 508046) (|FreeMonoidCategory| "FMONCAT.spad" 504911 504937 507748 507753) (|FreeModuleCat| "FMCAT.spad" 502719 502748 504862 504906) (|FreeModule1| "FM1.spad" 502045 502066 502623 502667) (|FreeModule| "FM.spad" 501623 501643 501870 501914) (|FloatingRealPackage| "FLOATRP.spad" 499349 499380 501613 501618) (|FloatingComplexPackage| "FLOATCP.spad" 496768 496802 499339 499344) (|Float| "FLOAT.spad" 493747 493758 496525 496763) (|FullyLinearlyExplicitRingOver| "FLINEXP.spad" 493442 493479 493737 493742) (|FullyLinearlyExplicitRingOver&| "FLINEXP.spad" 493066 493106 493364 493369) (|FiniteLinearAggregateSort| "FLASORT.spad" 492369 492404 493056 493061) (|FreeLieAlgebra| "FLALG.spad" 490010 490041 492278 492364) (|FiniteLinearAggregateFunctions2| "FLAGG2.spad" 488698 488743 490000 490005) (|FiniteLinearAggregate| "FLAGG.spad" 485755 485784 488688 488693) (|FiniteLinearAggregate&| "FLAGG.spad" 482638 482670 485574 485579) (|FiniteRankAlgebra| "FINRALG.spad" 480684 480712 482570 482633) (|FiniteRankAlgebra&| "FINRALG.spad" 478641 478672 480530 480535) (|Finite| "FINITE.spad" 477789 477801 478631 478636) (|Finite&| "FINITE.spad" 476934 476949 477779 477784) (|FiniteAggregate| "aggcat.spad" 473646 473669 476924 476929) (|FiniteAggregate&| "FINAGG.spad" 470314 470340 473595 473600) (|FiniteRankNonAssociativeAlgebra| "FINAALG.spad" 459434 459473 470220 470309) (|FiniteRankNonAssociativeAlgebra&| "FINAALG.spad" 448589 448631 459378 459383) (|FileCategory| "FILECAT.spad" 447113 447140 448579 448584) (|File| "FILE.spad" 446694 446706 447103 447108) (|Field| "FIELD.spad" 446025 446036 446524 446689) (|Field&| "FIELD.spad" 445513 445527 446015 446020) (|FreeGroup| "FGROUP.spad" 444162 444179 445486 445508) (|FGLMIfCanPackage| "FGLMICPK.spad" 442943 442972 444152 444157) (|FiniteFieldExtension| "FFX.spad" 442258 442291 442609 442774) (|FiniteFieldSolveLinearPolynomialEquation| "FFSLPE.spad" 441735 441790 442248 442253) (|FiniteFieldPolynomialPackage2| "FFPOLY2.spad" 440772 440812 441725 441730) (|FiniteFieldPolynomialPackage| "FFPOLY.spad" 432088 432125 440762 440767) (|FiniteFieldExtensionByPolynomial| "FFP.spad" 431413 431463 431754 431919) (|FiniteFieldNormalBasisExtension| "FFNBX.spad" 429854 429903 431079 431244) (|FiniteFieldNormalBasisExtensionByPolynomial| "FFNBP.spad" 428284 428342 429520 429685) (|FiniteFieldNormalBasis| "FFNB.spad" 426698 426739 427934 428099) (|FunctionFieldIntegralBasis| "FFINTBAS.spad" 424192 424231 426688 426693) (|FiniteFieldCategory| "FFIELDC.spad" 421688 421713 424022 424187) (|FiniteFieldCategory&| "FFIELDC.spad" 419341 419369 421678 421683) (|FiniteFieldHomomorphisms| "FFHOM.spad" 418091 418130 419331 419336) (|FiniteFieldFunctions| "FFF.spad" 415516 415545 418081 418086) (|FiniteFieldCyclicGroupExtension| "FFCGX.spad" 414292 414341 415182 415347) (|FiniteFieldCyclicGroupExtensionByPolynomial| "FFCGP.spad" 413098 413159 413958 414123) (|FiniteFieldCyclicGroup| "FFCG.spad" 411839 411880 412748 412913) (|FunctionFieldCategoryFunctions2| "FFCAT2.spad" 411557 411626 411829 411834) (|FunctionFieldCategory| "FFCAT.spad" 404609 404646 411298 411552) (|FunctionFieldCategory&| "FFCAT.spad" 397830 397870 404522 404527) (|FiniteField| "FF.spad" 397238 397263 397480 397645) (|FullyEvalableOver| "FEVALAB.spad" 397060 397085 397228 397233) (|FullyEvalableOver&| "FEVALAB.spad" 396674 396702 396845 396850) (|FiniteDivisorCategory| "FDIVCAT.spad" 394755 394794 396664 396669) (|FiniteDivisorCategory&| "FDIVCAT.spad" 392833 392875 394745 394750) (|FiniteDivisorFunctions2| "FDIV2.spad" 392468 392529 392823 392828) (|FiniteDivisor| "FDIV.spad" 391919 391950 392458 392463) (|FunctorData| "FCTRDATA.spad" 390918 390935 391909 391914) (|FourierComponent| "FCOMP.spad" 390283 390307 390908 390913) (|FiniteAlgebraicExtensionField| "FAXF.spad" 383223 383260 390113 390278) (|FiniteAlgebraicExtensionField&| "FAXF.spad" 376282 376322 383175 383180) (|FlexibleArray| "FARRAY.spad" 374632 374653 375676 375681) (|FiniteAbelianMonoidRing| "FAMR.spad" 372687 372720 374462 374627) (|FiniteAbelianMonoidRing&| "FAMR.spad" 370761 370797 372539 372544) (|FreeAbelianMonoid| "FAMONOID.spad" 370396 370421 370681 370686) (|FreeAbelianMonoidCategory| "FAMONC.spad" 368693 368728 370386 370391) (|FreeAbelianGroup| "FAGROUP.spad" 368271 368295 368541 368585) (|FactoringUtilities| "FACUTIL.spad" 366467 366500 368261 368266) (|FactoredFunctions| "FACTFUNC.spad" 365654 365679 366457 366462) (|ExponentialOfUnivariatePuiseuxSeries| "EXPUPXS.spad" 362894 362951 364227 364482) (|ExpressionTubePlot| "EXPRTUBE.spad" 360166 360190 362884 362889) (|ExpressionSpaceODESolver| "EXPRODE.spad" 357316 357350 360156 360161) (|ExpressionToUnivariatePowerSeries| "EXPR2UPS.spad" 353407 353451 357306 357311) (|ExpressionFunctions2| "EXPR2.spad" 353094 353124 353397 353402) (|Expression| "EXPR.spad" 350554 350572 351276 351649) (|ExponentialExpansion| "EXPEXPAN.spad" 348101 348144 348751 348916) (|ExitAst| "EXITAST.spad" 347832 347845 348091 348096) (|Exit| "EXIT.spad" 347501 347511 347822 347827) (|EvaluateCycleIndicators| "EVALCYC.spad" 346944 346975 347491 347496) (|Evalable| "EVALAB.spad" 346518 346534 346934 346939) (|Evalable&| "EVALAB.spad" 346089 346108 346508 346513) (|EuclideanDomain| "EUCDOM.spad" 343623 343644 345972 346084) (|EuclideanDomain&| "EUCDOM.spad" 341261 341285 343613 343618) (|ExpressionSpaceFunctions2| "ES2.spad" 340755 340790 341251 341256) (|ExpressionSpaceFunctions1| "ES1.spad" 340306 340341 340745 340750) (|ExpressionSpace| "ES.spad" 333164 333185 340296 340301) (|ExpressionSpace&| "ES.spad" 325924 325948 333059 333064) (|ErrorFunctions| "ERROR.spad" 323239 323259 325914 325919) (|EqTable| "EQTBL.spad" 322101 322128 322315 322320) (|EquationFunctions2| "EQ2.spad" 321803 321831 322091 322096) (|Equation| "EQ.spad" 318021 318037 320685 320826) (|EigenPackage| "EP.spad" 314337 314357 318011 318016) (|Environment| "ENV.spad" 313006 313023 314327 314332) (|EntireRing| "ENTIRER.spad" 312631 312647 312915 313001) (|EntireRing&| "ENTIRER.spad" 312334 312353 312621 312626) (|EuclideanModularRing| "EMR.spad" 311553 311620 312217 312329) (|EltableAggregate| "ELTAGG.spad" 309793 309826 311543 311548) (|EltableAggregate&| "ELTAGG.spad" 307946 307982 309699 309704) (|Eltable| "ELTAB.spad" 307416 307434 307936 307941) (|EllipticFunctionsUnivariateTaylorSeries| "ELFUTS.spad" 306814 306870 307406 307411) (|ElementaryFunctionCategory| "ELEMFUN.spad" 306479 306511 306804 306809) (|ElementaryFunctionCategory&| "ELEMFUN.spad" 306141 306176 306469 306474) (|ExtensibleLinearAggregate| "ELAGG.spad" 304099 304132 306131 306136) (|ExtensibleLinearAggregate&| "ELAGG.spad" 301969 302005 304004 304009) (|Elaboration| "ELABOR.spad" 301306 301323 301959 301964) (|ElaboratedExpression| "ELABEXPR.spad" 300220 300246 301296 301301) (|ElementaryFunctionsUnivariatePuiseuxSeries| "EFUPXS.spad" 296953 297023 300173 300178) (|ElementaryFunctionsUnivariateLaurentSeries| "EFULS.spad" 293746 293809 296906 296911) (|ElementaryFunctionStructurePackage| "EFSTRUC.spad" 291733 291777 293736 293741) (|ElementaryFunction| "EF.spad" 286497 286525 291723 291728) (|ExtAlgBasis| "EAB.spad" 284788 284805 286487 286492) (|DifferentialVariableCategory| "DVARCAT.spad" 281768 281804 284778 284783) (|DifferentialVariableCategory&| "DVARCAT.spad" 278745 278784 281758 281763) (|DifferentialSparseMultivariatePolynomial| "DSMP.spad" 276651 276703 276994 277228) (|DifferentialSpaceExtension| "DSEXT.spad" 275929 275963 276641 276646) (|DifferentialSpaceExtension&| "DSEXT.spad" 275086 275123 275801 275806) (|DrawOptionFunctions1| "DROPT1.spad" 274733 274761 275076 275081) (|DrawOptionFunctions0| "DROPT0.spad" 269580 269606 274723 274728) (|DrawOption| "DROPT.spad" 263531 263547 269570 269575) (|TopLevelDrawFunctionsForPoints| "DRAWPT.spad" 261676 261712 263521 263526) (|DrawNumericHack| "DRAWHACK.spad" 260971 260994 261666 261671) (|DrawComplex| "DRAWCX.spad" 258440 258457 260961 260966) (|TopLevelDrawFunctionsForAlgebraicCurves| "DRAWCURV.spad" 257950 258002 258430 258435) (|TopLevelDrawFunctionsForCompiledFunctions| "DRAWCFUN.spad" 247443 247490 257940 257945) (|TopLevelDrawFunctions| "DRAW.spad" 240300 240332 247433 247438) (|DequeueAggregate| "DQAGG.spad" 238486 238510 240290 240295) (|DifferentialPolynomialCategory| "DPOLCAT.spad" 233708 233752 238247 238481) (|DifferentialPolynomialCategory&| "DPOLCAT.spad" 229108 229155 233650 233655) (|DirectProductModule| "DPMO.spad" 226345 226378 226500 226765) (|DirectProductMatrixModule| "DPMM.spad" 223589 223630 223737 224002) (|DomainTemplate| "DOMTMPLT.spad" 223348 223368 223579 223584) (|DomainConstructor| "DOMCTOR.spad" 223088 223111 223338 223343) (|Domain| "DOMAIN.spad" 222195 222207 223078 223083) (|DistributedMultivariatePolynomial| "DMP.spad" 220054 220100 220655 220889) (|DifferentialModuleExtension| "DMEXT.spad" 219879 219914 220005 220049) (|DiscreteLogarithmPackage| "DLP.spad" 219217 219249 219869 219874) (|DataList| "DLIST.spad" 218001 218017 218611 218616) (|DoublyLinkedAggregate| "DLAGG.spad" 216399 216428 217991 217996) (|DivisionRing| "DIVRING.spad" 215896 215914 216308 216394) (|DivisionRing&| "DIVRING.spad" 215471 215492 215886 215891) (|DisplayPackage| "DISPLAY.spad" 213649 213669 215461 215466) (|DirectProductFunctions2| "DIRPROD2.spad" 212446 212485 213639 213644) (|DirectProduct| "DIRPROD.spad" 208894 208921 209545 209676) (|DirectProductCategory| "DIRPCAT.spad" 208124 208159 208758 208889) (|DirectProductCategory&| "DIRPCAT.spad" 206882 206920 207519 207524) (|DiophantineSolutionPackage| "DIOSP.spad" 205683 205715 206872 206877) (|DictionaryOperations| "DIOPS.spad" 204671 204699 205673 205678) (|DictionaryOperations&| "DIOPS.spad" 203582 203613 204587 204592) (|Dioid| "catdef.spad" 203437 203448 203572 203577) (|DifferentialRing| "DIFRING.spad" 203254 203276 203410 203432) (|DifferentialSpace| "DIFFSPC.spad" 202818 202841 203244 203249) (|DifferentialSpace&| "DIFFSPC.spad" 202379 202405 202808 202813) (|DifferentialModule| "DIFFMOD.spad" 201835 201861 202330 202374) (|DifferentialDomain| "DIFFDOM.spad" 200984 201011 201825 201830) (|DifferentialDomain&| "DIFFDOM.spad" 200130 200160 200974 200979) (|DifferentialExtension| "DIFEXT.spad" 199923 199952 200103 200125) (|Dictionary| "DIAGG.spad" 199555 199573 199913 199918) (|Dictionary&| "DIAGG.spad" 199184 199205 199545 199550) (|DenavitHartenbergMatrix| "DHMATRIX.spad" 197578 197609 198744 198749) (|DoubleFloatSpecialFunctions| "DFSFUN.spad" 191193 191226 197568 197573) (|DoubleFloat| "DFLOAT.spad" 187711 187728 191003 191188) (|DefiniteIntegrationTools| "DFINTTLS.spad" 185924 185958 187701 187706) (|DeRhamComplex| "DERHAM.spad" 183993 184036 185897 185919) (|Dequeue| "DEQUEUE.spad" 183451 183466 183739 183744) (|DegreeReductionPackage| "DEGRED.spad" 183048 183082 183441 183446) (|RationalFunctionDefiniteIntegration| "DEFINTRF.spad" 180597 180640 183038 183043) (|ElementaryFunctionDefiniteIntegration| "DEFINTEF.spad" 179104 179151 180587 180592) (|DefinitionAst| "DEFAST.spad" 178477 178496 179094 179099) (|DecimalExpansion| "DECIMAL.spad" 176555 176577 176930 177095) (|DistinctDegreeFactorize| "DDFACT.spad" 174359 174393 176545 176550) (|DoubleResultantPackage| "DBLRESP.spad" 173943 173983 174349 174354) (|DualBasis| "DBASIS.spad" 173562 173584 173933 173938) (|Database| "DBASE.spad" 172220 172236 173552 173557) (|DataArray| "DATAARY.spad" 171699 171719 172210 172215) (|CyclotomicPolynomialPackage| "CYCLOTOM.spad" 171180 171213 171689 171694) (|CycleIndicators| "CYCLES.spad" 167950 167971 171170 171175) (|CoerceVectorMatrixPackage| "CVMP.spad" 167344 167377 167940 167945) (|ComplexTrigonometricManipulations| "CTRIGMNP.spad" 165817 165860 167334 167339) (|ConstructorKind| "CTORKIND.spad" 165407 165428 165807 165812) (|ConstructorCategory| "CTORCAT.spad" 164631 164656 165397 165402) (|ConstructorCategory&| "CTORCAT.spad" 163852 163880 164621 164626) (|ConstructorCall| "CTORCALL.spad" 163428 163451 163842 163847) (|Constructor| "CTOR.spad" 163110 163127 163418 163423) (|CyclicStreamTools| "CSTTOOLS.spad" 162340 162368 163100 163105) (|ComplexRootFindingPackage| "CRFP.spad" 156089 156125 162330 162335) (|CoerceAst| "CRCEAST.spad" 155802 155817 156079 156084) (|CRApackage| "CRAPACK.spad" 154861 154879 155792 155797) (|ComplexPatternMatch| "CPMATCH.spad" 154323 154355 154761 154766) (|CharacteristicPolynomialInMonogenicalAlgebra| "CPIMA.spad" 153986 154047 154313 154318) (|CoordinateSystems| "COORDSYS.spad" 148980 149005 153976 153981) (|Contour| "CONTOUR.spad" 148402 148415 148970 148975) (|ContinuedFraction| "CONTFRAC.spad" 144065 144090 148232 148397) (|Conduit| "CONDUIT.spad" 143818 143831 144055 144060) (|CommutativeRing| "COMRING.spad" 143447 143468 143724 143813) (|SubSpaceComponentProperty| "COMPPROP.spad" 142942 142973 143437 143442) (|ComplexPattern| "COMPLPAT.spad" 142697 142724 142932 142937) (|ComplexFunctions2| "COMPLEX2.spad" 142397 142424 142687 142692) (|Complex| "COMPLEX.spad" 139504 139519 139753 140232) (|CompilerPackage| "COMPILER.spad" 139040 139061 139494 139499) (|ComplexFactorization| "COMPFACT.spad" 138624 138656 139030 139035) (|ComplexCategory| "COMPCAT.spad" 136465 136488 138140 138619) (|ComplexCategory&| "COMPCAT.spad" 134042 134068 135720 135725) (|CommutativeOperatorCategory| "catdef.spad" 133764 133800 133902 134037) (|CommutativeOperation| "/home/gdr/build/1.5.x/x86_64-unknown-linux-gnu/src/algebra/catdef.spad" 133336 133365 133624 133759) (|CommuteUnivariatePolynomialCategory| "COMMUPC.spad" 133051 133102 133326 133331) (|CommonOperators| "COMMONOP.spad" 132571 132592 133041 133046) (|CommaAst| "COMMAAST.spad" 132328 132342 132561 132566) (|Commutator| "COMM.spad" 132131 132147 132318 132323) (|CombinatorialOpsCategory| "COMBOPC.spad" 131032 131062 132121 132126) (|IntegerCombinatoricFunctions| "COMBINAT.spad" 129773 129809 131022 131027) (|CombinatorialFunction| "COMBF.spad" 127180 127211 129763 129768) (|Color| "COLOR.spad" 126014 126025 127170 127175) (|ColonAst| "COLONAST.spad" 125674 125688 126004 126009) (|ComplexRootPackage| "CMPLXRT.spad" 125369 125402 125664 125669) (|CollectAst| "CLLCTAST.spad" 125023 125039 125359 125364) (|TwoDimensionalPlotClipping| "CLIP.spad" 121107 121139 125013 125018) (|CliffordAlgebra| "CLIF.spad" 119725 119754 121039 121102) (|Collection| "CLAGG.spad" 117923 117941 119715 119720) (|Collection&| "CLAGG.spad" 115940 115961 117735 117740) (|ComplexIntegerSolveLinearPolynomialEquation| "CINTSLPE.spad" 115254 115308 115930 115935) (|ChangeOfVariable| "CHVAR.spad" 113382 113414 115244 115249) (|CharacteristicZero| "CHARZ.spad" 113274 113298 113355 113377) (|CharacteristicPolynomialPackage| "CHARPOL.spad" 112771 112810 113264 113269) (|CharacteristicNonZero| "CHARNZ.spad" 112507 112534 112744 112766) (|Character| "CHAR.spad" 109868 109883 112497 112502) (|CombinatorialFunctionCategory| "CFCAT.spad" 109169 109204 109858 109863) (|CommonDenominator| "CDEN.spad" 108374 108403 109159 109164) (|CharacterClass| "CCLASS.spad" 106606 106626 107880 107911) (|Category| "CATEGORY.spad" 105674 105688 106596 106601) (|CategoryConstructor| "CATCTOR.spad" 105548 105573 105664 105669) (|CategoryAst| "CATAST.spad" 105165 105182 105538 105543) (|CaseAst| "CASEAST.spad" 104874 104887 105155 105160) (|CartesianTensorFunctions2| "CARTEN2.spad" 104241 104291 104864 104869) (|CartesianTensor| "CARTEN.spad" 99980 100017 104231 104236) (|CardinalNumber| "CARD.spad" 97255 97275 99946 99975) (|CapsuleAst| "CAPSLAST.spad" 97029 97045 97245 97250) (|CachableSet| "CACHSET.spad" 96644 96661 97019 97024) (|CancellationAbelianMonoid| "CABMON.spad" 96176 96207 96634 96639) (|ByteOrder| "BYTEORD.spad" 95844 95859 96166 96171) (|ByteBuffer| "BYTEBUF.spad" 94064 94080 95278 95283) (|Byte| "BYTE.spad" 93537 93547 94054 94059) (|BinaryTree| "BTREE.spad" 92670 92688 93212 93217) (|BinaryTournament| "BTOURN.spad" 91729 91753 92345 92350) (|BinaryTreeCategory| "BTCAT.spad" 91292 91318 91719 91724) (|BinaryTreeCategory&| "BTCAT.spad" 90852 90881 91282 91287) (|BitAggregate| "BTAGG.spad" 90330 90348 90842 90847) (|BitAggregate&| "BTAGG.spad" 89805 89826 90320 90325) (|BinarySearchTree| "BSTREE.spad" 88600 88624 89480 89485) (|BrillhartTests| "BRILL.spad" 86793 86816 88590 88595) (|BinaryRecursiveAggregate| "BRAGG.spad" 85727 85759 86783 86788) (|BinaryRecursiveAggregate&| "BRAGG.spad" 84574 84609 85633 85638) (|BalancedPAdicRational| "BPADICRT.spad" 82635 82666 82901 83066) (|BalancedPAdicInteger| "BPADIC.spad" 82246 82276 82518 82630) (|BoundIntegerRoots| "BOUNDZRO.spad" 81891 81919 82236 82241) (|BasicOperatorFunctions1| "BOP1.spad" 79328 79359 81881 81886) (|BasicOperator| "BOP.spad" 74459 74478 79318 79323) (|Boolean| "BOOLEAN.spad" 74002 74015 74449 74454) (|BooleanLogic| "BOOLE.spad" 73642 73660 73992 73997) (|BooleanLogic&| "BOOLE.spad" 73279 73300 73632 73637) (|BiModule| "BMODULE.spad" 72968 72986 73230 73274) (|Bits| "BITS.spad" 72241 72251 72458 72463) (|BinaryOperatorCategory| "catdef.spad" 72103 72134 72231 72236) (|BinaryOperation| "catdef.spad" 71840 71864 72093 72098) (|Binding| "BINDING.spad" 71256 71269 71830 71835) (|BinaryExpansion| "BINARY.spad" 69340 69361 69709 69874) (|BagAggregate| "BGAGG.spad" 68659 68679 69330 69335) (|BagAggregate&| "BGAGG.spad" 67975 67998 68649 68654) (|BezoutMatrix| "BEZOUT.spad" 67097 67134 67917 67922) (|BalancedBinaryTree| "BBTREE.spad" 64026 64052 66772 66777) (|BasicType| "BASTYPE.spad" 63518 63533 64016 64021) (|BasicType&| "BASTYPE.spad" 63007 63025 63508 63513) (|BalancedFactorisation| "BALFACT.spad" 62447 62479 62997 63002) (|Automorphism| "AUTOMOR.spad" 61880 61900 62420 62442) (|AttributeRegistry| "ATTREG.spad" 58842 58865 61502 61875) (|AttributeAst| "ATTRAST.spad" 58548 58566 58832 58837) (|ArcTrigonometricFunctionCategory| "ATRIG.spad" 57987 58025 58538 58543) (|ArcTrigonometricFunctionCategory&| "ATRIG.spad" 57423 57464 57977 57982) (|AbstractSyntaxCategory| "ASTCAT.spad" 57306 57334 57413 57418) (|AbstractSyntaxCategory&| "ASTCAT.spad" 57186 57217 57296 57301) (|ArrayStack| "ASTACK.spad" 56655 56673 56932 56937) (|AssociatedEquations| "ASSOCEQ.spad" 55468 55497 56608 56613) (|TwoDimensionalArray| "ARRAY2.spad" 55047 55074 55214 55219) (|OneDimensionalArrayFunctions2| "ARRAY12.spad" 53732 53771 55037 55042) (|OneDimensionalArray| "ARRAY1.spad" 52762 52789 53126 53131) (|TwoDimensionalArrayCategory| "ARR2CAT.spad" 49045 49092 52752 52757) (|TwoDimensionalArrayCategory&| "ARR2CAT.spad" 45325 45375 49035 49040) (|Arity| "ARITY.spad" 44693 44704 45315 45320) (|ApplyRules| "APPRULE.spad" 43972 43999 44683 44688) (|ApplyUnivariateSkewPolynomial| "APPLYORE.spad" 43563 43604 43962 43967) (|AnyFunctions1| "ANY1.spad" 42622 42643 43553 43558) (|Any| "ANY.spad" 41471 41480 42612 42617) (|AntiSymm| "ANTISYM.spad" 40030 40053 41444 41466) (|AnonymousFunction| "ANON.spad" 39723 39746 40020 40025) (|AlgebraicNumber| "AN.spad" 38087 38108 39464 39629) (|AbelianMonoidRing| "AMR.spad" 36333 36360 37917 38082) (|AbelianMonoidRing&| "AMR.spad" 34429 34459 36016 36021) (|AssociationList| "ALIST.spad" 32953 32988 33317 33322) (|AlgebraGivenByStructuralConstants| "ALGSC.spad" 32005 32063 32774 32863) (|AlgebraPackage| "ALGPKG.spad" 27762 27786 31948 31953) (|AlgebraicMultFact| "ALGMFACT.spad" 26939 26969 27752 27757) (|AlgebraicManipulations| "ALGMANIP.spad" 24389 24421 26749 26754) (|AlgebraicFunctionField| "ALGFF.spad" 23032 23080 23270 23499) (|AlgFactor| "ALGFACT.spad" 22143 22161 23022 23027) (|Algebra| "ALGEBRA.spad" 21946 21961 22075 22138) (|Algebra&| "ALGEBRA.spad" 21804 21822 21936 21941) (|AssociationListAggregate| "ALAGG.spad" 21319 21363 21794 21799) (|ArcHyperbolicFunctionCategory| "AHYP.spad" 20672 20707 21309 21314) (|Aggregate| "AGG.spad" 19571 19586 20662 20667) (|Aggregate&| "AGG.spad" 18467 18485 19561 19566) (|AlgebraicFunction| "AF.spad" 16884 16911 18400 18405) (|AddAst| "ADDAST.spad" 16565 16577 16874 16879) (|PlaneAlgebraicCurvePlot| "ACPLOT.spad" 15420 15449 16555 16560) (|AlgebraicallyClosedFunctionSpace| "ACFS.spad" 13174 13214 15250 15415) (|AlgebraicallyClosedFunctionSpace&| "ACFS.spad" 11085 11128 13164 13169) (|AlgebraicallyClosedField| "ACF.spad" 7744 7774 10915 11080) (|AlgebraicallyClosedField&| "ACF.spad" 4560 4593 7734 7739) (|AbelianSemiGroup| "ABELSG.spad" 4086 4108 4550 4555) (|AbelianSemiGroup&| "ABELSG.spad" 3609 3634 4076 4081) (|AbelianMonoid| "ABELMON.spad" 3025 3044 3599 3604) (|AbelianMonoid&| "ABELMON.spad" 2438 2460 3015 3020) (|AbelianGroup| "ABELGRP.spad" 2092 2110 2428 2433) (|AbelianGroup&| "ABELGRP.spad" 1743 1764 2082 2087) (|OneDimensionalArrayAggregate| "A1AGG.spad" 888 924 1733 1738) (|OneDimensionalArrayAggregate&| "A1AGG.spad" 30 69 878 883)) 
-\ No newline at end of file
+((|Union| NIL 1891971 1891976 1891981 1891986) (|Record| NIL 1891951 1891956 1891961 1891966) (|Mapping| NIL 1891931 1891936 1891941 1891946) (|Enumeration| NIL 1891911 1891916 1891921 1891926) (|IntegerMod| "fmod.spad" 1891741 1891761 1891877 1891906) (|IntegerLinearDependence| "lindep.spad" 1890819 1890850 1891731 1891736) (|ZeroDimensionalSolvePackage| "zerodim.spad" 1880756 1880802 1890809 1890814) (|ParadoxicalCombinatorsForStreams| "ystream.spad" 1880222 1880262 1880746 1880751) (|YoungDiagram| "/Users/gdr/build/oa/src/algebra/YDIAGRAM.spad" 1879847 1879865 1880212 1880217) (|XRecursivePolynomial| "xpoly.spad" 1879033 1879070 1879686 1879748) (|XPolynomialRing| "xpoly.spad" 1876910 1876935 1878712 1878843) (|XPolynomialsCat| "xpoly.spad" 1876224 1876252 1876843 1876905) (|XPolynomial| "xpoly.spad" 1875754 1875773 1876063 1876125) (|XPBWPolynomial| "xlpoly.spad" 1874434 1874465 1875528 1875590) (|XFreeAlgebra| "xpoly.spad" 1871613 1871638 1874367 1874429) (|ExtensionField| "ffcat.spad" 1870082 1870104 1871528 1871608) (|ExtensionField&| "ffcat.spad" 1868478 1868503 1869927 1869932) (|XExponentialPackage| "xlpoly.spad" 1867721 1867763 1868468 1868473) (|XDistributedPolynomial| "xpoly.spad" 1867299 1867334 1867560 1867622) (|XAlgebra| "xpoly.spad" 1866996 1867012 1867289 1867294) (|WuWenTsunTriangularSet| "triset.spad" 1862878 1862914 1866528 1866533) (|WeightedPolynomials| "wtpol.spad" 1862115 1862175 1862782 1862787) (|WhileAst| "syntax.spad" 1861908 1861922 1862105 1862110) (|WhereAst| "syntax.spad" 1861574 1861588 1861898 1861903) (|WildFunctionFieldIntegralBasis| "intclos.spad" 1859214 1859259 1861564 1861569) (|WeierstrassPreparation| "weier.spad" 1857417 1857447 1859204 1859209) (|VectorSpace| "catdef.spad" 1857104 1857123 1857407 1857412) (|VectorSpace&| "catdef.spad" 1856788 1856810 1857094 1857099) (|Void| "void.spad" 1856464 1856474 1856778 1856783) (|ViewDefaultsPackage| "viewDef.spad" 1851649 1851674 1856454 1856459) (|ThreeDimensionalViewport| "view3D.spad" 1835589 1835619 1851639 1851644) (|TwoDimensionalViewport| "view2D.spad" 1823682 1823710 1835579 1835584) (|ViewportPackage| "viewpack.spad" 1821390 1821411 1823672 1823677) (|VectorFunctions2| "vector.spad" 1820016 1820042 1821380 1821385) (|Vector| "vector.spad" 1818871 1818885 1819125 1819130) (|VectorCategory| "vector.spad" 1816794 1816816 1818861 1818866) (|VectorCategory&| "vector.spad" 1814446 1814471 1816516 1816521) (|Variable| "variable.spad" 1814288 1814308 1814436 1814441) (|UnionType| "coerce.spad" 1813926 1813941 1814278 1814283) (|UTSodetools| "oderf.spad" 1813205 1813233 1813870 1813875) (|UnivariateTaylorSeriesODESolver| "utsode.spad" 1811393 1811441 1813195 1813200) (|UnivariateTaylorSeriesCategory| "pscat.spad" 1808837 1808880 1811283 1811388) (|UnivariateTaylorSeriesCategory&| "pscat.spad" 1805874 1805920 1808323 1808328) (|UnivariateTaylorSeriesFunctions2| "taylor.spad" 1805440 1805504 1805864 1805869) (|UnivariateTaylorSeries| "taylor.spad" 1800670 1800717 1804209 1804314) (|UnaryRecursiveAggregate| "aggcat.spad" 1795371 1795402 1800660 1800665) (|UnaryRecursiveAggregate&| "aggcat.spad" 1789985 1790019 1795277 1795282) (|UnivariatePuiseuxSeriesWithExponentialSingularity| "expexpan.spad" 1787843 1787915 1789325 1789470) (|UnivariatePuiseuxSeriesConstructor| "puiseux.spad" 1786117 1786168 1786521 1786671) (|UnivariatePuiseuxSeriesConstructorCategory| "puiseux.spad" 1784648 1784707 1785962 1786112) (|UnivariatePuiseuxSeriesConstructorCategory&| "puiseux.spad" 1783321 1783383 1784638 1784643) (|UnivariatePuiseuxSeriesCategory| "pscat.spad" 1781881 1781925 1783166 1783316) (|UnivariatePuiseuxSeriesFunctions2| "puiseux.spad" 1781394 1781477 1781871 1781876) (|UnivariatePuiseuxSeries| "puiseux.spad" 1779216 1779264 1780072 1780222) (|UnivariatePolynomialSquareFree| "poly.spad" 1777604 1777645 1779206 1779211) (|UnivariatePowerSeriesCategory| "pscat.spad" 1775365 1775415 1777494 1777599) (|UnivariatePowerSeriesCategory&| "pscat.spad" 1772871 1772924 1775003 1775008) (|UnivariatePolynomialCategoryFunctions2| "polycat.spad" 1772307 1772361 1772861 1772866) (|UnivariatePolynomialCategory| "polycat.spad" 1767298 1767334 1772085 1772302) (|UnivariatePolynomialCategory&| "polycat.spad" 1762210 1762249 1767000 1767005) (|UnivariatePolynomialMultiplicationPackage| "poly.spad" 1761104 1761155 1762200 1762205) (|UnivariatePolynomialDivisionPackage| "updivp.spad" 1760637 1760683 1761094 1761099) (|UnivariatePolynomialDecompositionPackage| "updecomp.spad" 1758861 1758912 1760627 1760632) (|UnivariatePolynomialCommonDenominator| "cden.spad" 1758044 1758094 1758851 1758856) (|UnivariatePolynomialFunctions2| "poly.spad" 1757381 1757429 1758034 1758039) (|UnivariatePolynomial| "poly.spad" 1755155 1755187 1755559 1755776) (|UniversalSegmentFunctions2| "seg.spad" 1754620 1754656 1755102 1755107) (|UniversalSegment| "seg.spad" 1753943 1753967 1754522 1754527) (|UnivariateFactorize| "unifact.spad" 1753030 1753058 1753933 1753938) (|UnivariateLaurentSeriesConstructor| "laurent.spad" 1749547 1749598 1749948 1750098) (|UnivariateLaurentSeriesConstructorCategory| "laurent.spad" 1747244 1747303 1749392 1749542) (|UnivariateLaurentSeriesConstructorCategory&| "laurent.spad" 1745046 1745108 1747197 1747202) (|UnivariateLaurentSeriesCategory| "pscat.spad" 1743257 1743301 1744891 1745041) (|UnivariateLaurentSeriesFunctions2| "laurent.spad" 1742741 1742824 1743247 1743252) (|UnivariateLaurentSeries| "laurent.spad" 1738401 1738449 1739366 1739710) (|UInt8| "data.spad" 1738276 1738287 1738391 1738396) (|UInt64| "data.spad" 1738149 1738161 1738266 1738271) (|UInt32| "data.spad" 1738022 1738034 1738139 1738144) (|UInt16| "data.spad" 1737895 1737907 1738012 1738017) (|UniqueFactorizationDomain| "catdef.spad" 1736955 1736986 1737838 1737890) (|UniqueFactorizationDomain&| "catdef.spad" 1736059 1736093 1736945 1736950) (|UserDefinedVariableOrdering| "setorder.spad" 1734916 1734949 1736049 1736054) (|UserDefinedPartialOrdering| "setorder.spad" 1732466 1732500 1734864 1734869) (|TypeAst| "syntax.spad" 1732381 1732394 1732456 1732461) (|Type| "coerce.spad" 1732312 1732322 1732371 1732376) (|TwoFactorize| "twofact.spad" 1730959 1730979 1732302 1732307) (|Tuple| "array1.spad" 1730439 1730452 1730846 1730851) (|TubePlotTools| "tube.spad" 1727296 1727315 1730429 1730434) (|TubePlot| "tube.spad" 1725938 1725960 1727286 1727291) (|TriangularSetCategory| "triset.spad" 1714013 1714048 1725928 1725933) (|TriangularSetCategory&| "triset.spad" 1702047 1702085 1713965 1713970) (|TaylorSeries| "mts.spad" 1700636 1700661 1701611 1701716) (|TranscendentalManipulations| "manip.spad" 1695055 1695092 1700399 1700404) (|TriangularMatrixOperations| "intclos.spad" 1693995 1694043 1695045 1695050) (|TrigonometricManipulations| "efstruc.spad" 1692503 1692539 1693985 1693990) (|TrigonometricFunctionCategory| "trigcat.spad" 1691989 1692024 1692493 1692498) (|TrigonometricFunctionCategory&| "trigcat.spad" 1691472 1691510 1691979 1691984) (|Tree| "tree.spad" 1690114 1690126 1691147 1691152) (|TranscendentalFunctionCategory| "trigcat.spad" 1689926 1689962 1690104 1690109) (|TranscendentalFunctionCategory&| "trigcat.spad" 1689735 1689774 1689916 1689921) (|TopLevelThreeSpace| "space.spad" 1689394 1689418 1689725 1689730) (|ToolsForSign| "sign.spad" 1689048 1689068 1689384 1689389) (|TextFile| "files.spad" 1687604 1687618 1689038 1689043) (|TexFormat1| "tex.spad" 1687153 1687171 1687594 1687599) (|TexFormat| "tex.spad" 1684341 1684356 1687143 1687148) (|TabulatedComputationPackage| "newdata.spad" 1682418 1682465 1684331 1684336) (|TableAggregate| "aggcat.spad" 1681672 1681706 1682408 1682413) (|TableAggregate&| "aggcat.spad" 1680923 1680960 1681662 1681667) (|TangentExpansions| "efstruc.spad" 1680317 1680342 1680913 1680918) (|TermAlgebraOperator| "term.spad" 1680025 1680052 1680307 1680312) (|Tableau| "tableau.spad" 1679602 1679617 1680015 1680020) (|Table| "table.spad" 1678406 1678431 1678678 1678683) (|TableauxBumpers| "tableau.spad" 1675173 1675196 1678396 1678401) (|System| "/Users/gdr/build/oa/src/algebra/SYSTEM.spad" 1674398 1674410 1675163 1675168) (|SystemSolvePackage| "syssolp.spad" 1671866 1671892 1674388 1674393) (|SystemPointer| "data.spad" 1671755 1671774 1671856 1671861) (|SystemNonNegativeInteger| "data.spad" 1670957 1670989 1671745 1671750) (|SystemInteger| "data.spad" 1670351 1670372 1670947 1670952) (|Syntax| "syntax.spad" 1666682 1666694 1670341 1670346) (|SymbolTable| "forttyp.spad" 1664850 1664867 1666672 1666677) (|TheSymbolTable| "forttyp.spad" 1660868 1660888 1664840 1664845) (|SymmetricPolynomial| "prtition.spad" 1659965 1659992 1660063 1660237) (|SymmetricFunctions| "efstruc.spad" 1659451 1659477 1659955 1659960) (|Symbol| "symbol.spad" 1656943 1656955 1659441 1659446) (|SparseUnivariateTaylorSeries| "suts.spad" 1654268 1654321 1655712 1655817) (|SparseUnivariatePuiseuxSeries| "supxs.spad" 1652071 1652125 1652946 1653096) (|SupFractionFactorizer| "allfact.spad" 1651158 1651194 1652061 1652066) (|SparseUnivariatePolynomialFunctions2| "poly.spad" 1650517 1650563 1651148 1651153) (|SparseUnivariatePolynomial| "poly.spad" 1647899 1647933 1648695 1648912) (|RationalFunctionSum| "sum.spad" 1646857 1646884 1647889 1647894) (|FunctionSpaceSum| "combfunc.spad" 1646477 1646503 1646847 1646852) (|SparseUnivariateLaurentSeries| "suls.spad" 1642100 1642154 1643084 1643434) (|SuchThatAst| "syntax.spad" 1641861 1641878 1642090 1642095) (|SuchThat| "suchthat.spad" 1641546 1641566 1641851 1641856) (|SubSpace| "newpoint.spad" 1633672 1633692 1641536 1641541) (|SubResultantPackage| "intrf.spad" 1632813 1632843 1633615 1633620) (|StreamTranscendentalFunctionsNonCommutative| "sttf.spad" 1629241 1629297 1632803 1632808) (|StreamTranscendentalFunctions| "sttf.spad" 1625314 1625356 1629231 1629236) (|StreamTaylorSeriesOperations| "sttaylor.spad" 1617946 1617982 1625201 1625206) (|StringTable| "table.spad" 1616888 1616913 1617045 1617050) (|String| "string.spad" 1615929 1615941 1616317 1616322) (|StreamFunctions3| "stream.spad" 1615489 1615517 1615919 1615924) (|StreamFunctions2| "stream.spad" 1614604 1614630 1615479 1615484) (|StreamFunctions1| "stream.spad" 1614297 1614321 1614594 1614599) (|Stream| "stream.spad" 1611298 1611312 1613792 1613797) (|StreamInfiniteProduct| "infprod.spad" 1610216 1610250 1611288 1611293) (|StepAst| "syntax.spad" 1609446 1609459 1610206 1610211) (|StepThrough| "catdef.spad" 1608755 1608772 1609436 1609441) (|SparseTable| "table.spad" 1607656 1607692 1607831 1607836) (|StreamAggregate| "aggcat.spad" 1606343 1606366 1607646 1607651) (|StreamAggregate&| "aggcat.spad" 1605027 1605053 1606333 1606338) (|Stack| "bags.spad" 1604521 1604534 1604773 1604778) (|SemiRing| "catdef.spad" 1604276 1604290 1604511 1604516) (|SquareFreeRegularTriangularSet| "sregset.spad" 1601879 1601923 1603808 1603813) (|SquareFreeRegularSetDecompositionPackage| "sregset.spad" 1600419 1600476 1601869 1601874) (|StringAggregate| "aggcat.spad" 1595612 1595633 1600409 1600414) (|StringAggregate&| "aggcat.spad" 1590802 1590826 1595602 1595607) (|SquareMatrix| "matrix.spad" 1589185 1589212 1589780 1589785) (|SplittingTree| "newdata.spad" 1583978 1584001 1588784 1588789) (|SplittingNode| "newdata.spad" 1580588 1580611 1583968 1583973) (|SpecialFunctionCategory| "trigcat.spad" 1579377 1579406 1580578 1580583) (|SpecialOutputPackage| "out.spad" 1577912 1577938 1579367 1579372) (|SpadAstExports| "syntax.spad" 1569992 1570012 1577902 1577907) (|SpadParser| "parsers.spad" 1569450 1569466 1569982 1569987) (|SpadAst| "syntax.spad" 1569147 1569160 1569440 1569445) (|ThreeSpaceCategory| "space.spad" 1553462 1553488 1569137 1569142) (|ThreeSpace| "space.spad" 1553231 1553249 1553452 1553457) (|SortPackage| "sortpak.spad" 1552764 1552785 1553179 1553184) (|TransSolvePackage| "transsolve.spad" 1550513 1550538 1552754 1552759) (|TransSolvePackageService| "transsolve.spad" 1548948 1548980 1550503 1550508) (|RadicalSolvePackage| "solverad.spad" 1544958 1544985 1548938 1548943) (|PolynomialSolveByFormulas| "solvefor.spad" 1543402 1543438 1544948 1544953) (|SquareFreeNormalizedTriangularSetCategory| "nsregset.spad" 1542986 1543041 1543392 1543397) (|SparseMultivariateTaylorSeries| "mts.spad" 1541246 1541299 1542550 1542655) (|SparseMultivariatePolynomial| "multpoly.spad" 1539376 1539421 1539791 1539965) (|SmithNormalForm| "smith.spad" 1538209 1538246 1539366 1539371) (|SquareMatrixCategory| "matcat.spad" 1536356 1536403 1538199 1538204) (|SquareMatrixCategory&| "matcat.spad" 1534364 1534414 1536210 1536215) (|ShallowlyMutableAggregate| "aggcat.spad" 1534028 1534061 1534354 1534359) (|StackAggregate| "aggcat.spad" 1533008 1533030 1534018 1534023) (|SingleInteger| "si.spad" 1532513 1532532 1532873 1533003) (|SimplifyAlgebraicNumberConvertPackage| "manip.spad" 1532207 1532250 1532503 1532508) (|RationalFunctionSign| "sign.spad" 1531315 1531343 1532197 1532202) (|ElementaryFunctionSign| "limitps.spad" 1530586 1530618 1531305 1531310) (|SignatureAst| "syntax.spad" 1529994 1530012 1530576 1530581) (|Signature| "domain.spad" 1529350 1529365 1529984 1529989) (|SturmHabichtPackage| "sturm.spad" 1527271 1527302 1529299 1529304) (|SplitHomogeneousDirectProduct| "gdirprod.spad" 1523996 1524049 1524539 1524544) (|SemiGroup| "catdef.spad" 1523598 1523613 1523986 1523991) (|SemiGroup&| "catdef.spad" 1523197 1523215 1523588 1523593) (|SemiGroupOperatorCategory| "catdef.spad" 1522889 1522923 1523022 1523192) (|SemiGroupOperation| "catdef.spad" 1522434 1522461 1522714 1522884) (|SymmetricGroupCombinatoricFunctions| "sgcf.spad" 1515541 1515582 1522424 1522429) (|SquareFreeRegularTriangularSetCategory| "sregset.spad" 1514474 1514526 1515531 1515536) (|SquareFreeRegularTriangularSetGcdPackage| "sregset.spad" 1513500 1513557 1514464 1514469) (|SquareFreeQuasiComponentPackage| "sregset.spad" 1508285 1508333 1513490 1513495) (|SExpressionOf| "sex.spad" 1508118 1508168 1508275 1508280) (|SExpressionCategory| "sex.spad" 1505930 1505986 1508108 1508113) (|SExpression| "sex.spad" 1505814 1505831 1505920 1505925) (|SetOfMIntegersInOneToN| "lodof.spad" 1504255 1504291 1505804 1505809) (|SetCategory| "catdef.spad" 1503732 1503749 1504245 1504250) (|SetCategory&| "catdef.spad" 1503206 1503226 1503722 1503727) (|SetAggregate| "aggcat.spad" 1499730 1499750 1503170 1503201) (|SetAggregate&| "aggcat.spad" 1496277 1496300 1499720 1499725) (|Set| "sets.spad" 1494656 1494667 1495755 1495786) (|SequenceAst| "syntax.spad" 1494351 1494368 1494646 1494651) (|SegmentExpansionCategory| "seg.spad" 1493486 1493520 1494341 1494346) (|SegmentCategory| "seg.spad" 1492399 1492422 1493476 1493481) (|SegmentBindingFunctions2| "seg.spad" 1492076 1492110 1492389 1492394) (|SegmentBinding| "seg.spad" 1491811 1491833 1492011 1492016) (|SegmentAst| "syntax.spad" 1491534 1491550 1491801 1491806) (|SegmentFunctions2| "seg.spad" 1490946 1490973 1491481 1491486) (|Segment| "seg.spad" 1490738 1490753 1490848 1490853) (|SequentialDifferentialVariable| "dpolcat.spad" 1489987 1490025 1490728 1490733) (|SequentialDifferentialPolynomial| "dpolcat.spad" 1487938 1487978 1488258 1488432) (|StructuralConstantsPackage| "naalg.spad" 1486004 1486038 1487928 1487933) (|Scope| "any.spad" 1485179 1485190 1485994 1485999) (|SortedCache| "kl.spad" 1483867 1483886 1485169 1485174) (|SpadSyntaxCategory| "syntax.spad" 1483761 1483785 1483857 1483862) (|SingletonAsOrderedSet| "misc.spad" 1483615 1483642 1483751 1483756) (|SAERationalFunctionAlgFactor| "algfact.spad" 1483303 1483348 1483605 1483610) (|SimpleAlgebraicExtensionAlgFactor| "algfact.spad" 1482974 1483024 1483293 1483298) (|SimpleAlgebraicExtension| "algext.spad" 1481390 1481427 1482022 1482139) (|RationalUnivariateRepresentationPackage| "zerodim.spad" 1479013 1479065 1481380 1481385) (|Ruleset| "rule.spad" 1478466 1478490 1479003 1479008) (|RuleCalled| "variable.spad" 1478311 1478331 1478456 1478461) (|RewriteRule| "rule.spad" 1476555 1476583 1478301 1478306) (|RuntimeValue| "any.spad" 1476281 1476299 1476545 1476550) (|RestrictAst| "syntax.spad" 1475990 1476007 1476271 1476276) (|RegularTriangularSetGcdPackage| "regset.spad" 1472405 1472452 1475980 1475985) (|RegularTriangularSetCategory| "regset.spad" 1462370 1462412 1472395 1472400) (|RegularTriangularSetCategory&| "regset.spad" 1452332 1452377 1462360 1462365) (|RegularSetDecompositionPackage| "regset.spad" 1450805 1450852 1452322 1452327) (|RealRootCharacterizationCategory| "reclos.spad" 1449160 1449219 1450795 1450800) (|RealRootCharacterizationCategory&| "reclos.spad" 1447512 1447574 1449150 1449155) (|RepeatAst| "syntax.spad" 1447208 1447223 1447502 1447507) (|RecursivePolynomialCategory| "newpoly.spad" 1426641 1426680 1447029 1447203) (|RecursivePolynomialCategory&| "newpoly.spad" 1405816 1405858 1426207 1426212) (|RomanNumeral| "integer.spad" 1405284 1405302 1405681 1405811) (|RightOpenIntervalRootCharacterization| "reclos.spad" 1404330 1404396 1405274 1405279) (|RealNumberSystem| "sf.spad" 1403306 1403328 1404245 1404325) (|RealNumberSystem&| "sf.spad" 1402354 1402379 1403296 1403301) (|RangeBinding| "seg.spad" 1401497 1401520 1402301 1402306) (|Rng| "catdef.spad" 1401105 1401114 1401487 1401492) (|Rng&| "catdef.spad" 1400710 1400722 1401095 1401100) (|RightModule| "catdef.spad" 1400483 1400502 1400700 1400705) (|RectangularMatrixCategoryFunctions2| "matfuns.spad" 1399871 1399960 1400473 1400478) (|RectangularMatrix| "matrix.spad" 1398968 1399001 1399325 1399330) (|RectangularMatrixCategory| "matcat.spad" 1394749 1394802 1398958 1398963) (|RectangularMatrixCategory&| "matcat.spad" 1390344 1390400 1394556 1394561) (|RightLinearSet| "catdef.spad" 1390037 1390059 1390334 1390339) (|RationalInterpolation| "rinterp.spad" 1389911 1389945 1390027 1390032) (|Ring| "catdef.spad" 1389519 1389529 1389901 1389906) (|Ring&| "catdef.spad" 1389124 1389137 1389509 1389514) (|RandomIntegerDistributions| "random.spad" 1388493 1388525 1389114 1389119) (|RegularChain| "zerodim.spad" 1386945 1386970 1387848 1387853) (|RGBColorSpace| "color.spad" 1386724 1386746 1386935 1386940) (|RGBColorModel| "color.spad" 1386276 1386298 1386714 1386719) (|RationalFunctionFactorizer| "allfact.spad" 1385715 1385749 1386266 1386271) (|RationalFunctionFactor| "algfact.spad" 1385431 1385462 1385705 1385710) (|RandomFloatDistributions| "random.spad" 1384406 1384436 1385421 1385426) (|RationalFunction| "rf.spad" 1382067 1382091 1384396 1384401) (|RetractSolvePackage| "nlinsol.spad" 1381470 1381499 1382057 1382062) (|RetractableTo| "coerce.spad" 1380888 1380909 1381460 1381465) (|RetractableTo&| "coerce.spad" 1380303 1380327 1380878 1380883) (|ReturnAst| "syntax.spad" 1380109 1380124 1380293 1380298) (|ResidueRing| "resring.spad" 1379480 1379531 1380075 1380104) (|ResolveLatticeCompletion| "void.spad" 1378783 1378815 1379470 1379475) (|RepeatedSquaring| "defaults.spad" 1378501 1378525 1378773 1378778) (|RepeatedDoubling| "defaults.spad" 1378195 1378219 1378491 1378496) (|RepresentationPackage2| "rep2.spad" 1367899 1367929 1378046 1378051) (|RepresentationPackage1| "rep1.spad" 1362092 1362122 1367841 1367846) (|RadicalEigenPackage| "radeigen.spad" 1359630 1359655 1362082 1362087) (|RegularTriangularSet| "regset.spad" 1357336 1357370 1359162 1359167) (|Reference| "boolean.spad" 1356848 1356865 1357326 1357331) (|ReductionOfOrder| "odeef.spad" 1356045 1356071 1356838 1356843) (|RealClosure| "reclos.spad" 1355048 1355076 1355760 1355840) (|RealSolvePackage| "acplot.spad" 1354175 1354197 1355038 1355043) (|RealZeroPackageQ| "real0q.spad" 1351460 1351488 1354165 1354170) (|RealZeroPackage| "realzero.spad" 1348292 1348319 1351450 1351455) (|RealConstant| "sf.spad" 1348155 1348173 1348282 1348287) (|ReduceAst| "syntax.spad" 1347870 1347885 1348145 1348150) (|ReducedDivisor| "pfo.spad" 1347514 1347550 1347860 1347865) (|RandomDistributions| "random.spad" 1347065 1347092 1347504 1347509) (|TranscendentalRischDESystem| "rdesys.spad" 1345909 1345947 1347055 1347060) (|TranscendentalRischDE| "rderf.spad" 1344034 1344066 1345899 1345904) (|ElementaryRischDESystem| "rdesys.spad" 1343117 1343150 1344024 1344029) (|ElementaryRischDE| "rdeef.spad" 1342117 1342144 1343107 1343112) (|RealClosedField| "reclos.spad" 1339336 1339357 1342032 1342112) (|RealClosedField&| "reclos.spad" 1336627 1336651 1339326 1339331) (|RecursiveAggregate| "aggcat.spad" 1334548 1334574 1336617 1336622) (|RecursiveAggregate&| "aggcat.spad" 1332339 1332368 1334411 1334416) (|RationalRetractions| "retract.spad" 1331683 1331710 1332329 1332334) (|RationalFactorize| "ratfact.spad" 1331361 1331387 1331673 1331678) (|RandomNumberSource| "random.spad" 1330665 1330689 1331351 1331356) (|RadixUtilities| "radix.spad" 1330410 1330430 1330655 1330660) (|RadixExpansion| "radix.spad" 1327391 1327416 1328948 1329028) (|RadicalFunctionField| "curve.spad" 1326237 1326287 1326369 1326501) (|RadicalCategory| "sf.spad" 1325820 1325841 1326227 1326232) (|RadicalCategory&| "sf.spad" 1325400 1325424 1325810 1325815) (|Queue| "bags.spad" 1324885 1324898 1325146 1325151) (|QuaternionCategoryFunctions2| "quat.spad" 1324480 1324524 1324875 1324880) (|QuaternionCategory| "quat.spad" 1322652 1322678 1324427 1324475) (|QuaternionCategory&| "quat.spad" 1320468 1320497 1322246 1322251) (|Quaternion| "quat.spad" 1319012 1319030 1319362 1319410) (|QueueAggregate| "aggcat.spad" 1317856 1317878 1319002 1319007) (|QuasiquoteAst| "syntax.spad" 1317614 1317633 1317846 1317851) (|QuadraticForm| "clifford.spad" 1317222 1317247 1317604 1317609) (|QuotientFieldCategoryFunctions2| "fraction.spad" 1316886 1316931 1317212 1317217) (|QuotientFieldCategory| "fraction.spad" 1315583 1315612 1316801 1316881) (|QuotientFieldCategory&| "fraction.spad" 1313712 1313744 1314933 1314938) (|QueryEquation| "alql.spad" 1313260 1313279 1313702 1313707) (|QuasiComponentPackage| "regset.spad" 1308156 1308194 1313250 1313255) (|QuasiAlgebraicSet2| "qalgset.spad" 1306136 1306170 1308146 1308151) (|QuasiAlgebraicSet| "qalgset.spad" 1302197 1302244 1306021 1306026) (|PAdicWildFunctionFieldIntegralBasis| "padiclib.spad" 1299584 1299634 1302187 1302192) (|PushVariables| "facutil.spad" 1298912 1298942 1299574 1299579) (|PartialTranscendentalFunctions| "ptranfn.spad" 1295020 1295058 1298902 1298907) (|PointPackage| "newpoint.spad" 1292098 1292118 1295010 1295015) (|PointFunctions2| "newpoint.spad" 1291908 1291935 1292088 1292093) (|PointCategory| "newpoint.spad" 1291174 1291195 1291898 1291903) (|PolynomialSquareFree| "poly.spad" 1290471 1290513 1291164 1291169) (|PseudoLinearNormalForm| "pseudolin.spad" 1289337 1289367 1290461 1290466) (|PolynomialSetUtilitiesPackage| "triset.spad" 1275979 1276022 1289179 1289184) (|PolynomialSetCategory| "polset.spad" 1270370 1270412 1275969 1275974) (|PolynomialSetCategory&| "polset.spad" 1264712 1264757 1270314 1270319) (|PlottableSpaceCurveCategory| "pcurve.spad" 1263686 1263719 1264702 1264707) (|PowerSeriesCategory| "pscat.spad" 1262444 1262490 1263576 1263681) (|PowerSeriesCategory&| "pscat.spad" 1261299 1261348 1262434 1262439) (|Partition| "prtition.spad" 1259990 1260005 1261289 1261294) (|PretendAst| "syntax.spad" 1259701 1259717 1259980 1259985) (|PseudoRemainderSequence| "prs.spad" 1249291 1249329 1259650 1259655) (|PriorityQueueAggregate| "aggcat.spad" 1248728 1248758 1249281 1249286) (|PropositionalLogic| "logic.spad" 1248316 1248340 1248718 1248723) (|PropositionalFormulaFunctions2| "logic.spad" 1247911 1247952 1248306 1248311) (|PropositionalFormulaFunctions1| "logic.spad" 1247289 1247328 1247901 1247906) (|PropositionalFormula| "logic.spad" 1245839 1245868 1247279 1247284) (|Property| "any.spad" 1245329 1245343 1245829 1245834) (|Product| "product.spad" 1244260 1244277 1244549 1244554) (|PrintPackage| "print.spad" 1244002 1244020 1244250 1244255) (|IntegerPrimesPackage| "intfact.spad" 1242245 1242273 1243992 1243997) (|PrimitiveElement| "primelt.spad" 1240356 1240380 1242235 1242240) (|PrimitiveFunctionCategory| "trigcat.spad" 1239976 1240007 1240346 1240351) (|PrimitiveArrayFunctions2| "array1.spad" 1238721 1238755 1239966 1239971) (|PrimitiveArray| "array1.spad" 1237933 1237955 1238115 1238120) (|PrecomputedAssociatedEquations| "lodof.spad" 1237287 1237327 1237923 1237928) (|PolynomialRing| "poly.spad" 1235780 1235804 1236491 1236665) (|PlottablePlaneCurveCategory| "pcurve.spad" 1234892 1234925 1235770 1235775) (|PortNumber| "net.spad" 1234675 1234691 1234882 1234887) (|PolynomialRoots| "manip.spad" 1233508 1233539 1234624 1234629) (|PolynomialCategoryLifting| "polycat.spad" 1232750 1232796 1233498 1233503) (|PolynomialCategoryQuotientFunctions| "rf.spad" 1230847 1230898 1232740 1232745) (|PolynomialCategory| "polycat.spad" 1224286 1224323 1230668 1230842) (|PolynomialCategory&| "polycat.spad" 1217229 1217269 1223614 1223619) (|PolynomialToUnivariatePolynomial| "poly.spad" 1216651 1216695 1217219 1217224) (|PolynomialFunctions2| "multpoly.spad" 1216230 1216260 1216641 1216646) (|Polynomial| "multpoly.spad" 1214245 1214263 1214768 1214942) (|RealPolynomialUtilitiesPackage| "reclos.spad" 1213173 1213230 1214192 1214197) (|PolToPol| "poltopol.spad" 1211915 1211936 1213163 1213168) (|Point| "newpoint.spad" 1210934 1210947 1211024 1211029) (|PolynomialNumberTheoryFunctions| "numtheor.spad" 1207607 1207644 1210924 1210929) (|PatternMatchTools| "patmatch1.spad" 1206367 1206396 1207597 1207602) (|PatternMatchSymbol| "patmatch1.spad" 1205900 1205926 1206357 1206362) (|PatternMatchQuotientFieldCategory| "patmatch2.spad" 1205460 1205505 1205890 1205895) (|FunctionSpaceAttachPredicates| "expr.spad" 1204903 1204944 1205450 1205455) (|AttachPredicates| "expr.spad" 1204380 1204404 1204893 1204898) (|PatternMatchPolynomialCategory| "patmatch2.spad" 1203415 1203461 1204295 1204300) (|PatternMatchListAggregate| "patmatch1.spad" 1202977 1203014 1203405 1203410) (|PatternMatchKernel| "patmatch1.spad" 1202540 1202568 1202967 1202972) (|PatternMatchIntegerNumberSystem| "patmatch2.spad" 1202091 1202130 1202530 1202535) (|PatternMatchFunctionSpace| "patmatch2.spad" 1201649 1201686 1202081 1202086) (|PatternMatchPushDown| "patmatch1.spad" 1200921 1200953 1201639 1201644) (|FunctionSpaceAssertions| "expr.spad" 1199879 1199912 1200911 1200916) (|PatternMatchAssertions| "expr.spad" 1198877 1198905 1199869 1199874) (|PlotTools| "plottool.spad" 1198650 1198665 1198867 1198872) (|Plot3D| "plot3d.spad" 1195110 1195122 1198640 1198645) (|PlotFunctions1| "plot.spad" 1194271 1194293 1195100 1195105) (|Plot| "plot.spad" 1189192 1189202 1194261 1194266) (|ParametricLinearEquations| "pleqn.spad" 1176571 1176621 1189182 1189187) (|PolynomialInterpolationAlgorithms| "pinterp.spad" 1176328 1176371 1176561 1176566) (|PolynomialInterpolation| "pinterp.spad" 1175933 1175969 1176318 1176323) (|PrincipalIdealDomain| "catdef.spad" 1174906 1174932 1175876 1175928) (|PiCoercions| "expr.spad" 1174554 1174573 1174896 1174901) (|PositiveInteger| "integer.spad" 1174150 1174171 1174520 1174549) (|PolyGroebner| "pgrobner.spad" 1172753 1172773 1174140 1174145) (|PermutationGroupExamples| "permgrps.spad" 1164404 1164434 1172743 1172748) (|PolynomialGcdPackage| "pgcd.spad" 1163340 1163375 1164394 1164399) (|PartialFractionPackage| "pfr.spad" 1162469 1162499 1163330 1163335) (|PartialFraction| "pfr.spad" 1159294 1159317 1162384 1162464) (|PointsOfFiniteOrderTools| "pfo.spad" 1158530 1158568 1159284 1159289) (|PointsOfFiniteOrderRational| "pfo.spad" 1157875 1157918 1158520 1158525) (|PointsOfFiniteOrder| "pfo.spad" 1157281 1157321 1157865 1157870) (|PolynomialFactorizationExplicit| "catdef.spad" 1154979 1155016 1157224 1157276) (|PolynomialFactorizationExplicit&| "catdef.spad" 1152668 1152708 1154916 1154921) (|PolynomialFactorizationByRecursionUnivariate| "pfbr.spad" 1150514 1150568 1152658 1152663) (|PolynomialFactorizationByRecursion| "pfbr.spad" 1148042 1148097 1150504 1150509) (|PrimeField| "pf.spad" 1147582 1147602 1147821 1147901) (|PermutationGroup| "permgrps.spad" 1142588 1142612 1147572 1147577) (|PermutationCategory| "perm.spad" 1141242 1141269 1142578 1142583) (|Permanent| "perman.spad" 1139791 1139812 1141232 1141237) (|Permutation| "perm.spad" 1135648 1135667 1139680 1139685) (|PendantTree| "tree.spad" 1135034 1135053 1135323 1135328) (|PartialDifferentialSpace| "catdef.spad" 1133825 1133857 1135024 1135029) (|PartialDifferentialSpace&| "catdef.spad" 1132613 1132648 1133815 1133820) (|PartialDifferentialRing| "catdef.spad" 1132444 1132475 1132603 1132608) (|PartialDifferentialModule| "catdef.spad" 1132259 1132294 1132434 1132439) (|PolynomialDecomposition| "pdecomp.spad" 1131712 1131746 1132249 1132254) (|PartialDifferentialDomain| "catdef.spad" 1131127 1131163 1131702 1131707) (|PartialDifferentialDomain&| "catdef.spad" 1130539 1130578 1131117 1131122) (|PolynomialComposition| "pdecomp.spad" 1130373 1130405 1130529 1130534) (|PoincareBirkhoffWittLyndonBasis| "xlpoly.spad" 1129125 1129171 1130363 1130368) (|PatternFunctions2| "pattern.spad" 1128848 1128875 1129115 1129120) (|PatternFunctions1| "pattern.spad" 1127181 1127208 1128838 1128843) (|Pattern| "pattern.spad" 1121751 1121766 1127171 1127176) (|PatternMatchResultFunctions2| "patmatch1.spad" 1121397 1121437 1121741 1121746) (|PatternMatchResult| "patmatch1.spad" 1118964 1118992 1121387 1121392) (|PatternMatch| "patmatch2.spad" 1117290 1117331 1118811 1118816) (|PatternMatchable| "patmatch1.spad" 1116705 1116729 1117280 1117285) (|PatternMatchListResult| "patmatch1.spad" 1115771 1115805 1116695 1116700) (|Patternable| "pattern.spad" 1115526 1115545 1115761 1115766) (|PartitionsAndPermutations| "partperm.spad" 1113559 1113590 1115516 1115521) (|ParametricSurface| "paramete.spad" 1112978 1113021 1113549 1113554) (|ParametricSurfaceFunctions2| "paramete.spad" 1112750 1112791 1112968 1112973) (|Parser| "parsers.spad" 1112266 1112278 1112740 1112745) (|ParametricSpaceCurve| "paramete.spad" 1111682 1111728 1112256 1112261) (|ParametricSpaceCurveFunctions2| "paramete.spad" 1111445 1111489 1111672 1111677) (|ParametricPlaneCurve| "paramete.spad" 1110889 1110935 1111435 1111440) (|ParametricPlaneCurveFunctions2| "paramete.spad" 1110652 1110696 1110879 1110884) (|ParameterAst| "syntax.spad" 1109770 1109788 1110642 1110647) (|PolynomialAN2Expression| "expr.spad" 1109161 1109190 1109760 1109765) (|Palette| "color.spad" 1108270 1108283 1109151 1109156) (|Pair| "mkrecord.spad" 1107499 1107514 1108070 1108075) (|PAdicRationalConstructor| "padic.spad" 1104776 1104816 1105961 1106041) (|PAdicRational| "padic.spad" 1102980 1103003 1103204 1103284) (|PAdicIntegerCategory| "padic.spad" 1101528 1101558 1102923 1102975) (|PAdicInteger| "padic.spad" 1101238 1101260 1101471 1101523) (|PadeApproximantPackage| "pade.spad" 1099907 1099946 1101228 1101233) (|PadeApproximants| "pade.spad" 1098645 1098675 1099897 1099902) (|OrdinaryWeightedPolynomials| "wtpol.spad" 1097914 1097969 1098549 1098554) (|OverloadSet| "domain.spad" 1097478 1097495 1097904 1097909) (|OrderedVariableList| "variable.spad" 1097242 1097282 1097468 1097473) (|OutputForm| "outform.spad" 1086642 1086658 1097232 1097237) (|OutputBinaryFile| "net.spad" 1086062 1086084 1086632 1086637) (|OutputByteConduit| "net.spad" 1085117 1085140 1086052 1086057) (|OutputByteConduit&| "net.spad" 1084169 1084195 1085107 1085112) (|OutputPackage| "out.spad" 1083276 1083295 1084159 1084164) (|OrdSetInts| "fnla.spad" 1082743 1082759 1083266 1083271) (|OrderedSemiGroup| "catdef.spad" 1082647 1082669 1082733 1082738) (|OrthogonalPolynomialFunctions| "special.spad" 1081114 1081151 1082573 1082578) (|UnivariateSkewPolynomial| "ore.spad" 1080550 1080602 1080801 1080806) (|SparseUnivariateSkewPolynomial| "ore.spad" 1079828 1079882 1080237 1080242) (|UnivariateSkewPolynomialCategoryOps| "ore.spad" 1077669 1077714 1079733 1079738) (|UnivariateSkewPolynomialCategory| "ore.spad" 1071860 1071900 1077659 1077664) (|UnivariateSkewPolynomialCategory&| "ore.spad" 1065871 1065914 1071673 1071678) (|OrderedType| "catdef.spad" 1065099 1065116 1065861 1065866) (|OrderedType&| "catdef.spad" 1064324 1064344 1065089 1065094) (|OrderedStructure| "catdef.spad" 1064079 1064108 1064256 1064261) (|OrderedSet| "catdef.spad" 1063771 1063787 1064069 1064074) (|OrderedRing| "catdef.spad" 1063589 1063606 1063761 1063766) (|OrderedMonoid| "catdef.spad" 1063433 1063452 1063579 1063584) (|OrderingFunctions| "gdirprod.spad" 1062550 1062581 1063423 1063428) (|OrderedFinite| "catdef.spad" 1062359 1062378 1062540 1062545) (|OrderedCompletionFunctions2| "complet.spad" 1061627 1061664 1062349 1062354) (|OrderedCompletion| "complet.spad" 1060217 1060242 1061314 1061319) (|OperatorSignature| "domain.spad" 1059864 1059887 1060207 1060212) (|OperationsQuery| "alql.spad" 1059432 1059453 1059854 1059859) (|OperatorCategory| "term.spad" 1058884 1058908 1059422 1059427) (|OperatorCategory&| "term.spad" 1058333 1058360 1058874 1058879) (|Operator| "opalg.spad" 1058083 1058099 1058169 1058174) (|OnePointCompletionFunctions2| "complet.spad" 1057481 1057519 1058073 1058078) (|OnePointCompletion| "complet.spad" 1056350 1056376 1057168 1057173) (|OrderedMultisetAggregate| "aggcat.spad" 1056124 1056156 1056314 1056345) (|OppositeMonogenicLinearOperator| "lodop.spad" 1055535 1055576 1056017 1056022) (|OrderedIntegralDomain| "catdef.spad" 1055296 1055323 1055478 1055530) (|OrderedFreeMonoid| "xpoly.spad" 1053412 1053437 1055244 1055249) (|OrderlyDifferentialVariable| "dpolcat.spad" 1052648 1052683 1053402 1053407) (|OrdinaryDifferentialRing| "lodop.spad" 1052286 1052334 1052476 1052606) (|OrderlyDifferentialPolynomial| "dpolcat.spad" 1050193 1050230 1050560 1050734) (|OrderedDirectProduct| "gdirprod.spad" 1047070 1047108 1047461 1047466) (|ODETools| "oderf.spad" 1045717 1045738 1047060 1047065) (|SystemODESolver| "odealg.spad" 1043402 1043428 1045707 1045712) (|RationalRicDE| "riccati.spad" 1039405 1039429 1043336 1043341) (|ReduceLODE| "odealg.spad" 1038800 1038828 1039395 1039400) (|RationalLODE| "oderf.spad" 1036427 1036450 1038790 1038795) (|PrimitiveRatRicDE| "riccati.spad" 1033509 1033542 1036417 1036422) (|PrimitiveRatDE| "oderf.spad" 1030899 1030929 1033499 1033504) (|PureAlgebraicLODE| "odealg.spad" 1030274 1030309 1030889 1030894) (|ODEIntegration| "oderf.spad" 1029701 1029725 1030264 1030269) (|ElementaryFunctionODESolver| "odeef.spad" 1025175 1025212 1029691 1029696) (|ConstantLODE| "oderf.spad" 1024714 1024738 1025165 1025170) (|OctonionCategoryFunctions2| "oct.spad" 1024331 1024373 1024704 1024709) (|Octonion| "oct.spad" 1022765 1022781 1023485 1023490) (|OrderedCancellationAbelianMonoid| "catdef.spad" 1022583 1022621 1022755 1022760) (|OctonionCategory| "oct.spad" 1020399 1020423 1022573 1022578) (|OctonionCategory&| "oct.spad" 1017820 1017847 1019997 1020002) (|OrderedAbelianSemiGroup| "catdef.spad" 1017614 1017643 1017810 1017815) (|OrderedAbelianMonoidSup| "catdef.spad" 1017115 1017144 1017604 1017609) (|OrderedAbelianMonoid| "catdef.spad" 1016855 1016881 1017105 1017110) (|OrderedAbelianMonoid&| "catdef.spad" 1016592 1016621 1016845 1016850) (|OrderedAbelianGroup| "catdef.spad" 1016113 1016138 1016582 1016587) (|OrderedAbelianGroup&| "catdef.spad" 1015631 1015659 1016103 1016108) (|NumericTubePlot| "tube.spad" 1015209 1015238 1015621 1015626) (|NumericalQuadrature| "numquad.spad" 1003168 1003193 1015199 1015204) (|NumericalOrdinaryDifferentialEquations| "numode.spad" 994484 994528 1003158 1003163) (|NumberFormats| "outform.spad" 993313 993332 994474 994479) (|Numeric| "numeric.spad" 985417 985432 993113 993118) (|NormalizedTriangularSetCategory| "nregset.spad" 983918 983963 985407 985412) (|NumberTheoreticPolynomialFunctions| "special.spad" 983446 983488 983844 983849) (|NewSparseUnivariatePolynomialFunctions2| "newpoly.spad" 982801 982850 983436 983441) (|NewSparseUnivariatePolynomial| "newpoly.spad" 976532 976569 980979 981196) (|NewSparseMultivariatePolynomial| "newpoly.spad" 974368 974416 974689 974863) (|NumericRealEigenPackage| "numeigen.spad" 972749 972784 974358 974363) (|NPCoef| "npcoef.spad" 971991 972015 972739 972744) (|NormRetractPackage| "twofact.spad" 971577 971628 971981 971986) (|NormalizationPackage| "nregset.spad" 969501 969538 971567 971572) (|NormInMonogenicAlgebra| "algcat.spad" 969169 969215 969491 969496) (|NoneFunctions1| "any.spad" 968833 968855 969159 969164) (|None| "any.spad" 968572 968582 968823 968828) (|NonLinearFirstOrderODESolver| "nlode.spad" 968037 968075 968562 968567) (|NonNegativeInteger| "integer.spad" 966908 966932 968003 968032) (|NonLinearSolvePackage| "nlinsol.spad" 965515 965544 966898 966903) (|NumberFieldIntegralBasis| "intclos.spad" 963057 963092 965505 965510) (|NetworkClientSocket| "net.spad" 963014 963042 963047 963052) (|NonCommutativeOperatorDivision| "lodop.spad" 961214 961254 963004 963009) (|NumericContinuedFraction| "contfrac.spad" 960838 960870 961204 961209) (|NumericComplexEigenPackage| "numeigen.spad" 958980 959018 960828 960833) (|NonAssociativeRing| "naalgc.spad" 958568 958592 958970 958975) (|NonAssociativeRing&| "naalgc.spad" 958153 958180 958558 958563) (|NonAssociativeRng| "naalgc.spad" 957538 957561 958143 958148) (|NonAssociativeRng&| "naalgc.spad" 956920 956946 957528 957533) (|NonAssociativeAlgebra| "naalgc.spad" 956488 956517 956910 956915) (|NonAssociativeAlgebra&| "naalgc.spad" 956053 956085 956478 956483) (|MultivariateSquareFree| "multsqfr.spad" 952991 953028 956043 956048) (|MultivariateFactorize| "multfact.spad" 952355 952391 952981 952986) (|MultivariateTaylorSeriesCategory| "pscat.spad" 950411 950462 952245 952350) (|MergeThing| "alql.spad" 950062 950080 950401 950406) (|MoreSystemCommands| "system.spad" 949480 949504 950052 950057) (|MultisetAggregate| "aggcat.spad" 949306 949331 949444 949475) (|Multiset| "mset.spad" 947147 947163 948900 948931) (|MonoidRing| "mring.spad" 944271 944291 946865 946870) (|MonoidRingFunctions2| "mring.spad" 943815 943847 944261 944266) (|MRationalFactorize| "allfact.spad" 943345 943378 943805 943810) (|MPolyCatRationalFunctionFactorizer| "allfact.spad" 941353 941404 943335 943340) (|MultivariatePolynomial| "multpoly.spad" 939494 939529 939873 940047) (|MPolyCatPolyFactorizer| "allfact.spad" 938738 938777 939484 939489) (|MPolyCatFunctions3| "poltopol.spad" 938539 938595 938728 938733) (|MPolyCatFunctions2| "poltopol.spad" 938177 938226 938529 938534) (|MonomialExtensionTools| "intrf.spad" 936512 936545 938167 938172) (|MonoidOperatorCategory| "catdef.spad" 935919 935950 936160 936507) (|MonoidOperation| "catdef.spad" 935325 935349 935594 935914) (|Monoid| "catdef.spad" 934659 934671 935315 935320) (|Monoid&| "catdef.spad" 933990 934005 934649 934654) (|MonogenicAlgebra| "algcat.spad" 932742 932769 933868 933985) (|MonogenicAlgebra&| "algcat.spad" 931473 931503 932602 932607) (|MonadWithUnit| "naalgc.spad" 929710 929729 931463 931468) (|MonadWithUnit&| "naalgc.spad" 927944 927966 929700 929705) (|Monad| "naalgc.spad" 927101 927112 927934 927939) (|Monad&| "naalgc.spad" 926255 926269 927091 927096) (|MoebiusTransform| "moebius.spad" 924991 925015 926245 926250) (|Module| "catdef.spad" 924879 924893 924981 924986) (|Module&| "catdef.spad" 924764 924781 924869 924874) (|ModularRing| "modring.spad" 924220 924276 924754 924759) (|ModuleOperator| "opalg.spad" 922879 922903 924056 924061) (|ModuleMonomial| "modmonom.spad" 922598 922628 922869 922874) (|ModMonic| "modmon.spad" 919962 919980 920683 920900) (|ModularField| "modring.spad" 919376 919433 919877 919957) (|MathMLFormat| "mathml.spad" 918226 918244 919366 919371) (|MultipleMap| "curve.spad" 917959 918002 918216 918221) (|MonogenicLinearOperator| "lodop.spad" 916431 916462 917949 917954) (|MultivariateLifting| "mlift.spad" 915026 915060 916421 916426) (|MakeUnaryCompiledFunction| "mkfunc.spad" 914542 914579 915016 915021) (|MakeRecord| "mkrecord.spad" 914122 914143 914532 914537) (|MakeFunction| "mkfunc.spad" 913519 913539 914112 914117) (|MakeFloatCompiledFunction| "mkfunc.spad" 912464 912497 913509 913514) (|MakeBinaryCompiledFunction| "mkfunc.spad" 911935 911977 912454 912459) (|ModularHermitianRowReduction| "divisor.spad" 910420 910456 911925 911930) (|MultFiniteFactorize| "mfinfact.spad" 909807 909842 910410 910415) (|MeshCreationRoutinesForThreeDimensions| "mesh.spad" 907566 907610 909797 909802) (|ModularDistinctDegreeFactorizer| "moddfact.spad" 905756 905795 907556 907561) (|MultiDictionary| "aggcat.spad" 905044 905067 905746 905751) (|MatrixCommonDenominator| "cden.spad" 904233 904266 905034 905039) (|Maybe| "any.spad" 903472 903486 904165 904170) (|StorageEfficientMatrixOperations| "matstor.spad" 900758 900798 903462 903467) (|Matrix| "matrix.spad" 899737 899751 900225 900230) (|MatrixLinearAlgebraFunctions| "matfuns.spad" 897051 897101 899593 899598) (|MatrixCategoryFunctions2| "matfuns.spad" 896311 896381 897041 897046) (|MatrixCategory| "matcat.spad" 888017 888051 896301 896306) (|MatrixCategory&| "matcat.spad" 879536 879573 887823 887828) (|MappingPackage3| "mappkg.spad" 878438 878465 879526 879531) (|MappingPackage2| "mappkg.spad" 877763 877788 878428 878433) (|MappingPackage1| "mappkg.spad" 876578 876601 877753 877758) (|MappingAst| "syntax.spad" 875909 875925 876568 876573) (|MappingPackageInternalHacks3| "mappkg.spad" 875695 875735 875899 875904) (|MappingPackageInternalHacks2| "mappkg.spad" 875438 875476 875685 875690) (|MappingPackageInternalHacks1| "mappkg.spad" 875056 875092 875428 875433) (|MacroAst| "syntax.spad" 874645 874659 875046 875051) (|LazyStreamAggregate| "stream.spad" 871882 871909 874635 874640) (|LazyStreamAggregate&| "stream.spad" 869116 869146 871872 871877) (|LyndonWord| "xlpoly.spad" 866158 866183 869106 869111) (|ConstructAst| "syntax.spad" 865932 865950 866148 866153) (|LieSquareMatrix| "lie.spad" 864564 864591 864971 864976) (|LinearSystemPolynomialPackage| "solvelin.spad" 864072 864116 864554 864559) (|LinearSystemMatrixPackage1| "solvelin.spad" 861895 861929 864062 864067) (|LinearSystemMatrixPackage| "solvelin.spad" 860733 860780 861885 861890) (|ListAggregate| "aggcat.spad" 860413 860434 860723 860728) (|ListAggregate&| "aggcat.spad" 860090 860114 860403 860408) (|LiePolynomial| "xlpoly.spad" 859089 859119 859994 859999) (|LinearPolynomialEquationByFractions| "fraction.spad" 858327 858370 859079 859084) (|Logic| "logic.spad" 857866 857877 858317 858322) (|Logic&| "logic.spad" 857402 857416 857856 857861) (|LinearOrdinaryDifferentialOperatorsOps| "lodo.spad" 856296 856344 857392 857397) (|LinearOrdinaryDifferentialOperatorFactorizer| "lodof.spad" 855281 855336 856230 856235) (|LinearOrdinaryDifferentialOperatorCategory| "lodo.spad" 853941 853991 855271 855276) (|LinearOrdinaryDifferentialOperatorCategory&| "lodo.spad" 852561 852614 853894 853899) (|LinearOrdinaryDifferentialOperator2| "lodo.spad" 851808 851853 852248 852253) (|LinearOrdinaryDifferentialOperator1| "lodo.spad" 851182 851225 851495 851500) (|LinearOrdinaryDifferentialOperator| "lodo.spad" 850540 850589 850869 850874) (|ElementaryFunctionLODESolver| "odeef.spad" 849320 849360 850530 850535) (|Localize| "fraction.spad" 848720 848740 849259 849264) (|LinearAggregate| "aggcat.spad" 844894 844917 848710 848715) (|LinearAggregate&| "aggcat.spad" 840981 841007 844800 844805) (|ListMonoidOps| "free.spad" 837738 837766 840971 840976) (|LeftModule| "catdef.spad" 837514 837532 837728 837733) (|ListMultiDictionary| "lmdict.spad" 836856 836883 837121 837126) (|LeftLinearSet| "catdef.spad" 836552 836573 836846 836851) (|Literal| "syntax.spad" 836453 836469 836542 836547) (|ListFunctions3| "list.spad" 835752 835778 836443 836448) (|ListToMap| "list.spad" 832672 832691 835742 835747) (|ListFunctions2| "list.spad" 831362 831386 832662 832667) (|List| "list.spad" 829411 829423 830756 830761) (|LinearSet| "catdef.spad" 829183 829200 829401 829406) (|LinearForm| "vector.spad" 828660 828680 829173 829178) (|LinearlyExplicitRingOver| "catdef.spad" 827381 827413 828650 828655) (|LinearElement| "vector.spad" 826755 826778 827278 827283) (|LinearDependence| "lindep.spad" 825616 825642 826693 826698) (|LinearBasis| "vector.spad" 825243 825267 825606 825611) (|RationalFunctionLimitPackage| "sign.spad" 823164 823200 825233 825238) (|PowerSeriesLimitPackage| "limitps.spad" 822053 822087 823154 823159) (|LieAlgebra| "xlpoly.spad" 821555 821573 822043 822048) (|LieAlgebra&| "xlpoly.spad" 821017 821038 821508 821513) (|AssociatedLieAlgebra| "lie.spad" 819401 819431 820693 820698) (|Library| "files.spad" 818169 818182 818620 818625) (|LinGroebnerPackage| "lingrob.spad" 815510 815541 818159 818164) (|LiouvillianFunctionCategory| "trigcat.spad" 814544 814577 815500 815505) (|LiouvillianFunction| "liouv.spad" 813486 813515 814534 814539) (|LexTriangularPackage| "zerodim.spad" 809091 809124 813476 813481) (|LieExponentials| "xlpoly.spad" 807372 807412 809081 809086) (|LetAst| "syntax.spad" 807067 807079 807362 807367) (|LeadingCoefDetermination| "leadcdet.spad" 805451 805490 807057 807062) (|LazardSetSolvingPackage| "nsregset.spad" 804174 804217 805441 805446) (|LaurentPolynomial| "gpol.spad" 802698 802726 803613 803665) (|LaplaceTransform| "laplace.spad" 802271 802297 802688 802693) (|LeftAlgebra| "derham.spad" 802048 802067 802261 802266) (|LeftAlgebra&| "derham.spad" 801822 801844 802038 802043) (|LocalAlgebra| "fraction.spad" 801277 801301 801769 801774) (|ConvertibleFrom| "coerce.spad" 801007 801030 801267 801272) (|KleeneTrivalentLogic| "logic.spad" 800533 800559 800997 801002) (|CoercibleFrom| "coerce.spad" 800268 800289 800523 800528) (|Kovacic| "kovacic.spad" 798998 799016 800258 800263) (|ConvertibleTo| "coerce.spad" 798709 798730 798988 798993) (|CoercibleTo| "coerce.spad" 798437 798456 798699 798704) (|KernelFunctions2| "kl.spad" 798126 798152 798427 798432) (|Kernel| "kl.spad" 796784 796798 797917 797922) (|KeyedDictionary| "aggcat.spad" 795890 795925 796774 796779) (|KeyedDictionary&| "aggcat.spad" 794993 795031 795880 795885) (|KeyedAccessFile| "files.spad" 793918 793947 794166 794171) (|JVMOpcode| "java.spad" 793824 793839 793908 793913) (|JVMMethodAccess| "java.spad" 792865 792886 793814 793819) (|JVMFieldAccess| "java.spad" 792169 792189 792855 792860) (|JVMConstantTag| "java.spad" 790886 790906 792159 792164) (|JVMClassFileAccess| "java.spad" 790316 790340 790876 790881) (|JVMBytecode| "java.spad" 790218 790235 790306 790311) (|AssociatedJordanAlgebra| "lie.spad" 788412 788445 789894 789899) (|JoinAst| "syntax.spad" 788109 788122 788402 788407) (|IndexedAggregate| "aggcat.spad" 786228 786266 788099 788104) (|IndexedAggregate&| "aggcat.spad" 784109 784150 785983 785988) (|InfiniteTuple| "ituple.spad" 783390 783411 784099 784104) (|InnerTrigonometricManipulations| "efstruc.spad" 782212 782256 783380 783385) (|InfiniteTupleFunctions3| "ituple.spad" 781697 781732 782202 782207) (|InfiniteTupleFunctions2| "ituple.spad" 781420 781453 781687 781692) (|InternalTypeForm| "compiler.spad" 780761 780783 781410 781415) (|InnerTaylorSeries| "taylor.spad" 778727 778757 780612 780710) (|InnerSparseUnivariatePowerSeries| "sups.spad" 771349 771394 777916 778021) (|InnerPolySum| "sum.spad" 770840 770866 771339 771344) (|IsAst| "syntax.spad" 770556 770567 770830 770835) (|InternalRationalUnivariateRepresentationPackage| "zerodim.spad" 769228 769292 770546 770551) (|IrrRepSymNatPackage| "irsn.spad" 767215 767240 769218 769223) (|IntegrationResultRFToFunction| "irexpand.spad" 765665 765702 767155 767160) (|IrredPolyOverFiniteField| "ffx.spad" 765244 765277 765655 765660) (|IntegerRoots| "intfact.spad" 763573 763593 765234 765239) (|InternalRepresentationForm| "compiler.spad" 762873 762905 763563 763568) (|IntegrationResultToFunction| "irexpand.spad" 762066 762103 762863 762868) (|IntegrationResultFunctions2| "intaux.spad" 761073 761110 762056 762061) (|IntegrationResult| "intaux.spad" 758886 758911 760943 760948) (|InternalPrintPackage| "newdata.spad" 758628 758654 758876 758881) (|InnerPrimeField| "pf.spad" 758154 758179 758407 758487) (|InnerPAdicInteger| "padic.spad" 757925 757966 758097 758149) (|IP4Address| "net.spad" 757474 757490 757915 757920) (|IOMode| "files.spad" 756992 757004 757464 757469) (|InputOutputBinaryFile| "net.spad" 756358 756385 756982 756987) (|InputOutputByteConduit| "net.spad" 756203 756231 756348 756353) (|InverseLaplaceTransform| "laplace.spad" 755835 755868 756193 756198) (|TranscendentalIntegration| "intrf.spad" 749210 749246 755825 755830) (|IntegrationTools| "rdeef.spad" 746949 746975 748778 748783) (|IntegerSolveLinearPolynomialEquation| "integer.spad" 746243 746285 746939 746944) (|Interval| "interval.spad" 745812 745828 746166 746238) (|RationalFunctionIntegration| "intrf.spad" 744223 744258 745802 745807) (|IntegerRetractions| "retract.spad" 743639 743665 744213 744218) (|RationalIntegration| "intrf.spad" 742361 742391 743629 743634) (|PatternMatchIntegration| "intpm.spad" 740806 740839 742081 742086) (|PureAlgebraicIntegration| "intaf.spad" 738624 738660 740695 740700) (|TranscendentalHermiteIntegration| "intrf.spad" 737872 737915 738614 738619) (|AlgebraicHermiteIntegration| "intalg.spad" 737521 737566 737862 737867) (|IntegerNumberTheoryFunctions| "numtheor.spad" 733934 733968 737511 737516) (|GenusZeroIntegration| "intaf.spad" 727644 727676 733823 733828) (|IntegerFactorizationPackage| "intfact.spad" 726686 726721 727634 727639) (|ElementaryIntegration| "intef.spad" 725082 725113 726676 726681) (|IntegralDomain| "catdef.spad" 723800 723820 725025 725077) (|IntegralDomain&| "catdef.spad" 722562 722585 723790 723795) (|IntervalCategory| "interval.spad" 720824 720848 722485 722557) (|IntegerBits| "random.spad" 720322 720339 720814 720819) (|AlgebraicIntegrate| "intalg.spad" 719498 719537 720312 720317) (|AlgebraicIntegration| "intaf.spad" 718984 719014 719488 719493) (|InnerTable| "table.spad" 717889 717928 718060 718065) (|Int8| "data.spad" 717767 717777 717879 717884) (|Int64| "data.spad" 717643 717654 717757 717762) (|Int32| "data.spad" 717519 717530 717633 717638) (|Int16| "data.spad" 717395 717406 717509 717514) (|Integer| "integer.spad" 717065 717078 717260 717390) (|IntegerNumberSystem| "si.spad" 714532 714557 716948 717060) (|IntegerNumberSystem&| "si.spad" 712103 712131 714522 714527) (|InnerPolySign| "sign.spad" 711562 711586 712093 712098) (|InfiniteProductPrimeField| "infprod.spad" 710635 710677 711552 711557) (|InfiniteProductFiniteField| "infprod.spad" 709699 709747 710625 710630) (|InnerMultFact| "multfact.spad" 708663 708691 709689 709694) (|InnerModularGcd| "modgcd.spad" 708154 708197 708653 708658) (|InnerNumericFloatSolvePackage| "numsolve.spad" 706428 706473 708144 708149) (|InfiniteProductCharacteristicZero| "infprod.spad" 705477 705527 706418 706423) (|InputFormFunctions1| "mkfunc.spad" 705085 705112 705467 705472) (|InputForm| "mkfunc.spad" 702289 702304 705075 705080) (|Infinity| "complet.spad" 701835 701849 702279 702284) (|InetClientStreamSocket| "net.spad" 701792 701820 701825 701830) (|InnerNumericEigenPackage| "numeigen.spad" 700320 700360 701782 701787) (|IndexedExponents| "multpoly.spad" 699940 699971 700215 700220) (|IncrementingMaps| "seg.spad" 699363 699387 699930 699935) (|InputBinaryFile| "net.spad" 698446 698467 699353 699358) (|InnerNormalBasisFieldFunctions| "ffnb.spad" 694268 694307 698436 698441) (|InputByteConduit| "net.spad" 692520 692542 694258 694263) (|InputByteConduit&| "net.spad" 690769 690794 692510 692515) (|InAst| "syntax.spad" 690427 690438 690759 690764) (|ImportAst| "syntax.spad" 690128 690143 690417 690422) (|InnerMatrixQuotientFieldFunctions| "matfuns.spad" 689141 689216 690034 690039) (|InnerMatrixLinearAlgebraFunctions| "matfuns.spad" 687681 687736 689047 689052) (|InnerFiniteField| "ffp.spad" 687126 687156 687411 687491) (|IfAst| "syntax.spad" 686737 686748 687116 687121) (|IndexedFlexibleArray| "array1.spad" 684415 684448 686131 686136) (|InnerFreeAbelianMonoid| "free.spad" 684239 684276 684353 684358) (|InnerEvalable| "equation1.spad" 683641 683664 684229 684234) (|InnerEvalable&| "equation1.spad" 683040 683066 683631 683636) (|IndexedProductTerm| "indexedp.spad" 682580 682608 683030 683035) (|IndexedDirectProductOrderedAbelianMonoidSup| "indexedp.spad" 682218 682271 682493 682498) (|IndexedDirectProductOrderedAbelianMonoid| "indexedp.spad" 681823 681873 682131 682136) (|IndexedDirectProductObject| "indexedp.spad" 681214 681250 681736 681741) (|IndexedDirectProductCategory| "indexedp.spad" 680086 680124 681204 681209) (|IndexedDirectProductAbelianMonoid| "indexedp.spad" 679723 679766 679999 680004) (|IndexedDirectProductAbelianGroup| "indexedp.spad" 679363 679405 679636 679641) (|Identifier| "syntax.spad" 679007 679023 679353 679358) (|IdempotentOperatorCategory| "catdef.spad" 678758 678793 678894 679002) (|IdealDecompositionPackage| "idecomp.spad" 675974 676015 678748 678753) (|PolynomialIdeals| "ideal.spad" 670912 670961 675908 675913) (|InnerCommonDenominator| "cden.spad" 670105 670141 670902 670907) (|IndexCard| "alql.spad" 669491 669506 670095 670100) (|IntegralBasisPolynomialTools| "padiclib.spad" 668072 668115 669481 669486) (|IndexedBits| "boolean.spad" 667420 667442 667562 667567) (|IntegralBasisTools| "intclos.spad" 664393 664424 667410 667415) (|ChineseRemainderToolsForIntegralBases| "padiclib.spad" 662865 662915 664383 664388) (|InnerTwoDimensionalArray| "array2.spad" 662402 662446 662611 662616) (|IndexedOneDimensionalArray| "array1.spad" 661626 661665 661796 661801) (|InnerAlgebraicNumber| "constant.spad" 659985 660011 661452 661532) (|InnerAlgFactor| "algfact.spad" 659588 659629 659975 659980) (|HyperbolicFunctionCategory| "trigcat.spad" 658988 659020 659578 659583) (|HyperbolicFunctionCategory&| "trigcat.spad" 658385 658420 658978 658983) (|Hostname| "net.spad" 658195 658209 658375 658380) (|HomotopicTo| "coerce.spad" 657929 657948 658185 658190) (|HomogeneousAggregate| "aggcat.spad" 657611 657639 657919 657924) (|HomogeneousAggregate&| "aggcat.spad" 657075 657106 657386 657391) (|HexadecimalExpansion| "radix.spad" 655230 655256 655613 655693) (|HeuGcd| "listgcd.spad" 654317 654332 655220 655225) (|HyperellipticFiniteDivisor| "divisor.spad" 653903 653947 654307 654312) (|Heap| "bags.spad" 653432 653444 653649 653654) (|HeadAst| "syntax.spad" 652968 652981 653422 653427) (|HomogeneousDirectProduct| "gdirprod.spad" 649837 649875 650236 650241) (|HomogeneousDistributedMultivariatePolynomial| "gdpoly.spad" 647699 647756 648357 648531) (|HallBasis| "fnla.spad" 645967 645982 647689 647694) (|HashTable| "table.spad" 644825 644863 645043 645048) (|HasAst| "syntax.spad" 644537 644549 644815 644820) (|Pi| "expr.spad" 644041 644049 644452 644532) (|GeneralTriangularSet| "triset.spad" 642848 642882 643573 643578) (|GeneralSparseTable| "table.spad" 641734 641785 641924 641929) (|GeneralUnivariatePowerSeries| "gseries.spad" 639567 639620 640412 640562) (|Group| "catdef.spad" 638949 638960 639557 639562) (|Group&| "catdef.spad" 638328 638342 638939 638944) (|GroebnerSolve| "groebsol.spad" 636815 636843 638318 638323) (|GradedModule| "carten.spad" 635386 635408 636805 636810) (|GradedModule&| "carten.spad" 633954 633979 635376 635381) (|GraphImage| "view2D.spad" 627027 627043 633944 633949) (|GraphicsDefaults| "grdef.spad" 625392 625414 627017 627022) (|GrayCode| "perman.spad" 623857 623871 625382 625387) (|GradedAlgebra| "carten.spad" 622941 622964 623847 623852) (|GradedAlgebra&| "carten.spad" 622022 622048 622931 622936) (|GeneralPolynomialSet| "polset.spad" 621364 621405 621594 621599) (|GosperSummationMethod| "sum.spad" 620622 620659 621354 621359) (|GeneralModulePolynomial| "modmonom.spad" 619771 619819 620612 620617) (|GeneralHenselPackage| "ghensel.spad" 618836 618868 619761 619766) (|GenerateUnivariatePowerSeries| "genups.spad" 615102 615142 618826 618831) (|GenUFactorize| "genufact.spad" 614668 614689 615092 615097) (|GeneralPolynomialGcdPackage| "gpgcd.spad" 614245 614287 614658 614663) (|GeneralizedMultivariateFactorize| "allfact.spad" 613667 613716 614235 614240) (|GenExEuclid| "geneez.spad" 611617 611639 613657 613662) (|GeneralDistributedMultivariatePolynomial| "gdpoly.spad" 609325 609380 610137 610311) (|GenericNonAssociativeAlgebra| "generic.spad" 603275 603328 609172 609177) (|GcdDomain| "catdef.spad" 602477 602492 603218 603270) (|GcdDomain&| "catdef.spad" 601723 601741 602467 602472) (|GroebnerInternalPackage| "gbintern.spad" 597722 597781 601713 601718) (|GroebnerFactorizationPackage| "groebf.spad" 593479 593543 597712 597717) (|EuclideanGroebnerBasisPackage| "gbeuclid.spad" 591334 591399 593469 593474) (|GroebnerPackage| "gb.spad" 588844 588895 591287 591292) (|GaussianFactorizationPackage| "gaussfac.spad" 588131 588165 588834 588839) (|GaloisGroupUtilities| "galutil.spad" 586422 586450 588070 588075) (|GaloisGroupPolynomialUtilities| "galpolyu.spad" 584848 584889 586412 586417) (|GaloisGroupFactorizationUtilities| "galfactu.spad" 583034 583080 584838 584843) (|GaloisGroupFactorizer| "galfact.spad" 573228 573258 583024 583029) (|FunctionDescriptor| "domain.spad" 572890 572914 573218 573223) (|Functorial| "catdef.spad" 572493 572511 572880 572885) (|FunctionCalled| "variable.spad" 572330 572354 572483 572488) (|FortranType| "forttyp.spad" 570621 570638 572320 572325) (|FunctionSpaceUnivariatePolynomialFactor| "funcpkgs.spad" 569477 569529 570546 570551) (|FortranScalarType| "forttyp.spad" 567731 567754 569467 569472) (|FunctionSpaceReduce| "pfo.spad" 567198 567227 567721 567726) (|FunctionSpacePrimitiveElement| "primelt.spad" 566018 566057 567132 567137) (|FunctionalSpecialFunction| "combfunc.spad" 564090 564125 566008 566013) (|FunctionSpaceIntegration| "integrat.spad" 563732 563766 564080 564085) (|FourierSeries| "fourier.spad" 562934 562957 563574 563652) (|FunctionSpaceComplexIntegration| "integrat.spad" 562226 562267 562924 562929) (|FiniteSetAggregateFunctions2| "aggcat2.spad" 560935 560977 562216 562221) (|FiniteSetAggregate| "aggcat.spad" 560044 560070 560899 560930) (|FiniteSetAggregate&| "aggcat.spad" 559094 559123 559952 559957) (|FunctionSpaceToUnivariatePowerSeries| "fs2ups.spad" 553575 553643 559084 559089) (|FunctionSpaceToExponentialExpansion| "fs2expxp.spad" 552683 552739 553565 553570) (|FunctionSpaceFunctions2| "fspace.spad" 552317 552354 552673 552678) (|FunctionSpace| "fspace.spad" 546655 546676 552173 552312) (|FunctionSpace&| "fspace.spad" 540586 540610 546107 546112) (|FactoredFunctionUtilities| "fr.spad" 539517 539550 540576 540581) (|FramedNonAssociativeAlgebra| "naalgc.spad" 534817 534852 539507 539512) (|FramedNonAssociativeAlgebra&| "naalgc.spad" 530077 530115 534770 534775) (|FramedNonAssociativeAlgebraFunctions2| "naalg.spad" 529490 529543 530067 530072) (|FramedModule| "divisor.spad" 528881 528917 529408 529413) (|FractionalIdealFunctions2| "divisor.spad" 528462 528517 528871 528876) (|FractionalIdeal| "divisor.spad" 527688 527718 528452 528457) (|FullyRetractableTo| "retract.spad" 527191 527217 527678 527683) (|FullyRetractableTo&| "retract.spad" 526567 526596 527057 527062) (|FramedAlgebra| "algcat.spad" 524970 524994 526557 526562) (|FramedAlgebra&| "algcat.spad" 523370 523397 524960 524965) (|FractionFunctions2| "fraction.spad" 522959 522987 523360 523365) (|Fraction| "fraction.spad" 520756 520772 521149 521358) (|FactoredFunctions2| "fr.spad" 520076 520104 520746 520751) (|Factored| "fr.spad" 514075 514091 519038 519090) (|FloatingPointSystem| "sf.spad" 510902 510927 513970 514070) (|FloatingPointSystem&| "sf.spad" 507722 507750 510793 510798) (|FieldOfPrimeCharacteristic| "ffcat.spad" 506757 506789 507637 507717) (|FieldOfPrimeCharacteristic&| "ffcat.spad" 505864 505899 506747 506752) (|FullyPatternMatchable| "patmatch1.spad" 505607 505636 505854 505859) (|FullPartialFractionExpansion| "fparfrac.spad" 504427 504466 505597 505602) (|FindOrderFinite| "pfo.spad" 504109 504142 504417 504422) (|FreeNilpotentLie| "fnla.spad" 503541 503577 504099 504104) (|FileNameCategory| "fname.spad" 502122 502144 503531 503536) (|FileName| "fname.spad" 502008 502022 502112 502117) (|FreeMonoid| "free.spad" 501673 501691 501956 501961) (|FreeMonoidCategory| "free.spad" 498826 498852 501663 501668) (|FreeModuleCat| "xpoly.spad" 496673 496702 498816 498821) (|FreeMagma| "xlpoly.spad" 494652 494676 496663 496668) (|FreeModule1| "xpoly.spad" 494017 494038 494595 494600) (|FreeModule| "poly.spad" 493634 493654 493881 493886) (|FloatingRealPackage| "numsolve.spad" 491360 491391 493624 493629) (|FloatingComplexPackage| "numsolve.spad" 488779 488813 491350 491355) (|Float| "float.spad" 485843 485854 488621 488774) (|FullyLinearlyExplicitRingOver| "catdef.spad" 485538 485575 485833 485838) (|FullyLinearlyExplicitRingOver&| "catdef.spad" 485162 485202 485460 485465) (|FiniteLinearAggregateSort| "defaults.spad" 484465 484500 485152 485157) (|FreeLieAlgebra| "xlpoly.spad" 482437 482468 484455 484460) (|FiniteLinearAggregateFunctions2| "aggcat2.spad" 481125 481170 482427 482432) (|FiniteLinearAggregate| "aggcat.spad" 478182 478211 481115 481120) (|FiniteLinearAggregate&| "aggcat.spad" 475065 475097 478001 478006) (|FiniteRankAlgebra| "algcat.spad" 473169 473197 475055 475060) (|FiniteRankAlgebra&| "algcat.spad" 471126 471157 473015 473020) (|Finite| "catdef.spad" 470274 470286 471116 471121) (|Finite&| "catdef.spad" 469419 469434 470264 470269) (|FiniteAggregate| "aggcat.spad" 466131 466154 469409 469414) (|FiniteAggregate&| "aggcat.spad" 462799 462825 466080 466085) (|FiniteRankNonAssociativeAlgebra| "naalgc.spad" 452352 452391 462789 462794) (|FiniteRankNonAssociativeAlgebra&| "naalgc.spad" 441856 441898 452296 452301) (|FileCategory| "files.spad" 440380 440407 441846 441851) (|File| "files.spad" 439961 439973 440370 440375) (|Field| "catdef.spad" 439453 439464 439876 439956) (|Field&| "catdef.spad" 439017 439031 439443 439448) (|FreeGroup| "free.spad" 437683 437700 439007 439012) (|FGLMIfCanPackage| "zerodim.spad" 436464 436493 437673 437678) (|FiniteFieldExtension| "ffp.spad" 435864 435897 436215 436295) (|FiniteFieldSolveLinearPolynomialEquation| "ffcat.spad" 435341 435396 435854 435859) (|FiniteFieldPolynomialPackage2| "ffpoly2.spad" 434378 434418 435331 435336) (|FiniteFieldPolynomialPackage| "ffpoly.spad" 425694 425731 434368 434373) (|FiniteFieldExtensionByPolynomial| "ffp.spad" 425104 425154 425445 425525) (|FiniteFieldNormalBasisExtension| "ffnb.spad" 423630 423679 424855 424935) (|FiniteFieldNormalBasisExtensionByPolynomial| "ffnb.spad" 422145 422203 423381 423461) (|FiniteFieldNormalBasis| "ffnb.spad" 420644 420685 421880 421960) (|FunctionFieldIntegralBasis| "intclos.spad" 418138 418177 420634 420639) (|FiniteFieldCategory| "ffcat.spad" 415719 415744 418053 418133) (|FiniteFieldCategory&| "ffcat.spad" 413372 413400 415709 415714) (|FiniteFieldHomomorphisms| "ffhom.spad" 412122 412161 413362 413367) (|FiniteFieldFunctions| "fff.spad" 409547 409576 412112 412117) (|FiniteFieldCyclicGroupExtension| "ffcg.spad" 408408 408457 409298 409378) (|FiniteFieldCyclicGroupExtensionByPolynomial| "ffcg.spad" 407299 407360 408159 408239) (|FiniteFieldCyclicGroup| "ffcg.spad" 406125 406166 407034 407114) (|FunctionFieldCategoryFunctions2| "curve.spad" 405843 405912 406115 406120) (|FunctionFieldCategory| "curve.spad" 399006 399043 405695 405838) (|FunctionFieldCategory&| "curve.spad" 392227 392267 398919 398924) (|FiniteField| "ffp.spad" 391720 391745 391962 392042) (|FullyEvalableOver| "equation2.spad" 391542 391567 391710 391715) (|FullyEvalableOver&| "equation2.spad" 391156 391184 391327 391332) (|FiniteDivisorCategory| "divisor.spad" 389237 389276 391146 391151) (|FiniteDivisorCategory&| "divisor.spad" 387315 387357 389227 389232) (|FiniteDivisorFunctions2| "divisor.spad" 386950 387011 387305 387310) (|FiniteDivisor| "divisor.spad" 386401 386432 386940 386945) (|FunctorData| "domain.spad" 385400 385417 386391 386396) (|FourierComponent| "fourier.spad" 384765 384789 385390 385395) (|FiniteAlgebraicExtensionField| "ffcat.spad" 377790 377827 384680 384760) (|FiniteAlgebraicExtensionField&| "ffcat.spad" 370849 370889 377742 377747) (|FlexibleArray| "array1.spad" 369199 369220 370243 370248) (|FiniteAbelianMonoidRing| "polycat.spad" 367314 367347 369089 369194) (|FiniteAbelianMonoidRing&| "polycat.spad" 365388 365424 367166 367171) (|FreeAbelianMonoid| "free.spad" 365023 365048 365308 365313) (|FreeAbelianMonoidCategory| "free.spad" 363320 363355 365013 365018) (|FreeAbelianGroup| "free.spad" 362937 362961 363207 363212) (|FactoringUtilities| "facutil.spad" 361133 361166 362927 362932) (|FactoredFunctions| "manip.spad" 360320 360345 361123 361128) (|ExponentialOfUnivariatePuiseuxSeries| "expexpan.spad" 357665 357722 358998 359148) (|ExpressionTubePlot| "tube.spad" 354937 354961 357655 357660) (|ExpressionSpaceODESolver| "exprode.spad" 352087 352121 354927 354932) (|ExpressionToUnivariatePowerSeries| "expr2ups.spad" 348178 348222 352077 352082) (|ExpressionFunctions2| "expr.spad" 347865 347895 348168 348173) (|Expression| "expr.spad" 345573 345591 346295 346434) (|ExponentialExpansion| "expexpan.spad" 343205 343248 343855 343935) (|ExitAst| "syntax.spad" 342936 342949 343195 343200) (|Exit| "void.spad" 342605 342615 342926 342931) (|EvaluateCycleIndicators| "cycles.spad" 342048 342079 342595 342600) (|Evalable| "equation1.spad" 341622 341638 342038 342043) (|Evalable&| "equation1.spad" 341193 341212 341612 341617) (|EuclideanDomain| "catdef.spad" 338787 338808 341136 341188) (|EuclideanDomain&| "catdef.spad" 336425 336449 338777 338782) (|ExpressionSpaceFunctions2| "fspace.spad" 335919 335954 336415 336420) (|ExpressionSpaceFunctions1| "fspace.spad" 335470 335505 335909 335914) (|ExpressionSpace| "fspace.spad" 328328 328349 335460 335465) (|ExpressionSpace&| "fspace.spad" 321088 321112 328223 328228) (|ErrorFunctions| "error.spad" 318403 318423 321078 321083) (|EqTable| "table.spad" 317265 317292 317479 317484) (|EquationFunctions2| "equation2.spad" 316967 316995 317255 317260) (|Equation| "equation2.spad" 313334 313350 315998 316003) (|EigenPackage| "eigen.spad" 309650 309670 313324 313329) (|Environment| "any.spad" 308319 308336 309640 309645) (|EntireRing| "catdef.spad" 308004 308020 308288 308314) (|EntireRing&| "catdef.spad" 307707 307726 307994 307999) (|EuclideanModularRing| "modring.spad" 307114 307181 307650 307702) (|EltableAggregate| "aggcat.spad" 305354 305387 307104 307109) (|EltableAggregate&| "aggcat.spad" 303507 303543 305260 305265) (|Eltable| "aggcat.spad" 302977 302995 303497 303502) (|EllipticFunctionsUnivariateTaylorSeries| "elfuts.spad" 302375 302431 302967 302972) (|ElementaryFunctionCategory| "trigcat.spad" 302040 302072 302365 302370) (|ElementaryFunctionCategory&| "trigcat.spad" 301702 301737 302030 302035) (|ExtensibleLinearAggregate| "aggcat.spad" 299660 299693 301692 301697) (|ExtensibleLinearAggregate&| "aggcat.spad" 297530 297566 299565 299570) (|Elaboration| "compiler.spad" 296867 296884 297520 297525) (|ElaboratedExpression| "syntax.spad" 295781 295807 296857 296862) (|ElementaryFunctionsUnivariatePuiseuxSeries| "efupxs.spad" 292514 292584 295734 295739) (|ElementaryFunctionsUnivariateLaurentSeries| "efuls.spad" 289307 289370 292467 292472) (|ElementaryFunctionStructurePackage| "efstruc.spad" 287294 287338 289297 289302) (|ElementaryFunction| "elemntry.spad" 282058 282086 287284 287289) (|ExtAlgBasis| "derham.spad" 280349 280366 282048 282053) (|DifferentialVariableCategory| "dpolcat.spad" 277329 277365 280339 280344) (|DifferentialVariableCategory&| "dpolcat.spad" 274306 274345 277319 277324) (|DifferentialSparseMultivariatePolynomial| "dpolcat.spad" 272272 272324 272615 272789) (|DifferentialSpaceExtension| "catdef.spad" 271550 271584 272262 272267) (|DifferentialSpaceExtension&| "catdef.spad" 270707 270744 271422 271427) (|DrawOptionFunctions1| "drawopt.spad" 270354 270382 270697 270702) (|DrawOptionFunctions0| "drawopt.spad" 265201 265227 270344 270349) (|DrawOption| "drawopt.spad" 259152 259168 265191 265196) (|TopLevelDrawFunctionsForPoints| "draw.spad" 257297 257333 259142 259147) (|DrawNumericHack| "numeric.spad" 256592 256615 257287 257292) (|DrawComplex| "drawpak.spad" 254061 254078 256582 256587) (|TopLevelDrawFunctionsForAlgebraicCurves| "draw.spad" 253571 253623 254051 254056) (|TopLevelDrawFunctionsForCompiledFunctions| "draw.spad" 243064 243111 253561 253566) (|TopLevelDrawFunctions| "draw.spad" 235921 235953 243054 243059) (|DequeueAggregate| "aggcat.spad" 234107 234131 235911 235916) (|DifferentialPolynomialCategory| "dpolcat.spad" 229389 229433 233928 234102) (|DifferentialPolynomialCategory&| "dpolcat.spad" 224789 224836 229331 229336) (|DirectProductModule| "lodop.spad" 222352 222385 222507 222512) (|DirectProductMatrixModule| "lodop.spad" 219922 219963 220070 220075) (|DomainTemplate| "domain.spad" 219681 219701 219912 219917) (|DomainConstructor| "domain.spad" 219421 219444 219671 219676) (|Domain| "domain.spad" 218528 218540 219411 219416) (|DistributedMultivariatePolynomial| "gdpoly.spad" 216447 216493 217048 217222) (|DifferentialModuleExtension| "catdef.spad" 216311 216346 216437 216442) (|DiscreteLogarithmPackage| "ffcat.spad" 215649 215681 216301 216306) (|DataList| "alql.spad" 214433 214449 215043 215048) (|DoublyLinkedAggregate| "aggcat.spad" 212831 212860 214423 214428) (|DivisionRing| "catdef.spad" 212388 212406 212800 212826) (|DivisionRing&| "catdef.spad" 211963 211984 212378 212383) (|DisplayPackage| "out.spad" 210141 210161 211953 211958) (|DirectProductFunctions2| "vector.spad" 208938 208977 210131 210136) (|DirectProduct| "vector.spad" 205555 205582 206206 206211) (|DirectProductCategory| "vector.spad" 204911 204946 205545 205550) (|DirectProductCategory&| "vector.spad" 203712 203750 204349 204354) (|DiophantineSolutionPackage| "solvedio.spad" 202513 202545 203702 203707) (|DictionaryOperations| "aggcat.spad" 201501 201529 202503 202508) (|DictionaryOperations&| "aggcat.spad" 200412 200443 201417 201422) (|Dioid| "catdef.spad" 200267 200278 200402 200407) (|DifferentialRing| "catdef.spad" 200101 200123 200257 200262) (|DifferentialSpace| "catdef.spad" 199665 199688 200091 200096) (|DifferentialSpace&| "catdef.spad" 199226 199252 199655 199660) (|DifferentialModule| "catdef.spad" 198721 198747 199216 199221) (|DifferentialDomain| "catdef.spad" 197870 197897 198711 198716) (|DifferentialDomain&| "catdef.spad" 197016 197046 197860 197865) (|DifferentialExtension| "catdef.spad" 196826 196855 197006 197011) (|Dictionary| "aggcat.spad" 196458 196476 196816 196821) (|Dictionary&| "aggcat.spad" 196087 196108 196448 196453) (|DenavitHartenbergMatrix| "dhmatrix.spad" 194481 194512 195647 195652) (|DoubleFloatSpecialFunctions| "special.spad" 188096 188129 194471 194476) (|DoubleFloat| "sf.spad" 184699 184716 187991 188091) (|DefiniteIntegrationTools| "defintrf.spad" 182912 182946 184689 184694) (|DeRhamComplex| "derham.spad" 180998 181041 182902 182907) (|Dequeue| "bags.spad" 180456 180471 180744 180749) (|DegreeReductionPackage| "degred.spad" 180053 180087 180446 180451) (|RationalFunctionDefiniteIntegration| "defintrf.spad" 177602 177645 180043 180048) (|ElementaryFunctionDefiniteIntegration| "defintef.spad" 176109 176156 177592 177597) (|DefinitionAst| "syntax.spad" 175482 175501 176099 176104) (|DecimalExpansion| "radix.spad" 173645 173667 174020 174100) (|DistinctDegreeFactorize| "ddfact.spad" 171449 171483 173635 173640) (|DoubleResultantPackage| "intalg.spad" 171033 171073 171439 171444) (|DualBasis| "vector.spad" 170652 170674 171023 171028) (|Database| "alql.spad" 169310 169326 170642 170647) (|DataArray| "data.spad" 168789 168809 169300 169305) (|CyclotomicPolynomialPackage| "cyclotom.spad" 168270 168303 168779 168784) (|CycleIndicators| "cycles.spad" 165040 165061 168260 168265) (|CoerceVectorMatrixPackage| "generic.spad" 164434 164467 165030 165035) (|ComplexTrigonometricManipulations| "efstruc.spad" 162907 162950 164424 164429) (|ConstructorKind| "domain.spad" 162497 162518 162897 162902) (|ConstructorCategory| "domain.spad" 161721 161746 162487 162492) (|ConstructorCategory&| "domain.spad" 160942 160970 161711 161716) (|ConstructorCall| "domain.spad" 160518 160541 160932 160937) (|Constructor| "domain.spad" 160200 160217 160508 160513) (|CyclicStreamTools| "stream.spad" 159430 159458 160190 160195) (|ComplexRootFindingPackage| "crfp.spad" 153179 153215 159420 159425) (|CoerceAst| "syntax.spad" 152892 152907 153169 153174) (|CRApackage| "cra.spad" 151951 151969 152882 152887) (|ComplexPatternMatch| "gaussian.spad" 151413 151445 151851 151856) (|CharacteristicPolynomialInMonogenicalAlgebra| "algcat.spad" 151076 151137 151403 151408) (|CoordinateSystems| "coordsys.spad" 146070 146095 151066 151071) (|Contour| "any.spad" 145492 145505 146060 146065) (|ContinuedFraction| "contfrac.spad" 141240 141265 145407 145487) (|Conduit| "net.spad" 140993 141006 141230 141235) (|CommutativeRing| "catdef.spad" 140682 140703 140959 140988) (|SubSpaceComponentProperty| "newpoint.spad" 140177 140208 140672 140677) (|ComplexPattern| "gaussian.spad" 139932 139959 140167 140172) (|ComplexFunctions2| "gaussian.spad" 139632 139659 139922 139927) (|Complex| "gaussian.spad" 136844 136859 137093 137467) (|CompilerPackage| "compiler.spad" 136380 136401 136834 136839) (|ComplexFactorization| "gaussian.spad" 135964 135996 136370 136375) (|ComplexCategory| "gaussian.spad" 133910 133933 135585 135959) (|ComplexCategory&| "gaussian.spad" 131487 131513 133165 133170) (|CommutativeOperatorCategory| "catdef.spad" 131209 131245 131347 131482) (|CommutativeOperation| "catdef.spad" 130781 130810 131069 131204) (|CommuteUnivariatePolynomialCategory| "polycat.spad" 130496 130547 130771 130776) (|CommonOperators| "op.spad" 130016 130037 130486 130491) (|CommaAst| "syntax.spad" 129773 129787 130006 130011) (|Commutator| "fnla.spad" 129576 129592 129763 129768) (|CombinatorialOpsCategory| "combfunc.spad" 128477 128507 129566 129571) (|IntegerCombinatoricFunctions| "combinat.spad" 127218 127254 128467 128472) (|CombinatorialFunction| "combfunc.spad" 124625 124656 127208 127213) (|Color| "color.spad" 123459 123470 124615 124620) (|ColonAst| "syntax.spad" 123119 123133 123449 123454) (|ComplexRootPackage| "cmplxrt.spad" 122814 122847 123109 123114) (|CollectAst| "syntax.spad" 122468 122484 122804 122809) (|TwoDimensionalPlotClipping| "clip.spad" 118552 118584 122458 122463) (|CliffordAlgebra| "clifford.spad" 117379 117408 118542 118547) (|Collection| "aggcat.spad" 115577 115595 117369 117374) (|Collection&| "aggcat.spad" 113594 113615 115389 115394) (|ComplexIntegerSolveLinearPolynomialEquation| "gaussian.spad" 112908 112962 113584 113589) (|ChangeOfVariable| "curve.spad" 111036 111068 112898 112903) (|CharacteristicZero| "catdef.spad" 110945 110969 111026 111031) (|CharacteristicPolynomialPackage| "eigen.spad" 110442 110481 110935 110940) (|CharacteristicNonZero| "catdef.spad" 110195 110222 110432 110437) (|Character| "string.spad" 107556 107571 110185 110190) (|CombinatorialFunctionCategory| "trigcat.spad" 106857 106892 107546 107551) (|CommonDenominator| "cden.spad" 106062 106091 106847 106852) (|CharacterClass| "string.spad" 104294 104314 105568 105599) (|Category| "domain.spad" 103362 103376 104284 104289) (|CategoryConstructor| "domain.spad" 103236 103261 103352 103357) (|CategoryAst| "syntax.spad" 102853 102870 103226 103231) (|CaseAst| "syntax.spad" 102562 102575 102843 102848) (|CartesianTensorFunctions2| "carten.spad" 101929 101979 102552 102557) (|CartesianTensor| "carten.spad" 97668 97705 101919 101924) (|CardinalNumber| "card.spad" 94943 94963 97634 97663) (|CapsuleAst| "syntax.spad" 94717 94733 94933 94938) (|CachableSet| "kl.spad" 94332 94349 94707 94712) (|CancellationAbelianMonoid| "catdef.spad" 93868 93899 94322 94327) (|ByteOrder| "data.spad" 93536 93551 93858 93863) (|ByteBuffer| "data.spad" 91756 91772 92970 92975) (|Byte| "data.spad" 91229 91239 91746 91751) (|BinaryTree| "tree.spad" 90362 90380 90904 90909) (|BinaryTournament| "tree.spad" 89421 89445 90037 90042) (|BinaryTreeCategory| "tree.spad" 88984 89010 89411 89416) (|BinaryTreeCategory&| "tree.spad" 88544 88573 88974 88979) (|BitAggregate| "aggcat.spad" 88022 88040 88534 88539) (|BitAggregate&| "aggcat.spad" 87497 87518 88012 88017) (|BinarySearchTree| "tree.spad" 86292 86316 87172 87177) (|BrillhartTests| "brill.spad" 84485 84508 86282 86287) (|BinaryRecursiveAggregate| "aggcat.spad" 83419 83451 84475 84480) (|BinaryRecursiveAggregate&| "aggcat.spad" 82266 82301 83325 83330) (|BalancedPAdicRational| "padic.spad" 80412 80443 80678 80758) (|BalancedPAdicInteger| "padic.spad" 80083 80113 80355 80407) (|BoundIntegerRoots| "oderf.spad" 79728 79756 80073 80078) (|BasicOperatorFunctions1| "op.spad" 77165 77196 79718 79723) (|BasicOperator| "op.spad" 72296 72315 77155 77160) (|Boolean| "boolean.spad" 71839 71852 72286 72291) (|BooleanLogic| "logic.spad" 71479 71497 71829 71834) (|BooleanLogic&| "logic.spad" 71116 71137 71469 71474) (|BiModule| "catdef.spad" 70949 70967 71106 71111) (|Bits| "boolean.spad" 70222 70232 70439 70444) (|BinaryOperatorCategory| "catdef.spad" 70084 70115 70212 70217) (|BinaryOperation| "catdef.spad" 69821 69845 70074 70079) (|Binding| "any.spad" 69237 69250 69811 69816) (|BinaryExpansion| "radix.spad" 67406 67427 67775 67855) (|BagAggregate| "aggcat.spad" 66725 66745 67396 67401) (|BagAggregate&| "aggcat.spad" 66041 66064 66715 66720) (|BezoutMatrix| "bezout.spad" 65163 65200 65983 65988) (|BalancedBinaryTree| "tree.spad" 62092 62118 64838 64843) (|BasicType| "catdef.spad" 61584 61599 62082 62087) (|BasicType&| "catdef.spad" 61073 61091 61574 61579) (|BalancedFactorisation| "oderf.spad" 60513 60545 61063 61068) (|Automorphism| "ore.spad" 59963 59983 60503 60508) (|AttributeRegistry| "attreg.spad" 58271 58294 59774 59958) (|AttributeAst| "syntax.spad" 57977 57995 58261 58266) (|ArcTrigonometricFunctionCategory| "trigcat.spad" 57416 57454 57967 57972) (|ArcTrigonometricFunctionCategory&| "trigcat.spad" 56852 56893 57406 57411) (|AbstractSyntaxCategory| "syntax.spad" 56735 56763 56842 56847) (|AbstractSyntaxCategory&| "syntax.spad" 56615 56646 56725 56730) (|ArrayStack| "bags.spad" 56084 56102 56361 56366) (|AssociatedEquations| "lodof.spad" 54897 54926 56037 56042) (|TwoDimensionalArray| "array2.spad" 54476 54503 54643 54648) (|OneDimensionalArrayFunctions2| "array1.spad" 53161 53200 54466 54471) (|OneDimensionalArray| "array1.spad" 52191 52218 52555 52560) (|TwoDimensionalArrayCategory| "array2.spad" 48474 48521 52181 52186) (|TwoDimensionalArrayCategory&| "array2.spad" 44754 44804 48464 48469) (|Arity| "term.spad" 44122 44133 44744 44749) (|ApplyRules| "rule.spad" 43401 43428 44112 44117) (|ApplyUnivariateSkewPolynomial| "ore.spad" 42992 43033 43391 43396) (|AnyFunctions1| "any.spad" 42051 42072 42982 42987) (|Any| "any.spad" 40900 40909 42041 42046) (|AntiSymm| "derham.spad" 39476 39499 40890 40895) (|AnonymousFunction| "variable.spad" 39169 39192 39466 39471) (|AlgebraicNumber| "constant.spad" 37618 37639 38995 39075) (|AbelianMonoidRing| "polycat.spad" 35924 35951 37508 37613) (|AbelianMonoidRing&| "polycat.spad" 34020 34050 35607 35612) (|AssociationList| "list.spad" 32544 32579 32908 32913) (|AlgebraGivenByStructuralConstants| "naalg.spad" 31680 31738 32449 32454) (|AlgebraPackage| "naalg.spad" 27437 27461 31623 31628) (|AlgebraicMultFact| "multfact.spad" 26614 26644 27427 27432) (|AlgebraicManipulations| "manip.spad" 24064 24096 26424 26429) (|AlgebraicFunctionField| "curve.spad" 22804 22852 23042 23174) (|AlgFactor| "algfact.spad" 21915 21933 22794 22799) (|Algebra| "catdef.spad" 21776 21791 21905 21910) (|Algebra&| "catdef.spad" 21634 21652 21766 21771) (|AssociationListAggregate| "aggcat.spad" 21149 21193 21624 21629) (|ArcHyperbolicFunctionCategory| "trigcat.spad" 20502 20537 21139 21144) (|Aggregate| "aggcat.spad" 19401 19416 20492 20497) (|Aggregate&| "aggcat.spad" 18297 18315 19391 19396) (|AlgebraicFunction| "algfunc.spad" 16714 16741 18230 18235) (|AddAst| "syntax.spad" 16395 16407 16704 16709) (|PlaneAlgebraicCurvePlot| "acplot.spad" 15250 15279 16385 16390) (|AlgebraicallyClosedFunctionSpace| "algfunc.spad" 13089 13129 15165 15245) (|AlgebraicallyClosedFunctionSpace&| "algfunc.spad" 11000 11043 13079 13084) (|AlgebraicallyClosedField| "algfunc.spad" 7744 7774 10915 10995) (|AlgebraicallyClosedField&| "algfunc.spad" 4560 4593 7734 7739) (|AbelianSemiGroup| "catdef.spad" 4086 4108 4550 4555) (|AbelianSemiGroup&| "catdef.spad" 3609 3634 4076 4081) (|AbelianMonoid| "catdef.spad" 3025 3044 3599 3604) (|AbelianMonoid&| "catdef.spad" 2438 2460 3015 3020) (|AbelianGroup| "catdef.spad" 2092 2110 2428 2433) (|AbelianGroup&| "catdef.spad" 1743 1764 2082 2087) (|OneDimensionalArrayAggregate| "aggcat.spad" 888 924 1733 1738) (|OneDimensionalArrayAggregate&| "aggcat.spad" 30 69 878 883)) 
+\ No newline at end of file
author	Gabriel Dos Reis <gdr@axiomatics.org>	2016-01-17 22:53:01 -0800
committer	Gabriel Dos Reis <gdr@axiomatics.org>	2016-01-17 22:53:01 -0800
commit	d07fc9735f40e545edda456e15dbab783c500f6a (patch)
tree	4d9fab82a7085b73a4b00d23389935503fdfc90d /src/share/algebra/browse.daase
parent	5437d438937eb25eb320fef6e4fd6ebc91ca6dc9 (diff)
download	open-axiom-d07fc9735f40e545edda456e15dbab783c500f6a.tar.gz