diff --git a/books/bookvol10.2.pamphlet b/books/bookvol10.2.pamphlet index c479832..64191ed 100644 --- a/books/bookvol10.2.pamphlet +++ b/books/bookvol10.2.pamphlet @@ -790,6 +790,7 @@ digraph pic { \pagepic{ps/v102combinatorialfunctioncategory.ps}{CFCAT}{1.00} {\bf See:}\\ +\pageto{CombinatorialOpsCategory}{COMBOPC} \pagefrom{Category}{CATEGORY} {\bf Exports:}\\ @@ -1224,6 +1225,7 @@ digraph pic { {\bf See:}\\ \pageto{Evalable}{EVALAB} +\pageto{ExpressionSpace}{ES} \pageto{PolynomialCategory}{POLYCAT} \pagefrom{Category}{CATEGORY} @@ -1306,6 +1308,7 @@ InnerEvalable(A:SetCategory, B:Type): Category == with [color=seagreen,href="bookvol10.2.pdf#nameddest=IEVALAB"]; "InnerEvalable(Kernal(ExpressionSpace),ExpressionSpace)" -> "InnerEvalable(a:SetCategory,b:Type)" + @ <>= digraph pic { @@ -1401,6 +1404,7 @@ digraph pic { \pagepic{ps/v102patternable.ps}{PATAB}{1.00} {\bf See:}\\ +\pageto{QuotientFieldCategory}{QFCAT} \pagefrom{Category}{CATEGORY} {\bf Exports:}\\ @@ -1447,6 +1451,10 @@ Patternable(R:Type): Category == with [color=lightblue,href="bookvol10.2.pdf#nameddest=PATAB"]; "Patternable(a:Type)" -> "Category" +"Patternable(IntegralDomain)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=PATAB"]; +"Patternable(IntegralDomain)" -> "Patternable(a:Type)" + @ <>= digraph pic { @@ -1599,13 +1607,17 @@ digraph pic { \pagepic{ps/v102retractableto.ps}{RETRACT}{1.00} {\bf See:}\\ +\pageto{DifferentialPolynomialCategory}{DPOLCAT} +\pageto{DifferentialVariableCategory}{DVARCAT} \pageto{ExtensionField}{XF} +\pageto{ExpressionSpace}{ES} \pageto{FiniteAlgebraicExtensionField}{FAXF} \pageto{FortranMachineTypeCategory}{FMTC} \pageto{FreeModuleCat}{FMCAT} \pageto{FullyRetractableTo}{FRETRCT} \pageto{GradedAlgebra}{GRALG} \pageto{PolynomialCategory}{POLYCAT} +\pageto{QuotientFieldCategory}{QFCAT} \pageto{RealNumberSystem}{RNS} \pageto{XFreeAlgebra}{XFALG} \pagefrom{Category}{CATEGORY} @@ -1704,6 +1716,10 @@ RetractableTo(S: Type): Category == with [color=seagreen,href="bookvol10.2.pdf#nameddest=RETRACT"]; "RetractableTo(Field)" -> "RetractableTo(a:Type)" +"RetractableTo(IntegralDomain)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=RETRACT"]; +"RetractableTo(IntegralDomain)" -> "RetractableTo(a:Type)" + "RetractableTo(OrderedFreeMonoid(OrderedSet))" [color=seagreen,href="bookvol10.2.pdf#nameddest=RETRACT"]; "RetractableTo(OrderedFreeMonoid(OrderedSet))" -> "RetractableTo(a:Type)" @@ -2079,6 +2095,99 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{CombinatorialOpsCategory}{COMBOPC} +\pagepic{ps/v102combinatorialopscategory.ps}{COMBOPC}{1.00} + +{\bf See:}\\ +\pagefrom{CombinatorialFunctionCategory}{CFCAT} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{COMBOPC}{binomial} & +\cross{COMBOPC}{factorial} & +\cross{COMBOPC}{factorials} & +\cross{COMBOPC}{permutation} & +\cross{COMBOPC}{product} \\ +\cross{COMBOPC}{summation} & +\end{tabular} + +These are directly exported but not implemented: +\begin{verbatim} + factorials : % -> % + factorials : (%,Symbol) -> % + product : (%,Symbol) -> % + product : (%,SegmentBinding %) -> % + summation : (%,Symbol) -> % + summation : (%,SegmentBinding %) -> % +\end{verbatim} + +These exports come from \refto{CombinatorialFunctionCategory}(): +\begin{verbatim} + binomial : (%,%) -> % + factorial : % -> % + permutation : (%,%) -> % +\end{verbatim} + +<>= +)abbrev category COMBOPC CombinatorialOpsCategory +++ Category for summations and products +++ Author: Manuel Bronstein +++ Date Created: ??? +++ Date Last Updated: 22 February 1993 (JHD/BMT) +++ Description: +++ CombinatorialOpsCategory is the category obtaining by adjoining +++ summations and products to the usual combinatorial operations; +CombinatorialOpsCategory(): Category == + CombinatorialFunctionCategory with + factorials : $ -> $ + ++ factorials(f) rewrites the permutations and binomials in f + ++ in terms of factorials; + factorials : ($, Symbol) -> $ + ++ factorials(f, x) rewrites the permutations and binomials in f + ++ involving x in terms of factorials; + summation : ($, Symbol) -> $ + ++ summation(f(n), n) returns the formal sum S(n) which verifies + ++ S(n+1) - S(n) = f(n); + summation : ($, SegmentBinding $) -> $ + ++ summation(f(n), n = a..b) returns f(a) + ... + f(b) as a + ++ formal sum; + product : ($, Symbol) -> $ + ++ product(f(n), n) returns the formal product P(n) which verifies + ++ P(n+1)/P(n) = f(n); + product : ($, SegmentBinding $) -> $ + ++ product(f(n), n = a..b) returns f(a) * ... * f(b) as a + ++ formal product; + +@ +<>= +"COMBOPC" + [color=lightblue,href="bookvol10.2.pdf#nameddest=COMBOPC"]; +"COMBOPC" -> "CFCAT" + +@ +<>= +"CombinatorialOpsCategory()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=COMBOPC"]; +"CombinatorialOpsCategory()" -> "CombinatorialFunctionCategory()" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"CombinatorialOpsCategory()" [color=lightblue]; +"CombinatorialOpsCategory()" -> "CombinatorialFunctionCategory()" + +"CombinatorialFunctionCategory()" [color=lightblue]; +"CombinatorialFunctionCategory()" -> "Category" + +"Category" [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{RealConstant}{REAL} \pagepic{ps/v102realconstant.ps}{REAL}{1.00} @@ -2087,7 +2196,8 @@ digraph pic { \pagefrom{ConvertibleTo}{KONVERT} {\bf Exports:}\\ -\begin{tabular}{lllll} +\begin{tabular}{l} +\cross{REAL}{convert} \end{tabular} These exports come from \refto{ConvertibleTo}(DoubleFloat): @@ -2278,6 +2388,7 @@ digraph pic { \pagepic{ps/v102evalable.ps}{EVALAB}{1.00} {\bf See:}\\ +\pageto{ExpressionSpace}{ES} \pageto{PolynomialCategory}{POLYCAT} \pagefrom{InnerEvalable}{IEVALAB} @@ -2585,6 +2696,7 @@ digraph pic { \pagepic{ps/v102fullypatternmatchable.ps}{FPATMAB}{1.00} {\bf See:}\\ +\pageto{QuotientFieldCategory}{QFCAT} \pagefrom{Type}{TYPE} {\bf Attributes exported:} @@ -2602,12 +2714,6 @@ digraph pic { \cross{FPATMAB}{?\~{}=?} &&&& \end{tabular} - coerce : % -> OutputForm if R has PATMAB INT or R has PATMAB FLOAT - hash : % -> SingleInteger if R has PATMAB INT or R has PATMAB FLOAT - latex : % -> String if R has PATMAB INT or R has PATMAB FLOAT - ?=? : (%,%) -> Boolean if R has PATMAB INT or R has PATMAB FLOAT - ?~=? : (%,%) -> Boolean if R has PATMAB INT or R has PATMAB FLOAT - These exports come from \refto{PatternMatchable}(Integer): \begin{verbatim} coerce : % -> OutputForm @@ -2668,6 +2774,11 @@ FullyPatternMatchable(R:Type): Category == Type with [color=lightblue,href="bookvol10.2.pdf#nameddest=FPATMAB"]; "FullyPatternMatchable(a:Type)" -> "Type()" +"FullyPatternMatchable(IntegralDomain)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=FPATMAB"]; +"FullyPatternMatchable(IntegralDomain)" -> + "FullyPatternMatchable(a:Type)" + @ <>= digraph pic { @@ -3940,6 +4051,7 @@ digraph pic { \pagepic{ps/v102fullyevalableover.ps}{FEVALAB}{0.75} {\bf See:}\\ +\pageto{QuotientFieldCategory}{QFCAT} \pagefrom{Category}{CATEGORY} {\bf Exports:}\\ @@ -4020,6 +4132,11 @@ FullyEvalableOver(R:SetCategory): Category == with "FullyEvalableOver(a:SetCategory)" -> "Evalable(a:SetCategory)" "FullyEvalableOver(a:SetCategory)" -> "Category" +"FullyEvalableOver(IntegralDomain)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=FEVALAB"]; +"FullyEvalableOver(IntegralDomain)" -> + "FullyEvalableOver(a:SetCategory)" + @ <>= digraph pic { @@ -5149,6 +5266,8 @@ digraph pic { {\bf See:}\\ \pageto{BitAggregate}{BTAGG} \pageto{CachableSet}{CACHSET} +\pageto{DifferentialVariableCategory}{DVARCAT} +\pageto{ExpressionSpace}{ES} \pageto{FortranMachineTypeCategory}{FMTC} \pageto{OrderedAbelianSemiGroup}{OASGP} \pageto{OrderedFinite}{ORDFIN} @@ -7041,6 +7160,766 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{DifferentialVariableCategory}{DVARCAT} +\pagepic{ps/v102differentialvariablecategory.ps}{DVARCAT}{1.00} + +{\bf See:}\\ +\pagefrom{OrderedSet}{ORDSET} +\pagefrom{RetractableTo}{RETRACT} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{DVARCAT}{coerce} & +\cross{DVARCAT}{differentiate} & +\cross{DVARCAT}{hash} & +\cross{DVARCAT}{latex} & +\cross{DVARCAT}{makeVariable} \\ +\cross{DVARCAT}{max} & +\cross{DVARCAT}{min} & +\cross{DVARCAT}{order} & +\cross{DVARCAT}{retract} & +\cross{DVARCAT}{retractIfCan} \\ +\cross{DVARCAT}{variable} & +\cross{DVARCAT}{weight} & +\cross{DVARCAT}{?\~{}=?} & +\cross{DVARCAT}{?$<$?} & +\cross{DVARCAT}{?$<=$?} \\ +\cross{DVARCAT}{?=?} & +\cross{DVARCAT}{?$>$?} & +\cross{DVARCAT}{?$>=$?} && +\end{tabular} + +These are directly exported but not implemented: +\begin{verbatim} + makeVariable : (S,NonNegativeInteger) -> % + order : % -> NonNegativeInteger + variable : % -> S +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + coerce : S -> % + coerce : % -> OutputForm + differentiate : % -> % + differentiate : (%,NonNegativeInteger) -> % + retract : % -> S + retractIfCan : % -> Union(S,"failed") + weight : % -> NonNegativeInteger + ? Boolean + ?=? : (%,%) -> Boolean +\end{verbatim} + +These exports come from \refto{OrderedSet}(): +\begin{verbatim} + hash : % -> SingleInteger + latex : % -> String + max : (%,%) -> % + min : (%,%) -> % + ?<=? : (%,%) -> Boolean + ?>? : (%,%) -> Boolean + ?>=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean +\end{verbatim} + +These exports come from \refto{RetractableTo}(S:OrderedSet): +\begin{verbatim} +\end{verbatim} + +<>= +)abbrev category DVARCAT DifferentialVariableCategory +++ Author: William Sit +++ Date Created: 19 July 1990 +++ Date Last Updated: 13 September 1991 +++ Basic Operations: +++ Related Constructors:DifferentialPolynomialCategory +++ See Also:OrderedDifferentialVariable, +++ SequentialDifferentialVariable, +++ DifferentialSparseMultivariatePolynomial. +++ AMS Classifications:12H05 +++ Keywords: differential indeterminates, ranking, order, weight +++ References:Ritt, J.F. "Differential Algebra" (Dover, 1950). +++ Description: +++ \spadtype{DifferentialVariableCategory} constructs the +++ set of derivatives of a given set of +++ (ordinary) differential indeterminates. +++ If x,...,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 +++ x,\spad{x'},\spad{x''},..., y,\spad{y'},\spad{y''},... +++ (Note: in the interpreter, the n-th derivative of y is displayed as +++ y with a subscript 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. +++ +++ 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. +++ +++ 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. +DifferentialVariableCategory(S:OrderedSet): Category == + Join(OrderedSet, RetractableTo S) with + -- Examples: + -- v:=makeVariable('s,5) + makeVariable : (S, NonNegativeInteger) -> $ + ++ makeVariable(s, n) returns the n-th derivative of a + ++ differential indeterminate s as an algebraic indeterminate. + -- Example: makeVariable('s, 5) + order : $ -> NonNegativeInteger + ++ order(v) returns n if v is the n-th derivative of any + ++ differential indeterminate. + -- Example: order(v) + variable : $ -> S + ++ variable(v) returns s if v is any derivative of the differential + ++ indeterminate s. + -- Example: variable(v) + -- default implementation using above primitives -- + + weight : $ -> NonNegativeInteger + ++ weight(v) returns the weight of the derivative v. + -- Example: weight(v) + differentiate : $ -> $ + ++ differentiate(v) returns the derivative of v. + -- Example: differentiate(v) + differentiate : ($, NonNegativeInteger) -> $ + ++ differentiate(v, n) returns the n-th derivative of v. + -- Example: differentiate(v,2) + coerce : S -> $ + ++ coerce(s) returns s, viewed as the zero-th order derivative of s. + -- Example: coerce('s); differentiate(%,5) + add + import NumberFormats + + coerce (s:S):$ == makeVariable(s, 0) + + differentiate v == differentiate(v, 1) + + differentiate(v, n) == makeVariable(variable v, n + order v) + + retractIfCan v == (zero?(order v) => variable v; "failed") + + v = u == (variable v = variable u) and (order v = order u) + + coerce(v:$):OutputForm == + a := variable(v)::OutputForm + zero?(nn := order v) => a + sub(a, outputForm nn) + + retract v == + zero?(order v) => variable v + error "Not retractable" + + v < u == + -- the ranking below is orderly, and is the default -- + order v = order u => variable v < variable u + order v < order u + + weight v == order v + -- the default weight is just the order + +@ +<>= +"DVARCAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=DVARCAT"]; +"DVARCAT" -> "ORDSET" +"DVARCAT" -> "RETRACT" + +@ +<>= +"DifferentialVariableCategory(a:OrderedSet)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=DVARCAT"]; +"DifferentialVariableCategory(a:OrderedSet)" -> "OrderedSet()" +"DifferentialVariableCategory(a:OrderedSet)" -> "RetractableTo(OrderedSet)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"DifferentialVariableCategory(a:OrderedSet)" [color=lightblue]; +"DifferentialVariableCategory(a:OrderedSet)" -> "OrderedSet()" +"DifferentialVariableCategory(a:OrderedSet)" -> "RetractableTo(OrderedSet)" + +"RetractableTo(OrderedSet)" [color=seagreen]; +"RetractableTo(OrderedSet)" -> "RetractableTo(a:Type)" + +"RetractableTo(a:Type)" [color=lightblue]; +"RetractableTo(a:Type)" -> "Category" + +"OrderedSet()" [color=lightblue]; +"OrderedSet()" -> "SetCategory()" + +"SetCategory()" [color=lightblue]; +"SetCategory()" -> "BasicType()" +"SetCategory()" -> "CoercibleTo(OutputForm)" + +"BasicType()" [color=lightblue]; +"BasicType()" -> "Category" + +"CoercibleTo(OutputForm)" [color=seagreen]; +"CoercibleTo(OutputForm)" -> "CoercibleTo(a:Type)" + +"CoercibleTo(a:Type)" [color=lightblue]; +"CoercibleTo(a:Type)" -> "Category" + +"Category" [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{ExpressionSpace}{ES} +\pagepic{ps/v102expressionspace.ps}{ES}{0.35} + +{\bf See:}\\ +\pagefrom{Evalable}{EVALAB} +\pagefrom{InnerEvalable}{IEVALAB} +\pagefrom{OrderedSet}{ORDSET} +\pagefrom{RetractableTo}{RETRACT} + +{\bf Exports:}\\ +\begin{tabular}{llll} +\cross{ES}{belong?} & +\cross{ES}{box} & +\cross{ES}{coerce} & +\cross{ES}{definingPolynomial} \\ +\cross{ES}{distribute} & +\cross{ES}{elt} & +\cross{ES}{eval} & +\cross{ES}{even?} \\ +\cross{ES}{freeOf?} & +\cross{ES}{hash} & +\cross{ES}{height} & +\cross{ES}{is?} \\ +\cross{ES}{kernel} & +\cross{ES}{kernels} & +\cross{ES}{latex} & +\cross{ES}{mainKernel} \\ +\cross{ES}{map} & +\cross{ES}{max} & +\cross{ES}{min} & +\cross{ES}{minPoly} \\ +\cross{ES}{odd?} & +\cross{ES}{operator} & +\cross{ES}{operators} & +\cross{ES}{paren} \\ +\cross{ES}{retract} & +\cross{ES}{retractIfCan} & +\cross{ES}{subst} & +\cross{ES}{tower} \\ +\cross{ES}{?$<$?} & +\cross{ES}{?$<=$?} & +\cross{ES}{?=?} & +\cross{ES}{?$>$?} \\ +\cross{ES}{?$>=$?} & +\cross{ES}{?\~{}=?} && +\end{tabular} + + +These are directly exported but not implemented: +\begin{verbatim} + definingPolynomial : % -> % if $ has RING + eval : (%,List Symbol,List (List % -> %)) -> % + eval : (%,List Kernel %,List %) -> % + eval : (%,List %,List %) -> % + eval : (%,%,%) -> % + eval : (%,Equation %) -> % + eval : (%,Kernel %,%) -> % + kernels : % -> List Kernel % + minPoly : Kernel % -> SparseUnivariatePolynomial % if $ has RING + subst : (%,List Kernel %,List %) -> % +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + belong? : BasicOperator -> Boolean + box : List % -> % + box : % -> % + distribute : % -> % + distribute : (%,%) -> % + elt : (BasicOperator,%,%,%,%) -> % + elt : (BasicOperator,%,%,%) -> % + elt : (BasicOperator,%,%) -> % + elt : (BasicOperator,%) -> % + elt : (BasicOperator,List %) -> % + eval : (%,List Equation %) -> % + eval : (%,Symbol,(% -> %)) -> % + eval : (%,Symbol,(List % -> %)) -> % + eval : (%,BasicOperator,(% -> %)) -> % + eval : (%,BasicOperator,(List % -> %)) -> % + eval : (%,List BasicOperator,List (% -> %)) -> % + eval : (%,List Symbol,List (% -> %)) -> % + eval : (%,List BasicOperator,List (List % -> %)) -> % + even? : % -> Boolean if $ has RETRACT INT + freeOf? : (%,Symbol) -> Boolean + freeOf? : (%,%) -> Boolean + height : % -> NonNegativeInteger + is? : (%,BasicOperator) -> Boolean + is? : (%,Symbol) -> Boolean + kernel : (BasicOperator,%) -> % + kernel : (BasicOperator,List %) -> % + mainKernel : % -> Union(Kernel %,"failed") + map : ((% -> %),Kernel %) -> % + odd? : % -> Boolean if $ has RETRACT INT + operator : BasicOperator -> BasicOperator + operators : % -> List BasicOperator + paren : % -> % + paren : List % -> % + retract : % -> Kernel % + retractIfCan : % -> Union(Kernel %,"failed") + subst : (%,Equation %) -> % + subst : (%,List Equation %) -> % + tower : % -> List Kernel % +\end{verbatim} + +These exports come from \refto{OrderedSet}(): +\begin{verbatim} + coerce : % -> OutputForm + hash : % -> SingleInteger + latex : % -> String + max : (%,%) -> % + min : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ? Boolean + ?>? : (%,%) -> Boolean + ?>=? : (%,%) -> Boolean + ?<=? : (%,%) -> Boolean +\end{verbatim} + +These exports come from \refto{RetractableTo}(a:Type): +\begin{verbatim} + coerce : Kernel % -> % +\end{verbatim} + +These exports come from \refto{InnerEvalable}(a:SetCategory,b:Type): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{Evalable}(a:SetCategory): +\begin{verbatim} +\end{verbatim} + +<>= +)abbrev category ES ExpressionSpace +++ Category for domains on which operators can be applied +++ Author: Manuel Bronstein +++ Date Created: 22 March 1988 +++ Date Last Updated: 27 May 1994 +++ Description: +++ An expression space is a set which is closed under certain operators; +++ Keywords: operator, kernel, expression, space. +ExpressionSpace(): Category == Defn where + N ==> NonNegativeInteger + K ==> Kernel % + OP ==> BasicOperator + SY ==> Symbol + PAREN ==> "%paren"::SY + BOX ==> "%box"::SY + DUMMYVAR ==> "%dummyVar" + + Defn ==> Join(OrderedSet, RetractableTo K, + InnerEvalable(K, %), Evalable %) with + elt : (OP, %) -> % + ++ elt(op,x) or op(x) applies the unary operator op to x. + elt : (OP, %, %) -> % + ++ elt(op,x,y) or op(x, y) applies the binary operator op to x and y. + elt : (OP, %, %, %) -> % + ++ elt(op,x,y,z) or op(x, y, z) applies the ternary operator op + ++ to x, y and z. + elt : (OP, %, %, %, %) -> % + ++ elt(op,x,y,z,t) or op(x, y, z, t) applies the 4-ary operator op + ++ to x, y, z and t. + elt : (OP, List %) -> % + ++ elt(op,[x1,...,xn]) or op([x1,...,xn]) applies the n-ary operator + ++ op to x1,...,xn. + subst : (%, Equation %) -> % + ++ subst(f, k = g) replaces the kernel k by g formally in f. + subst : (%, List Equation %) -> % + ++ subst(f, [k1 = g1,...,kn = gn]) replaces the kernels k1,...,kn + ++ by g1,...,gn formally in f. + subst : (%, List K, List %) -> % + ++ subst(f, [k1...,kn], [g1,...,gn]) replaces the kernels k1,...,kn + ++ by g1,...,gn formally in f. + box : % -> % + ++ box(f) returns f with a 'box' around it that prevents f from + ++ being evaluated when operators are applied to it. For example, + ++ \spad{log(1)} returns 0, but \spad{log(box 1)} + ++ returns the formal kernel log(1). + box : List % -> % + ++ box([f1,...,fn]) returns \spad{(f1,...,fn)} with a 'box' + ++ around them that + ++ prevents the fi from being evaluated when operators are applied to + ++ them, and makes them applicable to a unary operator. For example, + ++ \spad{atan(box [x, 2])} returns the formal kernel \spad{atan(x, 2)}. + paren : % -> % + ++ paren(f) returns (f). This prevents f from + ++ being evaluated when operators are applied to it. For example, + ++ \spad{log(1)} returns 0, but \spad{log(paren 1)} returns the + ++ formal kernel log((1)). + paren : List % -> % + ++ paren([f1,...,fn]) returns \spad{(f1,...,fn)}. This + ++ prevents the fi from being evaluated when operators are applied to + ++ them, and makes them applicable to a unary operator. For example, + ++ \spad{atan(paren [x, 2])} returns the formal + ++ kernel \spad{atan((x, 2))}. + distribute : % -> % + ++ distribute(f) expands all the kernels in f that are + ++ formally enclosed by a \spadfunFrom{box}{ExpressionSpace} + ++ or \spadfunFrom{paren}{ExpressionSpace} expression. + distribute : (%, %) -> % + ++ distribute(f, g) expands all the kernels in f that contain g in their + ++ arguments and that are formally + ++ enclosed by a \spadfunFrom{box}{ExpressionSpace} + ++ or a \spadfunFrom{paren}{ExpressionSpace} expression. + height : % -> N + ++ height(f) returns the highest nesting level appearing in f. + ++ Constants have height 0. Symbols have height 1. For any + ++ operator op and expressions f1,...,fn, \spad{op(f1,...,fn)} has + ++ height equal to \spad{1 + max(height(f1),...,height(fn))}. + mainKernel : % -> Union(K, "failed") + ++ mainKernel(f) returns a kernel of f with maximum nesting level, or + ++ if f has no kernels (i.e. f is a constant). + kernels : % -> List K + ++ kernels(f) returns the list of all the top-level kernels + ++ appearing in f, but not the ones appearing in the arguments + ++ of the top-level kernels. + tower : % -> List K + ++ tower(f) returns all the kernels appearing in f, no matter + ++ what their levels are. + operators : % -> List OP + ++ operators(f) returns all the basic operators appearing in f, + ++ no matter what their levels are. + operator : OP -> OP + ++ operator(op) returns a copy of op with the domain-dependent + ++ properties appropriate for %. + belong? : OP -> Boolean + ++ belong?(op) tests if % accepts op as applicable to its + ++ elements. + is? : (%, OP) -> Boolean + ++ is?(x, op) tests if x is a kernel and is its operator is op. + is? : (%, SY) -> Boolean + ++ is?(x, s) tests if x is a kernel and is the name of its + ++ operator is s. + kernel : (OP, %) -> % + ++ kernel(op, x) constructs op(x) without evaluating it. + kernel : (OP, List %) -> % + ++ kernel(op, [f1,...,fn]) constructs \spad{op(f1,...,fn)} without + ++ evaluating it. + map : (% -> %, K) -> % + ++ map(f, k) returns \spad{op(f(x1),...,f(xn))} where + ++ \spad{k = op(x1,...,xn)}. + freeOf? : (%, %) -> Boolean + ++ freeOf?(x, y) tests if x does not contain any occurrence of y, + ++ where y is a single kernel. + freeOf? : (%, SY) -> Boolean + ++ freeOf?(x, s) tests if x does not contain any operator + ++ whose name is s. + eval : (%, List SY, List(% -> %)) -> % + ++ eval(x, [s1,...,sm], [f1,...,fm]) replaces + ++ every \spad{si(a)} in x by \spad{fi(a)} for any \spad{a}. + eval : (%, List SY, List(List % -> %)) -> % + ++ eval(x, [s1,...,sm], [f1,...,fm]) replaces + ++ every \spad{si(a1,...,an)} in x by + ++ \spad{fi(a1,...,an)} for any \spad{a1},...,\spad{an}. + eval : (%, SY, List % -> %) -> % + ++ eval(x, s, f) replaces every \spad{s(a1,..,am)} in x + ++ by \spad{f(a1,..,am)} for any \spad{a1},...,\spad{am}. + eval : (%, SY, % -> %) -> % + ++ eval(x, s, f) replaces every \spad{s(a)} in x by \spad{f(a)} + ++ for any \spad{a}. + eval : (%, List OP, List(% -> %)) -> % + ++ eval(x, [s1,...,sm], [f1,...,fm]) replaces + ++ every \spad{si(a)} in x by \spad{fi(a)} for any \spad{a}. + eval : (%, List OP, List(List % -> %)) -> % + ++ eval(x, [s1,...,sm], [f1,...,fm]) replaces + ++ every \spad{si(a1,...,an)} in x by + ++ \spad{fi(a1,...,an)} for any \spad{a1},...,\spad{an}. + eval : (%, OP, List % -> %) -> % + ++ eval(x, s, f) replaces every \spad{s(a1,..,am)} in x + ++ by \spad{f(a1,..,am)} for any \spad{a1},...,\spad{am}. + eval : (%, OP, % -> %) -> % + ++ eval(x, s, f) replaces every \spad{s(a)} in x by \spad{f(a)} + ++ for any \spad{a}. + if % has Ring then + minPoly: K -> SparseUnivariatePolynomial % + ++ minPoly(k) returns p such that \spad{p(k) = 0}. + definingPolynomial: % -> % + ++ definingPolynomial(x) returns an expression p such that + ++ \spad{p(x) = 0}. + if % has RetractableTo Integer then + even?: % -> Boolean + ++ even? x is true if x is an even integer. + odd? : % -> Boolean + ++ odd? x is true if x is an odd integer. + + add + +-- the 7 functions not provided are: +-- kernels minPoly definingPolynomial +-- coerce:K -> % eval:(%, List K, List %) -> % +-- subst:(%, List K, List %) -> % +-- eval:(%, List Symbol, List(List % -> %)) -> % + + allKernels: % -> Set K + listk : % -> List K + allk : List % -> Set K + unwrap : (List K, %) -> % + okkernel : (OP, List %) -> % + mkKerLists: List Equation % -> Record(lstk: List K, lstv:List %) + + oppren := operator(PAREN)$CommonOperators() + opbox := operator(BOX)$CommonOperators() + + box(x:%) == box [x] + paren(x:%) == paren [x] + belong? op == op = oppren or op = opbox + listk f == parts allKernels f + tower f == sort_! listk f + allk l == reduce("union", [allKernels f for f in l], {}) + operators f == [operator k for k in listk f] + height f == reduce("max", [height k for k in kernels f], 0) + freeOf?(x:%, s:SY) == not member?(s, [name k for k in listk x]) + distribute x == unwrap([k for k in listk x | is?(k, oppren)], x) + box(l:List %) == opbox l + paren(l:List %) == oppren l + freeOf?(x:%, k:%) == not member?(retract k, listk x) + kernel(op:OP, arg:%) == kernel(op, [arg]) + elt(op:OP, x:%) == op [x] + elt(op:OP, x:%, y:%) == op [x, y] + elt(op:OP, x:%, y:%, z:%) == op [x, y, z] + elt(op:OP, x:%, y:%, z:%, t:%) == op [x, y, z, t] + eval(x:%, s:SY, f:List % -> %) == eval(x, [s], [f]) + eval(x:%, s:OP, f:List % -> %) == eval(x, [name s], [f]) + eval(x:%, s:SY, f:% -> %) == eval(x, [s], [f first #1]) + eval(x:%, s:OP, f:% -> %) == eval(x, [s], [f first #1]) + subst(x:%, e:Equation %) == subst(x, [e]) + + eval(x:%, ls:List OP, lf:List(% -> %)) == + eval(x, ls, [f first #1 for f in lf]$List(List % -> %)) + + eval(x:%, ls:List SY, lf:List(% -> %)) == + eval(x, ls, [f first #1 for f in lf]$List(List % -> %)) + + eval(x:%, ls:List OP, lf:List(List % -> %)) == + eval(x, [name s for s in ls]$List(SY), lf) + + map(fn, k) == + (l := [fn x for x in argument k]$List(%)) = argument k => k::% + (operator k) l + + operator op == + is?(op, PAREN) => oppren + is?(op, BOX) => opbox + error "Unknown operator" + + mainKernel x == + empty?(l := kernels x) => "failed" + n := height(k := first l) + for kk in rest l repeat + if height(kk) > n then + n := height kk + k := kk + k + +-- takes all the kernels except for the dummy variables, which are second +-- arguments of rootOf's, integrals, sums and products which appear only in +-- their first arguments + allKernels f == + s := brace(l := kernels f) + for k in l repeat + t := + (u := property(operator k, DUMMYVAR)) case None => + arg := argument k + s0 := remove_!(retract(second arg)@K, allKernels first arg) + arg := rest rest arg + n := (u::None) pretend N + if n > 1 then arg := rest arg + union(s0, allk arg) + allk argument k + s := union(s, t) + s + + kernel(op:OP, args:List %) == + not belong? op => error "Unknown operator" + okkernel(op, args) + + okkernel(op, l) == + kernel(op, l, 1 + reduce("max", [height f for f in l], 0))$K :: % + + elt(op:OP, args:List %) == + not belong? op => error "Unknown operator" + ((u := arity op) case N) and (#args ^= u::N) + => error "Wrong number of arguments" + (v := evaluate(op,args)$BasicOperatorFunctions1(%)) case % => v::% + okkernel(op, args) + + retract f == + (k := mainKernel f) case "failed" => error "not a kernel" + k::K::% ^= f => error "not a kernel" + k::K + + retractIfCan f == + (k := mainKernel f) case "failed" => "failed" + k::K::% ^= f => "failed" + k + + is?(f:%, s:SY) == + (k := retractIfCan f) case "failed" => false + is?(k::K, s) + + is?(f:%, op:OP) == + (k := retractIfCan f) case "failed" => false + is?(k::K, op) + + unwrap(l, x) == + for k in reverse_! l repeat + x := eval(x, k, first argument k) + x + + distribute(x, y) == + ky := retract y + unwrap([k for k in listk x | + is?(k, "%paren"::SY) and member?(ky, listk(k::%))], x) + + -- in case of conflicting substitutions e.g. [x = a, x = b], + -- the first one prevails. + -- this is not part of the semantics of the function, but just + -- a feature of this implementation. + eval(f:%, leq:List Equation %) == + rec := mkKerLists leq + eval(f, rec.lstk, rec.lstv) + + subst(f:%, leq:List Equation %) == + rec := mkKerLists leq + subst(f, rec.lstk, rec.lstv) + + mkKerLists leq == + lk := empty()$List(K) + lv := empty()$List(%) + for eq in leq repeat + (k := retractIfCan(lhs eq)@Union(K, "failed")) case "failed" => + error "left hand side must be a single kernel" + if not member?(k::K, lk) then + lk := concat(k::K, lk) + lv := concat(rhs eq, lv) + [lk, lv] + + if % has RetractableTo Integer then + intpred?: (%, Integer -> Boolean) -> Boolean + + even? x == intpred?(x, even?) + odd? x == intpred?(x, odd?) + + intpred?(x, pred?) == + (u := retractIfCan(x)@Union(Integer, "failed")) case Integer + and pred?(u::Integer) + +@ +<>= +"ES" + [color=lightblue,href="bookvol10.2.pdf#nameddest=ES"]; +"ES" -> "ORDSET" +"ES" -> "RETRACT" +"ES" -> "IEVALAB" +"ES" -> "EVALAB" + +@ +<>= +"ExpressionSpace()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=ES"]; +"ExpressionSpace()" -> "OrderedSet()" +"ExpressionSpace()" -> "RetractableTo(Kernel(ExpressionSpace))" +"ExpressionSpace()" -> + "InnerEvalable(Kernal(ExpressionSpace),ExpressionSpace)" +"ExpressionSpace()" -> "Evalable(ExpressionSpace)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"ExpressionSpace()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=ES"]; +"ExpressionSpace()" -> "OrderedSet()" +"ExpressionSpace()" -> "RetractableTo(Kernel(ExpressionSpace))" +"ExpressionSpace()" -> + "InnerEvalable(Kernal(ExpressionSpace),ExpressionSpace)" +"ExpressionSpace()" -> "Evalable(ExpressionSpace)" + +"Evalable(ExpressionSpace)" [color=seagreen]; +"Evalable(ExpressionSpace)" -> "Evalable(a:SetCategory)" + +"Evalable(a:SetCategory)" [color=lightblue]; +"Evalable(a:SetCategory)" -> "InnerEvalable(a:SetCategory,b:SetCategory)" + +"InnerEvalable(Kernal(ExpressionSpace),ExpressionSpace)" [color=seagreen]; +"InnerEvalable(Kernal(ExpressionSpace),ExpressionSpace)" -> + "InnerEvalable(a:SetCategory,b:Type)" + +"InnerEvalable(a:SetCategory,b:SetCategory)" [color=seagreen]; +"InnerEvalable(a:SetCategory,b:SetCategory)" -> + "InnerEvalable(a:SetCategory,b:Type)" + +"InnerEvalable(a:SetCategory,b:Type)" [color=lightblue]; +"InnerEvalable(a:SetCategory,b:Type)" -> "Category" + +"RetractableTo(Kernel(ExpressionSpace))" [color=seagreen]; +"RetractableTo(Kernel(ExpressionSpace))" -> "RetractableTo(a:Type)" + +"RetractableTo(a:Type)" [color=lightblue]; +"RetractableTo(a:Type)" -> "Category" + +"OrderedSet()" [color=lightblue]; +"OrderedSet()" -> "SetCategory()" + +"SetCategory()" [color=lightblue]; +"SetCategory()" -> "BasicType()" +"SetCategory()" -> "CoercibleTo(OutputForm)" + +"BasicType()" [color=lightblue]; +"BasicType()" -> "Category" + +"CoercibleTo(OutputForm)" [color=seagreen]; +"CoercibleTo(OutputForm)" -> "CoercibleTo(a:Type)" + +"CoercibleTo(a:Type)" [color=lightblue]; +"CoercibleTo(a:Type)" -> "Category" + +"Category" [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{GradedAlgebra}{GRALG} \pagepic{ps/v102gradedalgebra.ps}{GRALG}{0.75} @@ -11613,6 +12492,7 @@ digraph pic { \pagepic{ps/v102abeliangroup.ps}{ABELGRP}{0.75} {\bf See:}\\ +\pageto{FiniteDivisorCategory}{FDIVCAT} \pageto{LeftModule}{LMODULE} \pageto{NonAssociativeRng}{NARNG} \pageto{OrderedAbelianGroup}{OAGROUP} @@ -13806,6 +14686,178 @@ digraph pic { @ \chapter{Category Layer 7} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{FiniteDivisorCategory}{FDIVCAT} +\pagepic{ps/v102finitedivisorcategory.ps}{FDIVCAT}{0.75} + +{\bf See:}\\ +\pagefrom{AbelianGroup}{ABELGRP} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{FDIVCAT}{0} & +\cross{FDIVCAT}{coerce} & +\cross{FDIVCAT}{decompose} & +\cross{FDIVCAT}{divisor} & +\cross{FDIVCAT}{generator} \\ +\cross{FDIVCAT}{hash} & +\cross{FDIVCAT}{ideal} & +\cross{FDIVCAT}{latex} & +\cross{FDIVCAT}{principal?} & +\cross{FDIVCAT}{reduce} \\ +\cross{FDIVCAT}{sample} & +\cross{FDIVCAT}{subtractIfCan} & +\cross{FDIVCAT}{zero?} & +\cross{FDIVCAT}{?\~{}=?} & +\cross{FDIVCAT}{?*?} \\ +\cross{FDIVCAT}{?+?} & +\cross{FDIVCAT}{?-?} & +\cross{FDIVCAT}{-?} & +\cross{FDIVCAT}{?=?} & +\end{tabular} + +These are directly exported but not implemented: +\begin{verbatim} + decompose : % -> + Record(id: FractionalIdeal(UP,Fraction UP,UPUP,R),principalPart: R) + divisor : R -> % + divisor : FractionalIdeal(UP,Fraction UP,UPUP,R) -> % + divisor : (F,F) -> % + divisor : (F,F,Integer) -> % + divisor : (R,UP,UP,UP,F) -> % + generator : % -> Union(R,"failed") + ideal : % -> FractionalIdeal(UP,Fraction UP,UPUP,R) + reduce : % -> % +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + principal? : % -> Boolean +\end{verbatim} + +These exports come from \refto{AbelianGroup}(): +\begin{verbatim} + 0 : () -> % + coerce : % -> OutputForm + hash : % -> SingleInteger + latex : % -> String + sample : () -> % + subtractIfCan : (%,%) -> Union(%,"failed") + zero? : % -> Boolean + -? : % -> % + ?-? : (%,%) -> % + ?~=? : (%,%) -> Boolean + ?+? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?*? : (PositiveInteger,%) -> % + ?*? : (Integer,%) -> % + ?*? : (NonNegativeInteger,%) -> % +\end{verbatim} + +<>= +)abbrev category FDIVCAT FiniteDivisorCategory +++ Category for finite rational divisors on a curve +++ Author: Manuel Bronstein +++ Date Created: 19 May 1993 +++ Date Last Updated: 19 May 1993 +++ Description: +++ This category describes finite rational divisors on a curve, that +++ is finite formal sums SUM(n * P) where the n's are integers and the +++ P's are finite rational points on the curve. +++ Keywords: divisor, algebraic, curve. +++ Examples: )r FDIV INPUT +FiniteDivisorCategory(F, UP, UPUP, R): Category == Result where + F : Field + UP : UnivariatePolynomialCategory F + UPUP: UnivariatePolynomialCategory Fraction UP + R : FunctionFieldCategory(F, UP, UPUP) + + ID ==> FractionalIdeal(UP, Fraction UP, UPUP, R) + + Result ==> AbelianGroup with + ideal : % -> ID + ++ ideal(D) returns the ideal corresponding to a divisor D. + divisor : ID -> % + ++ divisor(I) makes a divisor D from an ideal I. + divisor : R -> % + ++ divisor(g) returns the divisor of the function g. + divisor : (F, F) -> % + ++ divisor(a, b) makes the divisor P: \spad{(x = a, y = b)}. + ++ Error: if P is singular. + divisor : (F, F, Integer) -> % + ++ divisor(a, b, n) makes the divisor + ++ \spad{nP} where P: \spad{(x = a, y = b)}. + ++ P is allowed to be singular if n is a multiple of the rank. + decompose : % -> Record(id:ID, principalPart: R) + ++ decompose(d) returns \spad{[id, f]} where \spad{d = (id) + div(f)}. + reduce : % -> % + ++ reduce(D) converts D to some reduced form (the reduced forms can + ++ be differents in different implementations). + principal? : % -> Boolean + ++ principal?(D) tests if the argument is the divisor of a function. + generator : % -> Union(R, "failed") + ++ generator(d) returns f if \spad{(f) = d}, + ++ "failed" if d is not principal. + divisor : (R, UP, UP, UP, F) -> % + ++ divisor(h, d, d', g, r) returns the sum of all the finite points + ++ where \spad{h/d} has residue \spad{r}. + ++ \spad{h} must be integral. + ++ \spad{d} must be squarefree. + ++ \spad{d'} is some derivative of \spad{d} (not necessarily dd/dx). + ++ \spad{g = gcd(d,discriminant)} contains the ramified zeros of \spad{d} + add + principal? d == generator(d) case R + +@ +<>= +"FDIVCAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FDIVCAT"]; +"FDIVCAT" -> "ABELGRP" +@ +<>= +"FiniteDivisorCategory()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FDIVCAT"]; +"FiniteDivisorCategory()" -> "AbelianGroup()" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"FiniteDivisorCategory()" [color=lightblue]; +"FiniteDivisorCategory()" -> "AbelianGroup()" + +"AbelianGroup()" [color=lightblue]; +"AbelianGroup()" -> "CancellationAbelianMonoid()" +"AbelianGroup()" -> "RepeatedDoubling(AbelianGroup)" + +"RepeatedDoubling(AbelianGroup)" [color="#00EE00"]; +"RepeatedDoubling(AbelianGroup)" -> "RepeatedDoubling(a:SetCategory)" + +"RepeatedDoubling(AbelianSemiGroup)" [color="#00EE00"]; +"RepeatedDoubling(AbelianSemiGroup)" -> "RepeatedDoubling(a:SetCategory)" + +"RepeatedDoubling(a:SetCategory)" [color="#00EE00"]; +"RepeatedDoubling(a:SetCategory)" -> "Package" + +"Package" [color="#00EE00"]; + +"CancellationAbelianMonoid()" [color=lightblue]; +"CancellationAbelianMonoid()" -> "AbelianMonoid()" + +"AbelianMonoid()" [color=lightblue]; +"AbelianMonoid()" -> "AbelianSemiGroup()" + +"AbelianSemiGroup()" [color=lightblue]; +"AbelianSemiGroup()" -> "SETCAT..." +"AbelianSemiGroup()" -> "RepeatedDoubling(AbelianSemiGroup)" + +"SETCAT..." [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{FiniteSetAggregate}{FSAGG} \pagepic{ps/v102finitesetaggregate.ps}{FSAGG}{0.75} @@ -22387,6 +23439,8 @@ digraph pic { \pagepic{ps/v102differentialextension.ps}{DIFEXT}{0.65} {\bf See:}\\ +\pageto{DifferentialPolynomialCategory}{DPOLCAT} +\pageto{QuotientFieldCategory}{QFCAT} \pageto{UnivariatePolynomialCategory}{UPOLYC} \pagefrom{PartialDifferentialRing}{PDRING} \pagefrom{Ring}{RING} @@ -22477,18 +23531,18 @@ These exports come from \refto{DifferentialRing}(): These exports come from \refto{PartialDifferentialRing}(Symbol): \begin{verbatim} - differentiate : (%,List Symbol) -> % - if R has PDRING SYMBOL - differentiate : (%,Symbol,NonNegativeInteger) -> % - if R has PDRING SYMBOL - differentiate : (%,List Symbol,List NonNegativeInteger) -> % - if R has PDRING SYMBOL D : (%,Symbol) -> % if R has PDRING SYMBOL D : (%,List Symbol) -> % if R has PDRING SYMBOL D : (%,Symbol,NonNegativeInteger) -> % if R has PDRING SYMBOL D : (%,List Symbol,List NonNegativeInteger) -> % if R has PDRING SYMBOL + differentiate : (%,List Symbol) -> % + if R has PDRING SYMBOL + differentiate : (%,Symbol,NonNegativeInteger) -> % + if R has PDRING SYMBOL + differentiate : (%,List Symbol,List NonNegativeInteger) -> % + if R has PDRING SYMBOL \end{verbatim} <>= @@ -22553,6 +23607,11 @@ DifferentialExtension(R:Ring): Category == Ring with "DifferentialExtension(a:Ring)" -> "DifferentialRing()" "DifferentialExtension(a:Ring)" -> "PartialDifferentialRing(Symbol)" +"DifferentialExtension(IntegralDomain)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=DIFEXT"]; +"DifferentialExtension(IntegralDomain)" -> + "DifferentialExtension(a:Ring)" + @ <>= digraph pic { @@ -22979,6 +24038,7 @@ digraph pic { {\bf See:}\\ \pageto{MonogenicAlgebra}{MONOGEN} \pageto{PolynomialCategory}{POLYCAT} +\pageto{QuotientFieldCategory}{QFCAT} \pagefrom{LinearlyExplicitRingOver}{LINEXP} {\bf Exports:}\\ @@ -23102,6 +24162,11 @@ FullyLinearlyExplicitRingOver(R:Ring):Category == "FullyLinearlyExplicitRingOver(a:CommutativeRing)" -> "FullyLinearlyExplicitRingOver(a:Ring)" +"FullyLinearlyExplicitRingOver(IntegralDomain)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=FLINEXP"]; +"FullyLinearlyExplicitRingOver(IntegralDomain)" -> + "FullyLinearlyExplicitRingOver(a:Ring)" + @ <>= digraph pic { @@ -23612,6 +24677,7 @@ digraph pic { \pageto{DivisionRing}{DIVRING} \pageto{FiniteRankAlgebra}{FINRALG} \pageto{IntegralDomain}{INTDOM} +\pageto{QuotientFieldCategory}{QFCAT} \pagefrom{Module}{MODULE} \pagefrom{Ring}{RING} @@ -23744,6 +24810,10 @@ Algebra(R:CommutativeRing): Category == [color=seagreen,href="bookvol10.2.pdf#nameddest=ALGEBRA"]; "Algebra(Fraction(Integer))" -> "Algebra(a:CommutativeRing)" +"Algebra(IntegralDomain)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=ALGEBRA"]; +"Algebra(IntegralDomain)" -> "Algebra(a:CommutativeRing)" + @ <>= digraph pic { @@ -28285,6 +29355,7 @@ digraph pic { \pageto{ExtensionField}{XF} \pageto{FieldOfPrimeCharacteristic}{FPC} \pageto{FiniteRankAlgebra}{FINRALG} +\pageto{QuotientFieldCategory}{QFCAT} \pageto{RealNumberSystem}{RNS} \pageto{UnivariatePolynomialCategory}{UPOLYC} \pagefrom{DivisionRing}{DIVRING} @@ -28528,6 +29599,7 @@ digraph pic { \pagepic{ps/v102polynomialcategory.ps}{POLYCAT}{0.30} {\bf See:}\\ +\pageto{DifferentialPolynomialCategory}{DPOLCAT} \pageto{UnivariatePolynomialCategory}{UPOLYC} \pagefrom{CommutativeRing}{COMRING} \pagefrom{ConvertibleTo}{KONVERT} @@ -29855,6 +30927,731 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{DifferentialPolynomialCategory}{DPOLCAT} +\pagepic{ps/v102differentialpolynomialcategory.ps}{DPOLCAT}{0.25} + +{\bf See:}\\ +\pagefrom{DifferentialExtension}{DIFEXT} +\pagefrom{PolynomialCategory}{POLYCAT} +\pagefrom{RetractableTo}{RETRACT} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{DPOLCAT}{0} & +\cross{DPOLCAT}{1} & +\cross{DPOLCAT}{associates?} \\ +\cross{DPOLCAT}{binomThmExpt} & +\cross{DPOLCAT}{characteristic} & +\cross{DPOLCAT}{charthRoot} \\ +\cross{DPOLCAT}{coefficient} & +\cross{DPOLCAT}{coefficients} & +\cross{DPOLCAT}{coerce} \\ +\cross{DPOLCAT}{conditionP} & +\cross{DPOLCAT}{content} & +\cross{DPOLCAT}{convert} \\ +\cross{DPOLCAT}{D} & +\cross{DPOLCAT}{degree} & +\cross{DPOLCAT}{differentialVariables} \\ +\cross{DPOLCAT}{differentiate} & +\cross{DPOLCAT}{discriminant} & +\cross{DPOLCAT}{eval} \\ +\cross{DPOLCAT}{exquo} & +\cross{DPOLCAT}{factor} & +\cross{DPOLCAT}{factorPolynomial} \\ +\cross{DPOLCAT}{factorSquareFreePolynomial} & +\cross{DPOLCAT}{gcd} & +\cross{DPOLCAT}{gcdPolynomial} \\ +\cross{DPOLCAT}{ground} & +\cross{DPOLCAT}{ground?} & +\cross{DPOLCAT}{hash} \\ +\cross{DPOLCAT}{initial} & +\cross{DPOLCAT}{isExpt} & +\cross{DPOLCAT}{isobaric?} \\ +\cross{DPOLCAT}{isPlus} & +\cross{DPOLCAT}{isTimes} & +\cross{DPOLCAT}{latex} \\ +\cross{DPOLCAT}{lcm} & +\cross{DPOLCAT}{leader} & +\cross{DPOLCAT}{leadingCoefficient} \\ +\cross{DPOLCAT}{leadingMonomial} & +\cross{DPOLCAT}{makeVariable} & +\cross{DPOLCAT}{map} \\ +\cross{DPOLCAT}{mapExponents} & +\cross{DPOLCAT}{max} & +\cross{DPOLCAT}{min} \\ +\cross{DPOLCAT}{minimumDegree} & +\cross{DPOLCAT}{monicDivide} & +\cross{DPOLCAT}{monomial} \\ +\cross{DPOLCAT}{monomial?} & +\cross{DPOLCAT}{monomials} & +\cross{DPOLCAT}{multivariate} \\ +\cross{DPOLCAT}{numberOfMonomials} & +\cross{DPOLCAT}{one?} & +\cross{DPOLCAT}{order} \\ +\cross{DPOLCAT}{order} & +\cross{DPOLCAT}{patternMatch} & +\cross{DPOLCAT}{pomopo!} \\ +\cross{DPOLCAT}{prime?} & +\cross{DPOLCAT}{primitiveMonomials} & +\cross{DPOLCAT}{primitivePart} \\ +\cross{DPOLCAT}{recip} & +\cross{DPOLCAT}{reducedSystem} & +\cross{DPOLCAT}{reductum} \\ +\cross{DPOLCAT}{resultant} & +\cross{DPOLCAT}{retract} & +\cross{DPOLCAT}{retractIfCan} \\ +\cross{DPOLCAT}{sample} & +\cross{DPOLCAT}{separant} & +\cross{DPOLCAT}{solveLinearPolynomialEquation} \\ +\cross{DPOLCAT}{squareFree} & +\cross{DPOLCAT}{squareFreePart} & +\cross{DPOLCAT}{squareFreePolynomial} \\ +\cross{DPOLCAT}{subtractIfCan} & +\cross{DPOLCAT}{totalDegree} & +\cross{DPOLCAT}{unit?} \\ +\cross{DPOLCAT}{unitCanonical} & +\cross{DPOLCAT}{unitNormal} & +\cross{DPOLCAT}{univariate} \\ +\cross{DPOLCAT}{variables} & +\cross{DPOLCAT}{weight} & +\cross{DPOLCAT}{weights} \\ +\cross{DPOLCAT}{zero?} & +\cross{DPOLCAT}{?*?} & +\cross{DPOLCAT}{?**?} \\ +\cross{DPOLCAT}{?+?} & +\cross{DPOLCAT}{?-?} & +\cross{DPOLCAT}{-?} \\ +\cross{DPOLCAT}{?=?} & +\cross{DPOLCAT}{?\^{}?} & +\cross{DPOLCAT}{?\~{}=?} \\ +\cross{DPOLCAT}{?/?} & +\cross{DPOLCAT}{?$<$?} & +\cross{DPOLCAT}{?$<=$?} \\ +\cross{DPOLCAT}{?$>$?} & +\cross{DPOLCAT}{?$>=$?} & +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item \item if R has canonicalUnitNormal then canonicalUnitNormal where +{\bf \cross{DPOLCAT}{canonicalUnitNormal}} +is true if we can choose a canonical representative for each class +of associate elements, that is {\tt associates?(a,b)} returns true +if and only if {\tt unitCanonical(a) = unitCanonical(b)}. +\item if \$ has IntegralDomain then noZeroDivisors where +{\bf \cross{DPOLCAT}{noZeroDivisors}} +is true if $x * y \ne 0$ implies both x and y are non-zero. +\item if \$ has CommutativeRing then commutative("*") where +{\bf \cross{DPOLCAT}{commutative("*")}} +is true if it has an operation $"*": (D,D) -> D$ +which is commutative. +\item {\bf \cross{DPOLCAT}{unitsKnown}} +is true if a monoid (a multiplicative semigroup with a 1) has +unitsKnown means that the operation {\tt recip} can only return +``failed'' if its argument is not a unit. +\item {\bf \cross{DPOLCAT}{leftUnitary}} +is true if $1 * x = x$ for all x. +\item {\bf \cross{DPOLCAT}{rightUnitary}} +is true if $x * 1 = x$ for all x. +\end{itemize} + +These are implemented by this category: +\begin{verbatim} + coerce : S -> % + degree : (%,S) -> NonNegativeInteger + differentialVariables : % -> List S + differentiate : (%,(R -> R)) -> % + eval : (%,List S,List R) -> % if R has DIFRING + eval : (%,List S,List %) -> % if R has DIFRING + eval : (%,List Equation %) -> % + initial : % -> % + isobaric? : % -> Boolean + leader : % -> V + makeVariable : S -> (NonNegativeInteger -> %) + makeVariable : % -> (NonNegativeInteger -> %) if R has DIFRING + order : % -> NonNegativeInteger + order : (%,S) -> NonNegativeInteger + retractIfCan : % -> Union(S,"failed") + separant : % -> % + weight : % -> NonNegativeInteger + weight : (%,S) -> NonNegativeInteger + weights : (%,S) -> List NonNegativeInteger + weights : % -> List NonNegativeInteger +\end{verbatim} + + +These exports come from \refto{PolynomialCategory}(R,E,V)\\ +where R:Ring, E:OrderedAbelianMonoidSup,\\ +V:DifferentialVariableCategory(S:OrderedSet):\\ +\begin{verbatim} + 0 : () -> % + 1 : () -> % + associates? : (%,%) -> Boolean if R has INTDOM + binomThmExpt : (%,%,NonNegativeInteger) -> % if R has COMRING + characteristic : () -> NonNegativeInteger + charthRoot : % -> Union(%,"failed") + if and(has($,CharacteristicNonZero), + has(R,PolynomialFactorizationExplicit)) + or R has CHARNZ + coefficient : (%,List V,List NonNegativeInteger) -> % + coefficient : (%,V,NonNegativeInteger) -> % + coefficient : (%,E) -> R + coefficients : % -> List R + coerce : R -> % + coerce : Fraction Integer -> % + if R has RETRACT FRAC INT + or R has ALGEBRA FRAC INT + coerce : % -> % if R has INTDOM + coerce : Integer -> % + coerce : % -> OutputForm + coerce : V -> % + conditionP : Matrix % -> Union(Vector %,"failed") + if and(has($,CharacteristicNonZero), + has(R,PolynomialFactorizationExplicit)) + content : % -> R if R has GCDDOM + content : (%,V) -> % if R has GCDDOM + convert : % -> Pattern Integer + if V has KONVERT PATTERN INT + and R has KONVERT PATTERN INT + convert : % -> Pattern Float + if V has KONVERT PATTERN FLOAT + and R has KONVERT PATTERN FLOAT + convert : % -> InputForm + if V has KONVERT INFORM + and R has KONVERT INFORM + D : (%,List V) -> % + D : (%,V) -> % + D : (%,List V,List NonNegativeInteger) -> % + D : (%,V,NonNegativeInteger) -> % + degree : % -> E + degree : (%,List V) -> List NonNegativeInteger + degree : (%,V) -> NonNegativeInteger + differentiate : (%,V) -> % + differentiate : (%,List V,List NonNegativeInteger) -> % + differentiate : (%,V,NonNegativeInteger) -> % + differentiate : (%,List V) -> % + discriminant : (%,V) -> % if R has COMRING + eval : (%,Equation %) -> % + eval : (%,List %,List %) -> % + eval : (%,%,%) -> % + eval : (%,List V,List R) -> % + eval : (%,V,R) -> % + eval : (%,List V,List %) -> % + eval : (%,V,%) -> % + exquo : (%,%) -> Union(%,"failed") if R has INTDOM + exquo : (%,R) -> Union(%,"failed") if R has INTDOM + factor : % -> Factored % if R has PFECAT + factorPolynomial : + SparseUnivariatePolynomial % -> + Factored SparseUnivariatePolynomial % + if R has PFECAT + factorSquareFreePolynomial : + SparseUnivariatePolynomial % -> + Factored SparseUnivariatePolynomial % + if R has PFECAT + gcd : (%,%) -> % if R has GCDDOM + gcd : List % -> % if R has GCDDOM + gcdPolynomial : + (SparseUnivariatePolynomial %, + SparseUnivariatePolynomial %) -> + SparseUnivariatePolynomial % + if R has GCDDOM + ground : % -> R + ground? : % -> Boolean + hash : % -> SingleInteger + isExpt : % -> + Union(Record(var: V,exponent: NonNegativeInteger),"failed") + isPlus : % -> Union(List %,"failed") + isTimes : % -> Union(List %,"failed") + latex : % -> String + lcm : (%,%) -> % if R has GCDDOM + lcm : List % -> % if R has GCDDOM + leadingCoefficient : % -> R + leadingMonomial : % -> % + mainVariable : % -> Union(V,"failed") + map : ((R -> R),%) -> % + mapExponents : ((E -> E),%) -> % + max : (%,%) -> % if R has ORDSET + min : (%,%) -> % if R has ORDSET + minimumDegree : % -> E + minimumDegree : (%,List V) -> List NonNegativeInteger + minimumDegree : (%,V) -> NonNegativeInteger + monicDivide : (%,%,V) -> Record(quotient: %,remainder: %) + monomial : (%,V,NonNegativeInteger) -> % + monomial : (%,List V,List NonNegativeInteger) -> % + monomial : (R,E) -> % + monomial? : % -> Boolean + monomials : % -> List % + multivariate : (SparseUnivariatePolynomial %,V) -> % + multivariate : (SparseUnivariatePolynomial R,V) -> % + numberOfMonomials : % -> NonNegativeInteger + one? : % -> Boolean + patternMatch : + (%,Pattern Integer,PatternMatchResult(Integer,%)) -> + PatternMatchResult(Integer,%) + if V has PATMAB INT + and R has PATMAB INT + patternMatch : + (%,Pattern Float,PatternMatchResult(Float,%)) -> + PatternMatchResult(Float,%) + if V has PATMAB FLOAT + and R has PATMAB FLOAT + pomopo! : (%,R,E,%) -> % + prime? : % -> Boolean if R has PFECAT + primitiveMonomials : % -> List % + primitivePart : (%,V) -> % if R has GCDDOM + primitivePart : % -> % if R has GCDDOM + recip : % -> Union(%,"failed") + reducedSystem : Matrix % -> Matrix R + reducedSystem : + (Matrix %,Vector %) -> Record(mat: Matrix R,vec: Vector R) + reducedSystem : + (Matrix %,Vector %) -> + Record(mat: Matrix Integer,vec: Vector Integer) + if R has LINEXP INT + reducedSystem : Matrix % -> Matrix Integer + if R has LINEXP INT + reductum : % -> % + resultant : (%,%,V) -> % if R has COMRING + retract : % -> R + retract : % -> Integer if R has RETRACT INT + retract : % -> Fraction Integer if R has RETRACT FRAC INT + retract : % -> V + retractIfCan : % -> Union(R,"failed") + retractIfCan : % -> Union(Integer,"failed") + if R has RETRACT INT + retractIfCan : % -> Union(Fraction Integer,"failed") + if R has RETRACT FRAC INT + retractIfCan : % -> Union(V,"failed") + sample : () -> % + solveLinearPolynomialEquation : + (List SparseUnivariatePolynomial %, + SparseUnivariatePolynomial %) -> + Union(List SparseUnivariatePolynomial %,"failed") + if R has PFECAT + squareFree : % -> Factored % if R has GCDDOM + squareFreePart : % -> % if R has GCDDOM + squareFreePolynomial : + SparseUnivariatePolynomial % -> + Factored SparseUnivariatePolynomial % + if R has PFECAT + subtractIfCan : (%,%) -> Union(%,"failed") + totalDegree : (%,List V) -> NonNegativeInteger + totalDegree : % -> NonNegativeInteger + unit? : % -> Boolean if R has INTDOM + unitCanonical : % -> % if R has INTDOM + unitNormal : % -> Record(unit: %,canonical: %,associate: %) + if R has INTDOM + univariate : % -> SparseUnivariatePolynomial R + univariate : (%,V) -> SparseUnivariatePolynomial % + variables : % -> List V + zero? : % -> Boolean + ?+? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (%,R) -> % + ?*? : (R,%) -> % + ?*? : (Fraction Integer,%) -> % if R has ALGEBRA FRAC INT + ?*? : (%,Fraction Integer) -> % if R has ALGEBRA FRAC INT + ?*? : (%,%) -> % + ?*? : (Integer,%) -> % + ?*? : (PositiveInteger,%) -> % + ?*? : (NonNegativeInteger,%) -> % + ?/? : (%,R) -> % if R has FIELD + ?-? : (%,%) -> % + -? : % -> % + ?^? : (%,NonNegativeInteger) -> % + ?^? : (%,PositiveInteger) -> % + ? Boolean if R has ORDSET + ?<=? : (%,%) -> Boolean if R has ORDSET + ?>? : (%,%) -> Boolean if R has ORDSET + ?>=? : (%,%) -> Boolean if R has ORDSET + ?**? : (%,PositiveInteger) -> % + ?**? : (%,NonNegativeInteger) -> % +\end{verbatim} + +These exports come from \refto{DifferentialExtension}(R:Ring): +\begin{verbatim} + D : (%,(R -> R)) -> % + D : (%,(R -> R),NonNegativeInteger) -> % + D : % -> % if R has DIFRING + D : (%,NonNegativeInteger) -> % if R has DIFRING + D : (%,Symbol) -> % if R has PDRING SYMBOL + D : (%,List Symbol) -> % if R has PDRING SYMBOL + D : (%,Symbol,NonNegativeInteger) -> % + if R has PDRING SYMBOL + D : (%,List Symbol,List NonNegativeInteger) -> % + if R has PDRING SYMBOL + differentiate : (%,NonNegativeInteger) -> % + if R has DIFRING + differentiate : (%,List Symbol) -> % + if R has PDRING SYMBOL + differentiate : (%,Symbol,NonNegativeInteger) -> % + if R has PDRING SYMBOL + differentiate : (%,List Symbol,List NonNegativeInteger) -> % + if R has PDRING SYMBOL + differentiate : % -> % if R has DIFRING + differentiate : (%,(R -> R),NonNegativeInteger) -> % + differentiate : (%,Symbol) -> % if R has PDRING SYMBOL +\end{verbatim} + +These exports come from \refto{RetractableTo}(S:OrderedSet): +\begin{verbatim} + retract : % -> S +\end{verbatim} + +These exports come from \refto{InnerEvalable}(S,R)\\ +where S:OrderedSet, R:Ring: +\begin{verbatim} + eval : (%,S,R) -> % if R has DIFRING +\end{verbatim} + +These exports come from \refto{InnerEvalable}(S,%)\\ +where S:OrderedSet, %:DPOLCAT: +\begin{verbatim} + eval : (%,S,%) -> % if R has DIFRING +\end{verbatim} + +These exports come from \refto{Evalable}(%:DPOLCAT): +\begin{verbatim} +\end{verbatim} + +<>= +)abbrev category DPOLCAT DifferentialPolynomialCategory +++ Author: William Sit +++ Date Created: 19 July 1990 +++ Date Last Updated: 13 September 1991 +++ Basic Operations:PolynomialCategory +++ Related Constructors:DifferentialVariableCategory +++ See Also: +++ AMS Classifications:12H05 +++ Keywords: differential indeterminates, ranking, differential polynomials, +++ order, weight, leader, separant, initial, isobaric +++ References:Kolchin, E.R. "Differential Algebra and Algebraic Groups" +++ (Academic Press, 1973). +++ Description: +++ \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}. +++ +++ To construct a domain using this constructor, one needs +++ to provide a ground ring R, an ordered set S of differential +++ indeterminates, a ranking V on the set of derivatives +++ of the differential indeterminates, and a set E of +++ exponents in bijection with the set of differential monomials +++ in the given differential indeterminates. +++ + +DifferentialPolynomialCategory(R:Ring,S:OrderedSet, + V:DifferentialVariableCategory S, E:OrderedAbelianMonoidSup): + Category == + Join(PolynomialCategory(R,E,V), + DifferentialExtension R, RetractableTo S) with + -- Examples: + -- s:=makeVariable('s) + -- p:= 3*(s 1)**2 + s*(s 2)**3 + -- all functions below have default implementations + -- using primitives from V + + makeVariable: S -> (NonNegativeInteger -> $) + ++ makeVariable(s) views s as a differential + ++ indeterminate, in such a way that the n-th + ++ derivative of s may be simply referenced as z.n + ++ where z :=makeVariable(s). + ++ Note: In the interpreter, z is + ++ given as an internal map, which may be ignored. + -- Example: makeVariable('s); %.5 + + differentialVariables: $ -> List S + ++ differentialVariables(p) returns a list of differential + ++ indeterminates occurring in a differential polynomial p. + order : ($, S) -> NonNegativeInteger + ++ order(p,s) returns the order of the differential + ++ polynomial p in differential indeterminate s. + order : $ -> NonNegativeInteger + ++ order(p) returns the order of the differential polynomial p, + ++ which is the maximum number of differentiations of a + ++ differential indeterminate, among all those appearing in p. + degree: ($, S) -> NonNegativeInteger + ++ degree(p, s) returns the maximum degree of + ++ the differential polynomial p viewed as a differential polynomial + ++ in the differential indeterminate s alone. + weights: $ -> List NonNegativeInteger + ++ weights(p) returns a list of weights of differential monomials + ++ appearing in differential polynomial p. + weight: $ -> NonNegativeInteger + ++ weight(p) returns the maximum weight of all differential monomials + ++ appearing in the differential polynomial p. + weights: ($, S) -> List NonNegativeInteger + ++ weights(p, s) returns a list of + ++ weights of differential monomials + ++ appearing in the differential polynomial p when p is viewed + ++ as a differential polynomial in the differential indeterminate s + ++ alone. + weight: ($, S) -> NonNegativeInteger + ++ weight(p, s) returns the maximum weight of all differential + ++ monomials appearing in the differential polynomial p + ++ when p is viewed as a differential polynomial in + ++ the differential indeterminate s alone. + isobaric?: $ -> Boolean + ++ isobaric?(p) returns true if every differential monomial appearing + ++ in the differential polynomial p has same weight, + ++ and returns false otherwise. + leader: $ -> V + ++ leader(p) returns the derivative of the highest rank + ++ appearing in the differential polynomial p + ++ Note: an error occurs if p is in the ground ring. + initial:$ -> $ + ++ initial(p) returns the + ++ leading coefficient when the differential polynomial p + ++ is written as a univariate polynomial in its leader. + separant:$ -> $ + ++ separant(p) returns the + ++ partial derivative of the differential polynomial p + ++ with respect to its leader. + if R has DifferentialRing then + InnerEvalable(S, R) + InnerEvalable(S, $) + Evalable $ + makeVariable: $ -> (NonNegativeInteger -> $) + ++ makeVariable(p) views p as an element of a differential + ++ ring, in such a way that the n-th + ++ derivative of p may be simply referenced as z.n + ++ where z := makeVariable(p). + ++ Note: In the interpreter, z is + ++ given as an internal map, which may be ignored. + -- Example: makeVariable(p); %.5; makeVariable(%**2); %.2 + + add + p:$ + s:S + + makeVariable s == makeVariable(s,#1)::$ + + if R has IntegralDomain then + differentiate(p:$, d:R -> R) == + ans:$ := 0 + l := variables p + while (u:=retractIfCan(p)@Union(R, "failed")) case "failed" repeat + t := leadingMonomial p + lc := leadingCoefficient t + ans := ans + d(lc)::$ * (t exquo lc)::$ + + +/[differentiate(t, v) * (differentiate v)::$ for v in l] + p := reductum p + ans + d(u::R)::$ + + order (p:$):NonNegativeInteger == + ground? p => 0 + "max"/[order v for v in variables p] + + order (p:$,s:S):NonNegativeInteger == + ground? p => 0 + empty? (vv:= [order v for v in variables p | (variable v) = s ]) =>0 + "max"/vv + + degree (p, s) == + d:NonNegativeInteger:=0 + for lp in monomials p repeat + lv:= [v for v in variables lp | (variable v) = s ] + if not empty? lv then d:= max(d, +/degree(lp, lv)) + d + + weights p == + ws:List NonNegativeInteger := nil + empty? (mp:=monomials p) => ws + for lp in mp repeat + lv:= variables lp + if not empty? lv then + dv:= degree(lp, lv) + w:=+/[(weight v) * d _ + for v in lv for d in dv]$(List NonNegativeInteger) + ws:= concat(ws, w) + ws + + weight p == + empty? (ws:=weights p) => 0 + "max"/ws + + weights (p, s) == + ws:List NonNegativeInteger := nil + empty?(mp:=monomials p) => ws + for lp in mp repeat + lv:= [v for v in variables lp | (variable v) = s ] + if not empty? lv then + dv:= degree(lp, lv) + w:=+/[(weight v) * d _ + for v in lv for d in dv]$(List NonNegativeInteger) + ws:= concat(ws, w) + ws + + weight (p,s) == + empty? (ws:=weights(p,s)) => 0 + "max"/ws + + isobaric? p == (# removeDuplicates weights p) = 1 + + leader p == -- depends on the ranking + vl:= variables p + -- it's not enough just to look at leadingMonomial p + -- the term-ordering need not respect the ranking + empty? vl => error "leader is not defined " + "max"/vl + + initial p == leadingCoefficient univariate(p,leader p) + + separant p == differentiate(p, leader p) + + coerce(s:S):$ == s::V::$ + + retractIfCan(p:$):Union(S, "failed") == + (v := retractIfCan(p)@Union(V,"failed")) case "failed" => "failed" + retractIfCan(v::V) + + differentialVariables p == + removeDuplicates [variable v for v in variables p] + + if R has DifferentialRing then + + makeVariable p == differentiate(p, #1) + + eval(p:$, sl:List S, rl:List R) == + ordp:= order p + vl := concat [[makeVariable(s,j)$V for j in 0..ordp] + for s in sl]$List(List V) + rrl:=nil$List(R) + for r in rl repeat + t:= r + rrl:= concat(rrl, + concat(r, [t := differentiate t for i in 1..ordp])) + eval(p, vl, rrl) + + eval(p:$, sl:List S, rl:List $) == + ordp:= order p + vl := concat [[makeVariable(s,j)$V for j in 0..ordp] + for s in sl]$List(List V) + rrl:=nil$List($) + for r in rl repeat + t:=r + rrl:=concat(rrl, + concat(r, [t:=differentiate t for i in 1..ordp])) + eval(p, vl, rrl) + + eval(p:$, l:List Equation $) == + eval(p, [retract(lhs e)@S for e in l]$List(S), + [rhs e for e in l]$List($)) + +@ +<>= +"DPOLCAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=DPOLCAT"]; +"DPOLCAT" -> "DIFEXT" +"DPOLCAT" -> "POLYCAT" +"DPOLCAT" -> "RETRACT" + +@ +<>= +"DifferentialPolynomialCategory(a:Ring,b:OrderedSet,c:DifferentialVariableCategory(b),d:OrderedAbelianMonoidSup)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=DPOLCAT"]; +"DifferentialPolynomialCategory(a:Ring,b:OrderedSet,c:DifferentialVariableCategory(b),d:OrderedAbelianMonoidSup)" + -> "DifferentialExtension(a:Ring)" +"DifferentialPolynomialCategory(a:Ring,b:OrderedSet,c:DifferentialVariableCategory(b),d:OrderedAbelianMonoidSup)" + -> "PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" +"DifferentialPolynomialCategory(a:Ring,b:OrderedSet,c:DifferentialVariableCategory(b),d:OrderedAbelianMonoidSup)" + -> "RetractableTo(OrderedSet)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"DifferentialPolynomialCategory(a:Ring,b:OrderedSet,c:DifferentialVariableCategory(b),d:OrderedAbelianMonoidSup)" + [color=lightblue]; + +"DifferentialPolynomialCategory(a:Ring,b:OrderedSet,c:DifferentialVariableCategory(b),d:OrderedAbelianMonoidSup)" + -> "DifferentialExtension(a:Ring)" + +"DifferentialPolynomialCategory(a:Ring,b:OrderedSet,c:DifferentialVariableCategory(b),d:OrderedAbelianMonoidSup)" + -> "PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + +"DifferentialPolynomialCategory(a:Ring,b:OrderedSet,c:DifferentialVariableCategory(b),d:OrderedAbelianMonoidSup)" + -> "RetractableTo(OrderedSet)" + +"DifferentialExtension(a:Ring)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=DIFEXT"]; +"DifferentialExtension(a:Ring)" -> "RING..." +"DifferentialExtension(a:Ring)" -> "DIFRING..." +"DifferentialExtension(a:Ring)" -> "PDRING..." + +"RetractableTo(OrderedSet)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=RETRACT"]; +"RetractableTo(OrderedSet)" -> "RetractableTo(a:Type)" + +"RetractableTo(a:Type)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=RETRACT"]; +"RetractableTo(a:Type)" -> "Category" + +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=POLYCAT"]; +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "PDRING..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "FAMR..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "EVALAB..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "IEVALAB..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "RETRACT..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "FLINEXP..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "ORDSET..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "GCDDOM..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "PFECAT..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "KONVERT..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "PATMAB..." +"PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)" + -> "COMRING..." + +"DIFRING..." [color=lightblue]; +"RING..." [color=lightblue]; +"PDRING..." [color=lightblue]; +"FAMR..." [color=lightblue]; +"EVALAB..." [color=lightblue]; +"IEVALAB..." [color=lightblue]; +"RETRACT..." [color=lightblue]; +"FLINEXP..." [color=lightblue]; +"ORDSET..." [color=lightblue]; +"GCDDOM..." [color=lightblue]; +"PFECAT..." [color=lightblue]; +"KONVERT..." [color=lightblue]; +"PATMAB..." [color=lightblue]; +"COMRING..." [color=lightblue]; + +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{FieldOfPrimeCharacteristic}{FPC} \pagepic{ps/v102fieldofprimecharacteristic.ps}{FPC}{1.00} @@ -30357,6 +32154,606 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{QuotientFieldCategory}{QFCAT} +\pagepic{ps/v102quotientfieldcategory.ps}{QFCAT}{0.50} + +{\bf See:}\\ +\pagefrom{Algebra}{ALGEBRA} +\pagefrom{DifferentialExtension}{DIFEXT} +\pagefrom{Field}{FIELD} +\pagefrom{FullyEvalableOver}{FEVALAB} +\pagefrom{FullyLinearlyExplicitRingOver}{FLINEXP} +\pagefrom{FullyPatternMatchable}{FPATMAB} +\pagefrom{Patternable}{PATAB} +\pagefrom{RetractableTo}{RETRACT} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{QFCAT}{0} & +\cross{QFCAT}{1} & +\cross{QFCAT}{abs} \\ +\cross{QFCAT}{associates?} & +\cross{QFCAT}{ceiling} & +\cross{QFCAT}{characteristic} \\ +\cross{QFCAT}{charthRoot} & +\cross{QFCAT}{coerce} & +\cross{QFCAT}{conditionP} \\ +\cross{QFCAT}{convert} & +\cross{QFCAT}{D} & +\cross{QFCAT}{denom} \\ +\cross{QFCAT}{denominator} & +\cross{QFCAT}{differentiate} & +\cross{QFCAT}{divide} \\ +\cross{QFCAT}{euclideanSize} & +\cross{QFCAT}{eval} & +\cross{QFCAT}{expressIdealMember} \\ +\cross{QFCAT}{exquo} & +\cross{QFCAT}{extendedEuclidean} & +\cross{QFCAT}{factor} \\ +\cross{QFCAT}{factorPolynomial} & +\cross{QFCAT}{factorSquareFreePolynomial} & +\cross{QFCAT}{floor} \\ +\cross{QFCAT}{fractionPart} & +\cross{QFCAT}{gcd} & +\cross{QFCAT}{gcdPolynomial} \\ +\cross{QFCAT}{hash} & +\cross{QFCAT}{init} & +\cross{QFCAT}{inv} \\ +\cross{QFCAT}{latex} & +\cross{QFCAT}{lcm} & +\cross{QFCAT}{map} \\ +\cross{QFCAT}{max} & +\cross{QFCAT}{min} & +\cross{QFCAT}{multiEuclidean} \\ +\cross{QFCAT}{negative?} & +\cross{QFCAT}{nextItem} & +\cross{QFCAT}{numer} \\ +\cross{QFCAT}{numerator} & +\cross{QFCAT}{one?} & +\cross{QFCAT}{patternMatch} \\ +\cross{QFCAT}{positive?} & +\cross{QFCAT}{prime?} & +\cross{QFCAT}{principalIdeal} \\ +\cross{QFCAT}{random} & +\cross{QFCAT}{recip} & +\cross{QFCAT}{reducedSystem} \\ +\cross{QFCAT}{retract} & +\cross{QFCAT}{retractIfCan} & +\cross{QFCAT}{sample} \\ +\cross{QFCAT}{sign} & +\cross{QFCAT}{sizeLess?} & +\cross{QFCAT}{solveLinearPolynomialEquation} \\ +\cross{QFCAT}{squareFree} & +\cross{QFCAT}{squareFreePart} & +\cross{QFCAT}{squareFreePolynomial} \\ +\cross{QFCAT}{subtractIfCan} & +\cross{QFCAT}{unit?} & +\cross{QFCAT}{unitNormal} \\ +\cross{QFCAT}{unitCanonical} & +\cross{QFCAT}{wholePart} & +\cross{QFCAT}{zero?} \\ +\cross{QFCAT}{?.?} & +\cross{QFCAT}{?*?} & +\cross{QFCAT}{?**?} \\ +\cross{QFCAT}{?+?} & +\cross{QFCAT}{?-?} & +\cross{QFCAT}{-?} \\ +\cross{QFCAT}{?/?} & +\cross{QFCAT}{?=?} & +\cross{QFCAT}{?\^{}?} \\ +\cross{QFCAT}{?quo?} & +\cross{QFCAT}{?rem?} & +\cross{QFCAT}{?\~{}=?} \\ +\cross{QFCAT}{?$<$?} & +\cross{QFCAT}{?$<=$?} & +\cross{QFCAT}{?$>$?} \\ +\cross{QFCAT}{?$>=$?} && +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item {\bf \cross{FPC}{canonicalUnitNormal}} +is true if we can choose a canonical representative for each class +of associate elements, that is {\tt associates?(a,b)} returns true +if and only if {\tt unitCanonical(a) = unitCanonical(b)}. +\item {\bf \cross{FPC}{canonicalsClosed}} +is true if\\ +{\tt unitCanonical(a)*unitCanonical(b) = unitCanonical(a*b)}. +\item {\bf \cross{FPC}{noZeroDivisors}} +is true if $x * y \ne 0$ implies both x and y are non-zero. +\item {\bf \cross{FPC}{commutative("*")}} +is true if it has an operation $"*": (D,D) -> D$ +which is commutative. +\item {\bf \cross{FPC}{unitsKnown}} +is true if a monoid (a multiplicative semigroup with a 1) has +unitsKnown means that the operation {\tt recip} can only return +``failed'' if its argument is not a unit. +\item {\bf \cross{FPC}{leftUnitary}} +is true if $1 * x = x$ for all x. +\item {\bf \cross{FPC}{rightUnitary}} +is true if $x * 1 = x$ for all x. +\item {\bf nil} +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + ceiling : % -> S if S has INS + denom : % -> S + floor : % -> S if S has INS + numer : % -> S + wholePart : % -> S if S has EUCDOM + ?/? : (S,S) -> % +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + characteristic : () -> NonNegativeInteger + coerce : Symbol -> % if S has RETRACT SYMBOL + coerce : Fraction Integer -> % + convert : % -> InputForm if S has KONVERT INFORM + convert : % -> DoubleFloat if S has REAL + convert : % -> Float if S has REAL + convert : % -> Pattern Integer if S has KONVERT PATTERN INT + convert : % -> Pattern Float if S has KONVERT PATTERN FLOAT + denominator : % -> % + differentiate : (%,(S -> S)) -> % + fractionPart : % -> % if S has EUCDOM + init : () -> % if S has STEP + map : ((S -> S),%) -> % + nextItem : % -> Union(%,"failed") if S has STEP + numerator : % -> % + patternMatch : + (%,Pattern Float,PatternMatchResult(Float,%)) -> + PatternMatchResult(Float,%) + if S has PATMAB FLOAT + patternMatch : + (%,Pattern Integer,PatternMatchResult(Integer,%)) -> + PatternMatchResult(Integer,%) + if S has PATMAB INT + random : () -> % if S has INS + reducedSystem : Matrix % -> Matrix S + reducedSystem : (Matrix %,Vector %) -> Record(mat: Matrix S,vec: Vector S) + retract : % -> Symbol if S has RETRACT SYMBOL + retract : % -> Integer if S has RETRACT INT + retractIfCan : % -> Union(Integer,"failed") if S has RETRACT INT + retractIfCan : % -> Union(Symbol,"failed") if S has RETRACT SYMBOL + ? Boolean if S has ORDSET +\end{verbatim} + +These exports come from \refto{Field}(): +\begin{verbatim} + 0 : () -> % + 1 : () -> % + associates? : (%,%) -> Boolean + coerce : % -> % + coerce : Integer -> % + coerce : % -> OutputForm + divide : (%,%) -> Record(quotient: %,remainder: %) + euclideanSize : % -> NonNegativeInteger + expressIdealMember : (List %,%) -> Union(List %,"failed") + extendedEuclidean : (%,%,%) -> Union(Record(coef1: %,coef2: %),"failed") + extendedEuclidean : (%,%) -> Record(coef1: %,coef2: %,generator: %) + exquo : (%,%) -> Union(%,"failed") + factor : % -> Factored % + gcd : (%,%) -> % + gcd : List % -> % + gcdPolynomial : + (SparseUnivariatePolynomial %, + SparseUnivariatePolynomial %) -> + SparseUnivariatePolynomial % + hash : % -> SingleInteger + inv : % -> % + latex : % -> String + lcm : List % -> % + lcm : (%,%) -> % + multiEuclidean : (List %,%) -> Union(List %,"failed") + one? : % -> Boolean + prime? : % -> Boolean + principalIdeal : List % -> Record(coef: List %,generator: %) + recip : % -> Union(%,"failed") + sample : () -> % + sizeLess? : (%,%) -> Boolean + squareFree : % -> Factored % + squareFreePart : % -> % + subtractIfCan : (%,%) -> Union(%,"failed") + unit? : % -> Boolean + unitCanonical : % -> % + unitNormal : % -> Record(unit: %,canonical: %,associate: %) + zero? : % -> Boolean + ?*? : (Fraction Integer,%) -> % + ?*? : (%,Fraction Integer) -> % + ?**? : (%,Integer) -> % + ?^? : (%,Integer) -> % + ?+? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (%,%) -> % + ?*? : (Integer,%) -> % + ?*? : (PositiveInteger,%) -> % + ?*? : (NonNegativeInteger,%) -> % + ?-? : (%,%) -> % + -? : % -> % + ?**? : (%,PositiveInteger) -> % + ?**? : (%,NonNegativeInteger) -> % + ?^? : (%,NonNegativeInteger) -> % + ?^? : (%,PositiveInteger) -> % + ?/? : (%,%) -> % + ?quo? : (%,%) -> % + ?rem? : (%,%) -> % +\end{verbatim} + +These exports come from \refto{Algebra}(S:IntegralDomain): +\begin{verbatim} + coerce : S -> % + ?*? : (%,S) -> % + ?*? : (S,%) -> % +\end{verbatim} + +These exports come from \refto{RetractableTo}(S:IntegralDomain): +\begin{verbatim} + retract : % -> S + retractIfCan : % -> Union(S,"failed") +\end{verbatim} + +These exports come from \refto{FullyEvalableOver}(S:IntegralDomain): +\begin{verbatim} + ?.? : (%,S) -> % if S has ELTAB(S,S) + eval : (%,Equation S) -> % if S has EVALAB S + eval : (%,List Symbol,List S) -> % if S has IEVALAB(SYMBOL,S) + eval : (%,List Equation S) -> % if S has EVALAB S + eval : (%,S,S) -> % if S has EVALAB S + eval : (%,List S,List S) -> % if S has EVALAB S + eval : (%,Symbol,S) -> % if S has IEVALAB(SYMBOL,S) +\end{verbatim} + +These exports come from \refto{DifferentialExtension}(S:IntegralDomain): +\begin{verbatim} + D : (%,(S -> S)) -> % + D : (%,(S -> S),NonNegativeInteger) -> % + D : % -> % if S has DIFRING + D : (%,NonNegativeInteger) -> % if S has DIFRING + D : (%,List Symbol,List NonNegativeInteger) -> % + if S has PDRING SYMBOL + D : (%,Symbol,NonNegativeInteger) -> % + if S has PDRING SYMBOL + D : (%,List Symbol) -> % if S has PDRING SYMBOL + D : (%,Symbol) -> % if S has PDRING SYMBOL + differentiate : (%,List Symbol) -> % + if S has PDRING SYMBOL + differentiate : (%,Symbol,NonNegativeInteger) -> % + if S has PDRING SYMBOL + differentiate : (%,List Symbol,List NonNegativeInteger) -> % + if S has PDRING SYMBOL + differentiate : (%,NonNegativeInteger) -> % if S has DIFRING + differentiate : % -> % if S has DIFRING + differentiate : (%,Symbol) -> % if S has PDRING SYMBOL + differentiate : (%,(S -> S),NonNegativeInteger) -> % +\end{verbatim} + +These exports come from +\refto{FullyLinearlyExplicitRingOver}(S:IntegralDomain): +\begin{verbatim} + reducedSystem : (Matrix %,Vector %) -> + Record(mat: Matrix Integer,vec: Vector Integer) + if S has LINEXP INT + reducedSystem : Matrix % -> Matrix Integer if S has LINEXP INT +\end{verbatim} + +These exports come from \refto{Patternable}(S:IntegralDomain): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{FullyPatternMatchable}(S:IntegralDomain): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{StepThrough}(): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{RetractableTo}(Integer): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{RetractableTo}(Fraction(Integer)): +\begin{verbatim} + retract : % -> Fraction Integer if S has RETRACT INT + retractIfCan : % -> Union(Fraction Integer,"failed") + if S has RETRACT INT +\end{verbatim} + +These exports come from \refto{OrderedSet}(): +\begin{verbatim} + max : (%,%) -> % if S has ORDSET + min : (%,%) -> % if S has ORDSET + ?<=? : (%,%) -> Boolean if S has ORDSET + ?>? : (%,%) -> Boolean if S has ORDSET + ?>=? : (%,%) -> Boolean if S has ORDSET +\end{verbatim} + +These exports come from \refto{OrderedIntegralDomain}(): +\begin{verbatim} + abs : % -> % if S has OINTDOM + negative? : % -> Boolean if S has OINTDOM + positive? : % -> Boolean if S has OINTDOM + sign : % -> Integer if S has OINTDOM +\end{verbatim} + +These exports come from \refto{RealConstant}(): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{ConvertibleTo}(InputForm): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{CharacteristicZero}(): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{CharacteristicNonZero}(): +\begin{verbatim} + charthRoot : % -> Union(%,"failed") + if S has CHARNZ + or and(has($,CharacteristicNonZero), + has(S,PolynomialFactorizationExplicit)) +\end{verbatim} + +These exports come from \refto{RetractableTo}(Symbol): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{EuclideanDomain}(): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{IntegerNumberSystem}(): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{PolynomialFactorizationExplicit}(): +\begin{verbatim} + conditionP : Matrix % -> Union(Vector %,"failed") + if and(has($,CharacteristicNonZero), + has(S,PolynomialFactorizationExplicit)) + factorPolynomial : + SparseUnivariatePolynomial % -> + Factored SparseUnivariatePolynomial % + if S has PFECAT + factorSquareFreePolynomial : + SparseUnivariatePolynomial % -> + Factored SparseUnivariatePolynomial % + if S has PFECAT + solveLinearPolynomialEquation : + (List SparseUnivariatePolynomial %, + SparseUnivariatePolynomial %) -> + Union(List SparseUnivariatePolynomial %,"failed") + if S has PFECAT + squareFreePolynomial : + SparseUnivariatePolynomial % -> + Factored SparseUnivariatePolynomial % + if S has PFECAT +\end{verbatim} + +<>= +)abbrev category QFCAT QuotientFieldCategory +++ Author: +++ Date Created: +++ Date Last Updated: 5th March 1996 +++ Basic Functions: + - * / numer denom +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: QuotientField(S) is the +++ category of fractions of an Integral Domain S. +QuotientFieldCategory(S: IntegralDomain): Category == + Join(Field, Algebra S, RetractableTo S, FullyEvalableOver S, + DifferentialExtension S, FullyLinearlyExplicitRingOver S, + Patternable S, FullyPatternMatchable S) with + _/ : (S, S) -> % + ++ d1 / d2 returns the fraction d1 divided by d2. + numer : % -> S + ++ numer(x) returns the numerator of the fraction x. + denom : % -> S + ++ denom(x) returns the denominator of the fraction x. + numerator : % -> % + ++ numerator(x) is the numerator of the fraction x converted to %. + denominator : % -> % + ++ denominator(x) is the denominator of the fraction x converted to %. + if S has StepThrough then StepThrough + if S has RetractableTo Integer then + RetractableTo Integer + RetractableTo Fraction Integer + if S has OrderedSet then OrderedSet + if S has OrderedIntegralDomain then OrderedIntegralDomain + if S has RealConstant then RealConstant + if S has ConvertibleTo InputForm then ConvertibleTo InputForm + if S has CharacteristicZero then CharacteristicZero + if S has CharacteristicNonZero then CharacteristicNonZero + if S has RetractableTo Symbol then RetractableTo Symbol + if S has EuclideanDomain then + wholePart: % -> S + ++ wholePart(x) returns the whole part of the fraction x + ++ i.e. the truncated quotient of the numerator by the denominator. + fractionPart: % -> % + ++ fractionPart(x) returns the fractional part of x. + ++ x = wholePart(x) + fractionPart(x) + if S has IntegerNumberSystem then + random: () -> % + ++ random() returns a random fraction. + ceiling : % -> S + ++ ceiling(x) returns the smallest integral element above x. + floor: % -> S + ++ floor(x) returns the largest integral element below x. + if S has PolynomialFactorizationExplicit then + PolynomialFactorizationExplicit + + add + import MatrixCommonDenominator(S, %) + + numerator(x) == numer(x)::% + + denominator(x) == denom(x) ::% + + if S has StepThrough then + init() == init()$S / 1$S + + nextItem(n) == + m:= nextItem(numer(n)) + m case "failed" => + error "We seem to have a Fraction of a finite object" + m / 1 + + map(fn, x) == (fn numer x) / (fn denom x) + + reducedSystem(m:Matrix %):Matrix S == clearDenominator m + + characteristic() == characteristic()$S + + differentiate(x:%, deriv:S -> S) == + n := numer x + d := denom x + (deriv n * d - n * deriv d) / (d**2) + + if S has ConvertibleTo InputForm then + convert(x:%):InputForm == (convert numer x) / (convert denom x) + + if S has RealConstant then + convert(x:%):Float == (convert numer x) / (convert denom x) + + convert(x:%):DoubleFloat == (convert numer x) / (convert denom x) + + -- Note that being a Join(OrderedSet,IntegralDomain) is not the same + -- as being an OrderedIntegralDomain. + if S has OrderedIntegralDomain then + if S has canonicalUnitNormal then + x:% < y:% == + (numer x * denom y) < (numer y * denom x) + else + x:% < y:% == + if denom(x) < 0 then (x,y):=(y,x) + if denom(y) < 0 then (x,y):=(y,x) + (numer x * denom y) < (numer y * denom x) + else if S has OrderedSet then + x:% < y:% == + (numer x * denom y) < (numer y * denom x) + + if (S has EuclideanDomain) then + fractionPart x == x - (wholePart(x)::%) + + if S has RetractableTo Symbol then + coerce(s:Symbol):% == s::S::% + + retract(x:%):Symbol == retract(retract(x)@S) + + retractIfCan(x:%):Union(Symbol, "failed") == + (r := retractIfCan(x)@Union(S,"failed")) case "failed" =>"failed" + retractIfCan(r::S) + + if (S has ConvertibleTo Pattern Integer) then + convert(x:%):Pattern(Integer)==(convert numer x)/(convert denom x) + + if (S has PatternMatchable Integer) then + patternMatch(x:%, p:Pattern Integer, + l:PatternMatchResult(Integer, %)) == + patternMatch(x, p, + l)$PatternMatchQuotientFieldCategory(Integer, S, %) + + if (S has ConvertibleTo Pattern Float) then + convert(x:%):Pattern(Float) == (convert numer x)/(convert denom x) + + if (S has PatternMatchable Float) then + patternMatch(x:%, p:Pattern Float, + l:PatternMatchResult(Float, %)) == + patternMatch(x, p, + l)$PatternMatchQuotientFieldCategory(Float, S, %) + + if S has RetractableTo Integer then + coerce(x:Fraction Integer):% == numer(x)::% / denom(x)::% + + if not(S is Integer) then + retract(x:%):Integer == retract(retract(x)@S) + + retractIfCan(x:%):Union(Integer, "failed") == + (u := retractIfCan(x)@Union(S, "failed")) case "failed" => + "failed" + retractIfCan(u::S) + + if S has IntegerNumberSystem then + random():% == + while zero?(d:=random()$S) repeat d + random()$S / d + + reducedSystem(m:Matrix %, v:Vector %): + Record(mat:Matrix S, vec:Vector S) == + n := reducedSystem(horizConcat(v::Matrix(%), m))@Matrix(S) + [subMatrix(n, minRowIndex n, maxRowIndex n, 1 + minColIndex n, + maxColIndex n), column(n, minColIndex n)] + +@ +<>= +"QFCAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=QFCAT"]; +"QFCAT" -> "ALGEBRA" +"QFCAT" -> "DIFEXT" +"QFCAT" -> "FIELD" +"QFCAT" -> "FEVALAB" +"QFCAT" -> "FLINEXP" +"QFCAT" -> "FPATMAB" +"QFCAT" -> "PATAB" +"QFCAT" -> "RETRACT" + +@ +<>= +"QuotientFieldCategory(a:IntegralDomain)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=QFCAT"]; +"QuotientFieldCategory(a:IntegralDomain)" -> "Field()" +"QuotientFieldCategory(a:IntegralDomain)" -> "Algebra(IntegralDomain)" +"QuotientFieldCategory(a:IntegralDomain)" -> "RetractableTo(IntegralDomain)" +"QuotientFieldCategory(a:IntegralDomain)" -> + "FullyEvalableOver(IntegralDomain)" +"QuotientFieldCategory(a:IntegralDomain)" -> + "DifferentialExtension(IntegralDomain)" +"QuotientFieldCategory(a:IntegralDomain)" -> + "FullyLinearlyExplicitRingOver(IntegralDomain)" +"QuotientFieldCategory(a:IntegralDomain)" -> + "Patternable(IntegralDomain)" +"QuotientFieldCategory(a:IntegralDomain)" -> + "FullyPatternMatchable(IntegralDomain)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"QuotientFieldCategory(a:IntegralDomain)" [color=lightblue]; +"QuotientFieldCategory(a:IntegralDomain)" -> "ALGEBRA..." +"QuotientFieldCategory(a:IntegralDomain)" -> "DIFEXT..." +"QuotientFieldCategory(a:IntegralDomain)" -> "FIELD..." +"QuotientFieldCategory(a:IntegralDomain)" -> "FEVALAB..." +"QuotientFieldCategory(a:IntegralDomain)" -> "FLINEXP..." +"QuotientFieldCategory(a:IntegralDomain)" -> "FPATMAB..." +"QuotientFieldCategory(a:IntegralDomain)" -> "PATAB..." +"QuotientFieldCategory(a:IntegralDomain)" -> "RETRACT..." + +"ALGEBRA..." [color=lightblue]; +"DIFEXT..." [color=lightblue]; +"FIELD..." [color=lightblue]; +"FEVALAB..." [color=lightblue]; +"FLINEXP..." [color=lightblue]; +"FPATMAB..." [color=lightblue]; +"PATAB..." [color=lightblue]; +"RETRACT..." [color=lightblue]; + +} + + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{RealNumberSystem}{RNS} \pagepic{ps/v102realnumbersystem.ps}{RNS}{0.50} @@ -36423,6 +38820,892 @@ Note that this code is not included in the generated catdef.spad file. (QUOTE |lookupComplete|))) @ +\section{ES.lsp BOOTSTRAP} +{\bf ES} depends on a chain of files. We need to break this cycle to build +the algebra. So we keep a cached copy of the translated {\bf ES} +category which we can write into the {\bf MID} directory. We compile +the lisp code and copy the {\bf ES.o} file to the {\bf OUT} directory. +This is eventually forcibly replaced by a recompiled version. + +Note that this code is not included in the generated catdef.spad file. + +<>= + +(|/VERSIONCHECK| 2) + +(SETQ |ExpressionSpace;AL| (QUOTE NIL)) + +(DEFUN |ExpressionSpace| NIL + (LET (#:G82344) + (COND + (|ExpressionSpace;AL|) + (T (SETQ |ExpressionSpace;AL| (|ExpressionSpace;|)))))) + +(DEFUN |ExpressionSpace;| NIL + (PROG (#1=#:G82342) + (RETURN + (PROG1 + (LETT #1# + (|sublisV| + (PAIR + (QUOTE (#2=#:G82340 #3=#:G82341)) + (LIST (QUOTE (|Kernel| |$|)) (QUOTE (|Kernel| |$|)))) + (|Join| + (|OrderedSet|) + (|RetractableTo| (QUOTE #2#)) + (|InnerEvalable| (QUOTE #3#) (QUOTE |$|)) + (|Evalable| (QUOTE |$|)) + (|mkCategory| + (QUOTE |domain|) + (QUOTE ( + ((|elt| (|$| (|BasicOperator|) |$|)) T) + ((|elt| (|$| (|BasicOperator|) |$| |$|)) T) + ((|elt| (|$| (|BasicOperator|) |$| |$| |$|)) T) + ((|elt| (|$| (|BasicOperator|) |$| |$| |$| |$|)) T) + ((|elt| (|$| (|BasicOperator|) (|List| |$|))) T) + ((|subst| (|$| |$| (|Equation| |$|))) T) + ((|subst| (|$| |$| (|List| (|Equation| |$|)))) T) + ((|subst| (|$| |$| (|List| (|Kernel| |$|)) (|List| |$|))) T) + ((|box| (|$| |$|)) T) + ((|box| (|$| (|List| |$|))) T) + ((|paren| (|$| |$|)) T) + ((|paren| (|$| (|List| |$|))) T) + ((|distribute| (|$| |$|)) T) + ((|distribute| (|$| |$| |$|)) T) + ((|height| ((|NonNegativeInteger|) |$|)) T) + ((|mainKernel| ((|Union| (|Kernel| |$|) "failed") |$|)) T) + ((|kernels| ((|List| (|Kernel| |$|)) |$|)) T) + ((|tower| ((|List| (|Kernel| |$|)) |$|)) T) + ((|operators| ((|List| (|BasicOperator|)) |$|)) T) + ((|operator| ((|BasicOperator|) (|BasicOperator|))) T) + ((|belong?| ((|Boolean|) (|BasicOperator|))) T) + ((|is?| ((|Boolean|) |$| (|BasicOperator|))) T) + ((|is?| ((|Boolean|) |$| (|Symbol|))) T) + ((|kernel| (|$| (|BasicOperator|) |$|)) T) + ((|kernel| (|$| (|BasicOperator|) (|List| |$|))) T) + ((|map| (|$| (|Mapping| |$| |$|) (|Kernel| |$|))) T) + ((|freeOf?| ((|Boolean|) |$| |$|)) T) + ((|freeOf?| ((|Boolean|) |$| (|Symbol|))) T) + ((|eval| (|$| |$| (|List| (|Symbol|)) (|List| (|Mapping| |$| |$|)))) + T) + ((|eval| + (|$| |$| (|List| (|Symbol|)) (|List| (|Mapping| |$| (|List| |$|))))) + T) + ((|eval| (|$| |$| (|Symbol|) (|Mapping| |$| (|List| |$|)))) T) + ((|eval| (|$| |$| (|Symbol|) (|Mapping| |$| |$|))) T) + ((|eval| + (|$| |$| (|List| (|BasicOperator|)) (|List| (|Mapping| |$| |$|)))) + T) + ((|eval| + (|$| |$| (|List| (|BasicOperator|)) + (|List| (|Mapping| |$| (|List| |$|))))) + T) + ((|eval| (|$| |$| (|BasicOperator|) (|Mapping| |$| (|List| |$|)))) T) + ((|eval| (|$| |$| (|BasicOperator|) (|Mapping| |$| |$|))) T) + ((|minPoly| + ((|SparseUnivariatePolynomial| |$|) (|Kernel| |$|))) + (|has| |$| (|Ring|))) + ((|definingPolynomial| (|$| |$|)) (|has| |$| (|Ring|))) + ((|even?| + ((|Boolean|) |$|)) (|has| |$| (|RetractableTo| (|Integer|)))) + ((|odd?| + ((|Boolean|) |$|)) (|has| |$| (|RetractableTo| (|Integer|)))))) + NIL + (QUOTE ( + (|Boolean|) + (|SparseUnivariatePolynomial| |$|) + (|Kernel| |$|) + (|BasicOperator|) + (|List| (|BasicOperator|)) + (|List| (|Mapping| |$| (|List| |$|))) + (|List| (|Mapping| |$| |$|)) + (|Symbol|) + (|List| (|Symbol|)) + (|List| |$|) + (|List| (|Kernel| |$|)) + (|NonNegativeInteger|) + (|List| (|Equation| |$|)) + (|Equation| |$|))) + NIL))) + |ExpressionSpace|) + (SETELT #1# 0 (QUOTE (|ExpressionSpace|))))))) + +(MAKEPROP (QUOTE |ExpressionSpace|) (QUOTE NILADIC) T) +@ +\section{ES-.lsp BOOTSTRAP} +{\bf ES-} depends on {\bf ES}. We need to break this cycle to build +the algebra. So we keep a cached copy of the translated {\bf ES-} +category which we can write into the {\bf MID} directory. We compile +the lisp code and copy the {\bf ES-.o} file to the {\bf OUT} directory. +This is eventually forcibly replaced by a recompiled version. + +Note that this code is not included in the generated catdef.spad file. + +<>= + +(|/VERSIONCHECK| 2) + +(DEFUN |ES-;box;2S;1| (|x| |$|) + (SPADCALL (LIST |x|) (QREFELT |$| 16))) + +(DEFUN |ES-;paren;2S;2| (|x| |$|) + (SPADCALL (LIST |x|) (QREFELT |$| 18))) + +(DEFUN |ES-;belong?;BoB;3| (|op| |$|) + (COND + ((SPADCALL |op| (QREFELT |$| 13) (QREFELT |$| 21)) (QUOTE T)) + ((QUOTE T) (SPADCALL |op| (QREFELT |$| 14) (QREFELT |$| 21))))) + +(DEFUN |ES-;listk| (|f| |$|) + (SPADCALL (|ES-;allKernels| |f| |$|) (QREFELT |$| 25))) + +(DEFUN |ES-;tower;SL;5| (|f| |$|) + (SPADCALL (|ES-;listk| |f| |$|) (QREFELT |$| 26))) + +(DEFUN |ES-;allk| (|l| |$|) + (PROG (#1=#:G82361 |f| #2=#:G82362) + (RETURN + (SEQ + (SPADCALL + (ELT |$| 30) + (PROGN + (LETT #1# NIL |ES-;allk|) + (SEQ + (LETT |f| NIL |ES-;allk|) + (LETT #2# |l| |ES-;allk|) + G190 + (COND + ((OR (ATOM #2#) + (PROGN (LETT |f| (CAR #2#) |ES-;allk|) NIL)) + (GO G191))) + (SEQ (EXIT (LETT #1# (CONS (|ES-;allKernels| |f| |$|) #1#) |ES-;allk|))) + (LETT #2# (CDR #2#) |ES-;allk|) (GO G190) G191 (EXIT (NREVERSE0 #1#)))) + (SPADCALL NIL (QREFELT |$| 29)) + (QREFELT |$| 33)))))) + +(DEFUN |ES-;operators;SL;7| (|f| |$|) + (PROG (#1=#:G82365 |k| #2=#:G82366) + (RETURN + (SEQ + (PROGN + (LETT #1# NIL |ES-;operators;SL;7|) + (SEQ + (LETT |k| NIL |ES-;operators;SL;7|) + (LETT #2# (|ES-;listk| |f| |$|) |ES-;operators;SL;7|) + G190 + (COND + ((OR (ATOM #2#) (PROGN (LETT |k| (CAR #2#) |ES-;operators;SL;7|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #1# + (CONS (SPADCALL |k| (QREFELT |$| 35)) #1#) |ES-;operators;SL;7|))) + (LETT #2# (CDR #2#) |ES-;operators;SL;7|) + (GO G190) + G191 + (EXIT (NREVERSE0 #1#)))))))) + +(DEFUN |ES-;height;SNni;8| (|f| |$|) + (PROG (#1=#:G82371 |k| #2=#:G82372) + (RETURN + (SEQ + (SPADCALL + (ELT |$| 41) + (PROGN + (LETT #1# NIL |ES-;height;SNni;8|) + (SEQ + (LETT |k| NIL |ES-;height;SNni;8|) + (LETT #2# (SPADCALL |f| (QREFELT |$| 38)) |ES-;height;SNni;8|) + G190 + (COND + ((OR (ATOM #2#) (PROGN (LETT |k| (CAR #2#) |ES-;height;SNni;8|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #1# + (CONS (SPADCALL |k| (QREFELT |$| 40)) #1#) |ES-;height;SNni;8|))) + (LETT #2# (CDR #2#) |ES-;height;SNni;8|) + (GO G190) + G191 + (EXIT (NREVERSE0 #1#)))) + 0 + (QREFELT |$| 44)))))) + +(DEFUN |ES-;freeOf?;SSB;9| (|x| |s| |$|) + (PROG (#1=#:G82377 |k| #2=#:G82378) + (RETURN + (SEQ + (COND + ((SPADCALL |s| + (PROGN + (LETT #1# NIL |ES-;freeOf?;SSB;9|) + (SEQ + (LETT |k| NIL |ES-;freeOf?;SSB;9|) + (LETT #2# (|ES-;listk| |x| |$|) |ES-;freeOf?;SSB;9|) + G190 + (COND + ((OR (ATOM #2#) (PROGN (LETT |k| (CAR #2#) |ES-;freeOf?;SSB;9|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #1# + (CONS (SPADCALL |k| (QREFELT |$| 46)) #1#) |ES-;freeOf?;SSB;9|))) + (LETT #2# (CDR #2#) |ES-;freeOf?;SSB;9|) + (GO G190) + G191 + (EXIT (NREVERSE0 #1#)))) + (QREFELT |$| 48)) + (QUOTE NIL)) + ((QUOTE T) (QUOTE T))))))) + +(DEFUN |ES-;distribute;2S;10| (|x| |$|) + (PROG (#1=#:G82381 |k| #2=#:G82382) + (RETURN + (SEQ + (|ES-;unwrap| + (PROGN (LETT #1# NIL |ES-;distribute;2S;10|) + (SEQ + (LETT |k| NIL |ES-;distribute;2S;10|) + (LETT #2# (|ES-;listk| |x| |$|) |ES-;distribute;2S;10|) + G190 + (COND + ((OR + (ATOM #2#) + (PROGN (LETT |k| (CAR #2#) |ES-;distribute;2S;10|) NIL)) + (GO G191))) + (SEQ + (EXIT + (COND + ((SPADCALL |k| (QREFELT |$| 13) (QREFELT |$| 50)) + (LETT #1# (CONS |k| #1#) |ES-;distribute;2S;10|))))) + (LETT #2# (CDR #2#) |ES-;distribute;2S;10|) + (GO G190) + G191 + (EXIT (NREVERSE0 #1#)))) + |x| + |$|))))) + +(DEFUN |ES-;box;LS;11| (|l| |$|) + (SPADCALL (QREFELT |$| 14) |l| (QREFELT |$| 52))) + +(DEFUN |ES-;paren;LS;12| (|l| |$|) + (SPADCALL (QREFELT |$| 13) |l| (QREFELT |$| 52))) + +(DEFUN |ES-;freeOf?;2SB;13| (|x| |k| |$|) + (COND + ((SPADCALL + (SPADCALL |k| (QREFELT |$| 56)) + (|ES-;listk| |x| |$|) + (QREFELT |$| 57)) + (QUOTE NIL)) + ((QUOTE T) (QUOTE T)))) + +(DEFUN |ES-;kernel;Bo2S;14| (|op| |arg| |$|) + (SPADCALL |op| (LIST |arg|) (QREFELT |$| 59))) + +(DEFUN |ES-;elt;Bo2S;15| (|op| |x| |$|) + (SPADCALL |op| (LIST |x|) (QREFELT |$| 52))) + +(DEFUN |ES-;elt;Bo3S;16| (|op| |x| |y| |$|) + (SPADCALL |op| (LIST |x| |y|) (QREFELT |$| 52))) + +(DEFUN |ES-;elt;Bo4S;17| (|op| |x| |y| |z| |$|) + (SPADCALL |op| (LIST |x| |y| |z|) (QREFELT |$| 52))) + +(DEFUN |ES-;elt;Bo5S;18| (|op| |x| |y| |z| |t| |$|) + (SPADCALL |op| (LIST |x| |y| |z| |t|) (QREFELT |$| 52))) + +(DEFUN |ES-;eval;SSMS;19| (|x| |s| |f| |$|) + (SPADCALL |x| (LIST |s|) (LIST |f|) (QREFELT |$| 67))) + +(DEFUN |ES-;eval;SBoMS;20| (|x| |s| |f| |$|) + (SPADCALL + |x| + (LIST (SPADCALL |s| (QREFELT |$| 69))) + (LIST |f|) + (QREFELT |$| 67))) + +(DEFUN |ES-;eval;SSMS;21| (|x| |s| |f| |$|) + (SPADCALL + |x| + (LIST |s|) + (LIST (CONS (FUNCTION |ES-;eval;SSMS;21!0|) (VECTOR |f| |$|))) + (QREFELT |$| 67))) + +(DEFUN |ES-;eval;SSMS;21!0| (|#1| |$$|) + (SPADCALL (SPADCALL |#1| (QREFELT (QREFELT |$$| 1) 72)) (QREFELT |$$| 0))) + +(DEFUN |ES-;eval;SBoMS;22| (|x| |s| |f| |$|) + (SPADCALL + |x| + (LIST |s|) + (LIST (CONS (FUNCTION |ES-;eval;SBoMS;22!0|) (VECTOR |f| |$|))) + (QREFELT |$| 75))) + +(DEFUN |ES-;eval;SBoMS;22!0| (|#1| |$$|) + (SPADCALL (SPADCALL |#1| (QREFELT (QREFELT |$$| 1) 72)) (QREFELT |$$| 0))) + +(DEFUN |ES-;subst;SES;23| (|x| |e| |$|) + (SPADCALL |x| (LIST |e|) (QREFELT |$| 78))) + +(DEFUN |ES-;eval;SLLS;24| (|x| |ls| |lf| |$|) + (PROG (#1=#:G82403 |f| #2=#:G82404) + (RETURN + (SEQ + (SPADCALL + |x| + |ls| + (PROGN + (LETT #1# NIL |ES-;eval;SLLS;24|) + (SEQ + (LETT |f| NIL |ES-;eval;SLLS;24|) + (LETT #2# |lf| |ES-;eval;SLLS;24|) + G190 + (COND + ((OR (ATOM #2#) (PROGN (LETT |f| (CAR #2#) |ES-;eval;SLLS;24|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #1# + (CONS (CONS (FUNCTION |ES-;eval;SLLS;24!0|) (VECTOR |f| |$|)) #1#) + |ES-;eval;SLLS;24|))) + (LETT #2# (CDR #2#) |ES-;eval;SLLS;24|) + (GO G190) + G191 + (EXIT (NREVERSE0 #1#)))) + (QREFELT |$| 75)))))) + +(DEFUN |ES-;eval;SLLS;24!0| (|#1| |$$|) + (SPADCALL (SPADCALL |#1| (QREFELT (QREFELT |$$| 1) 72)) (QREFELT |$$| 0))) + +(DEFUN |ES-;eval;SLLS;25| (|x| |ls| |lf| |$|) + (PROG (#1=#:G82407 |f| #2=#:G82408) + (RETURN + (SEQ + (SPADCALL + |x| + |ls| + (PROGN + (LETT #1# NIL |ES-;eval;SLLS;25|) + (SEQ + (LETT |f| NIL |ES-;eval;SLLS;25|) + (LETT #2# |lf| |ES-;eval;SLLS;25|) + G190 + (COND + ((OR (ATOM #2#) (PROGN (LETT |f| (CAR #2#) |ES-;eval;SLLS;25|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #1# + (CONS (CONS (FUNCTION |ES-;eval;SLLS;25!0|) (VECTOR |f| |$|)) #1#) + |ES-;eval;SLLS;25|))) + (LETT #2# (CDR #2#) |ES-;eval;SLLS;25|) + (GO G190) + G191 + (EXIT (NREVERSE0 #1#)))) + (QREFELT |$| 67)))))) + +(DEFUN |ES-;eval;SLLS;25!0| (|#1| |$$|) + (SPADCALL (SPADCALL |#1| (QREFELT (QREFELT |$$| 1) 72)) (QREFELT |$$| 0))) + +(DEFUN |ES-;eval;SLLS;26| (|x| |ls| |lf| |$|) + (PROG (#1=#:G82412 |s| #2=#:G82413) + (RETURN + (SEQ + (SPADCALL + |x| + (PROGN + (LETT #1# NIL |ES-;eval;SLLS;26|) + (SEQ + (LETT |s| NIL |ES-;eval;SLLS;26|) + (LETT #2# |ls| |ES-;eval;SLLS;26|) + G190 + (COND + ((OR (ATOM #2#) (PROGN (LETT |s| (CAR #2#) |ES-;eval;SLLS;26|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #1# + (CONS (SPADCALL |s| (QREFELT |$| 69)) #1#) |ES-;eval;SLLS;26|))) + (LETT #2# (CDR #2#) |ES-;eval;SLLS;26|) + (GO G190) + G191 + (EXIT (NREVERSE0 #1#)))) + |lf| + (QREFELT |$| 67)))))) + +(DEFUN |ES-;map;MKS;27| (|fn| |k| |$|) + (PROG (#1=#:G82428 |x| #2=#:G82429 |l|) + (RETURN + (SEQ + (COND + ((SPADCALL + (LETT |l| + (PROGN + (LETT #1# NIL |ES-;map;MKS;27|) + (SEQ + (LETT |x| NIL |ES-;map;MKS;27|) + (LETT #2# (SPADCALL |k| (QREFELT |$| 85)) |ES-;map;MKS;27|) + G190 + (COND + ((OR (ATOM #2#) (PROGN (LETT |x| (CAR #2#) |ES-;map;MKS;27|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #1# (CONS (SPADCALL |x| |fn|) #1#) |ES-;map;MKS;27|))) + (LETT #2# (CDR #2#) |ES-;map;MKS;27|) + (GO G190) + G191 + (EXIT (NREVERSE0 #1#)))) + |ES-;map;MKS;27|) + (SPADCALL |k| (QREFELT |$| 85)) (QREFELT |$| 86)) + (SPADCALL |k| (QREFELT |$| 87))) + ((QUOTE T) + (SPADCALL (SPADCALL |k| (QREFELT |$| 35)) |l| (QREFELT |$| 52)))))))) + +(DEFUN |ES-;operator;2Bo;28| (|op| |$|) + (COND + ((SPADCALL |op| (SPADCALL "%paren" (QREFELT |$| 9)) (QREFELT |$| 89)) + (QREFELT |$| 13)) + ((SPADCALL |op| (SPADCALL "%box" (QREFELT |$| 9)) (QREFELT |$| 89)) + (QREFELT |$| 14)) + ((QUOTE T) (|error| "Unknown operator")))) + +(DEFUN |ES-;mainKernel;SU;29| (|x| |$|) + (PROG (|l| |kk| #1=#:G82445 |n| |k|) + (RETURN + (SEQ + (COND + ((NULL (LETT |l| (SPADCALL |x| (QREFELT |$| 38)) |ES-;mainKernel;SU;29|)) + (CONS 1 "failed")) + ((QUOTE T) + (SEQ + (LETT |n| + (SPADCALL + (LETT |k| (|SPADfirst| |l|) |ES-;mainKernel;SU;29|) (QREFELT |$| 40)) + |ES-;mainKernel;SU;29|) + (SEQ + (LETT |kk| NIL |ES-;mainKernel;SU;29|) + (LETT #1# (CDR |l|) |ES-;mainKernel;SU;29|) + G190 + (COND + ((OR + (ATOM #1#) + (PROGN (LETT |kk| (CAR #1#) |ES-;mainKernel;SU;29|) NIL)) + (GO G191))) + (SEQ + (EXIT + (COND + ((|<| |n| (SPADCALL |kk| (QREFELT |$| 40))) + (SEQ + (LETT |n| (SPADCALL |kk| (QREFELT |$| 40)) |ES-;mainKernel;SU;29|) + (EXIT (LETT |k| |kk| |ES-;mainKernel;SU;29|))))))) + (LETT #1# (CDR #1#) |ES-;mainKernel;SU;29|) (GO G190) G191 (EXIT NIL)) + (EXIT (CONS 0 |k|))))))))) + +(DEFUN |ES-;allKernels| (|f| |$|) + (PROG (|l| |k| #1=#:G82458 |u| |s0| |n| |arg| |t| |s|) + (RETURN + (SEQ + (LETT |s| + (SPADCALL + (LETT |l| + (SPADCALL |f| (QREFELT |$| 38)) + |ES-;allKernels|) + (QREFELT |$| 29)) + |ES-;allKernels|) + (SEQ + (LETT |k| NIL |ES-;allKernels|) + (LETT #1# |l| |ES-;allKernels|) + G190 + (COND + ((OR (ATOM #1#) (PROGN (LETT |k| (CAR #1#) |ES-;allKernels|) NIL)) + (GO G191))) + (SEQ + (LETT |t| + (SEQ + (LETT |u| + (SPADCALL + (SPADCALL |k| (QREFELT |$| 35)) + "%dummyVar" + (QREFELT |$| 94)) + |ES-;allKernels|) + (EXIT + (COND + ((QEQCAR |u| 0) + (SEQ + (LETT |arg| (SPADCALL |k| (QREFELT |$| 85)) |ES-;allKernels|) + (LETT |s0| + (SPADCALL + (SPADCALL + (SPADCALL |arg| (QREFELT |$| 95)) + (QREFELT |$| 56)) + (|ES-;allKernels| (|SPADfirst| |arg|) |$|) + (QREFELT |$| 96)) + |ES-;allKernels|) + (LETT |arg| (CDR (CDR |arg|)) |ES-;allKernels|) + (LETT |n| (QCDR |u|) |ES-;allKernels|) + (COND ((|<| 1 |n|) (LETT |arg| (CDR |arg|) |ES-;allKernels|))) + (EXIT (SPADCALL |s0| (|ES-;allk| |arg| |$|) (QREFELT |$| 30))))) + ((QUOTE T) (|ES-;allk| (SPADCALL |k| (QREFELT |$| 85)) |$|))))) + |ES-;allKernels|) + (EXIT + (LETT |s| (SPADCALL |s| |t| (QREFELT |$| 30)) |ES-;allKernels|))) + (LETT #1# (CDR #1#) |ES-;allKernels|) + (GO G190) + G191 + (EXIT NIL)) + (EXIT |s|))))) + +(DEFUN |ES-;kernel;BoLS;31| (|op| |args| |$|) + (COND + ((NULL (SPADCALL |op| (QREFELT |$| 97))) (|error| "Unknown operator")) + ((QUOTE T) (|ES-;okkernel| |op| |args| |$|)))) + +(DEFUN |ES-;okkernel| (|op| |l| |$|) + (PROG (#1=#:G82465 |f| #2=#:G82466) + (RETURN + (SEQ + (SPADCALL + (SPADCALL |op| |l| + (|+| 1 + (SPADCALL + (ELT |$| 41) + (PROGN + (LETT #1# NIL |ES-;okkernel|) + (SEQ + (LETT |f| NIL |ES-;okkernel|) + (LETT #2# |l| |ES-;okkernel|) + G190 + (COND + ((OR (ATOM #2#) (PROGN (LETT |f| (CAR #2#) |ES-;okkernel|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT #1# + (CONS (SPADCALL |f| (QREFELT |$| 99)) #1#) |ES-;okkernel|))) + (LETT #2# (CDR #2#) |ES-;okkernel|) + (GO G190) + G191 + (EXIT (NREVERSE0 #1#)))) + 0 + (QREFELT |$| 44))) + (QREFELT |$| 100)) + (QREFELT |$| 87)))))) + +(DEFUN |ES-;elt;BoLS;33| (|op| |args| |$|) + (PROG (|u| #1=#:G82482 |v|) + (RETURN + (SEQ + (EXIT + (COND + ((NULL (SPADCALL |op| (QREFELT |$| 97))) (|error| "Unknown operator")) + ((QUOTE T) + (SEQ + (SEQ + (LETT |u| (SPADCALL |op| (QREFELT |$| 102)) |ES-;elt;BoLS;33|) + (EXIT + (COND + ((QEQCAR |u| 0) + (COND + ((NULL (EQL (LENGTH |args|) (QCDR |u|))) + (PROGN + (LETT #1# + (|error| "Wrong number of arguments") + |ES-;elt;BoLS;33|) + (GO #1#)))))))) + (LETT |v| (SPADCALL |op| |args| (QREFELT |$| 105)) |ES-;elt;BoLS;33|) + (EXIT + (COND + ((QEQCAR |v| 0) (QCDR |v|)) + ((QUOTE T) (|ES-;okkernel| |op| |args| |$|)))))))) + #1# + (EXIT #1#))))) + +(DEFUN |ES-;retract;SK;34| (|f| |$|) + (PROG (|k|) + (RETURN + (SEQ + (LETT |k| (SPADCALL |f| (QREFELT |$| 107)) |ES-;retract;SK;34|) + (EXIT + (COND + ((OR + (QEQCAR |k| 1) + (NULL + (SPADCALL + (SPADCALL (QCDR |k|) (QREFELT |$| 87)) + |f| + (QREFELT |$| 108)))) + (|error| "not a kernel")) + ((QUOTE T) (QCDR |k|)))))))) + +(DEFUN |ES-;retractIfCan;SU;35| (|f| |$|) + (PROG (|k|) + (RETURN + (SEQ + (LETT |k| (SPADCALL |f| (QREFELT |$| 107)) |ES-;retractIfCan;SU;35|) + (EXIT + (COND + ((OR + (QEQCAR |k| 1) + (NULL + (SPADCALL + (SPADCALL (QCDR |k|) (QREFELT |$| 87)) + |f| + (QREFELT |$| 108)))) + (CONS 1 "failed")) + ((QUOTE T) |k|))))))) + +(DEFUN |ES-;is?;SSB;36| (|f| |s| |$|) + (PROG (|k|) + (RETURN + (SEQ + (LETT |k| (SPADCALL |f| (QREFELT |$| 111)) |ES-;is?;SSB;36|) + (EXIT + (COND + ((QEQCAR |k| 1) (QUOTE NIL)) + ((QUOTE T) (SPADCALL (QCDR |k|) |s| (QREFELT |$| 112))))))))) + +(DEFUN |ES-;is?;SBoB;37| (|f| |op| |$|) + (PROG (|k|) + (RETURN + (SEQ + (LETT |k| (SPADCALL |f| (QREFELT |$| 111)) |ES-;is?;SBoB;37|) + (EXIT + (COND + ((QEQCAR |k| 1) (QUOTE NIL)) + ((QUOTE T) (SPADCALL (QCDR |k|) |op| (QREFELT |$| 50))))))))) + +(DEFUN |ES-;unwrap| (|l| |x| |$|) + (PROG (|k| #1=#:G82507) + (RETURN + (SEQ + (SEQ + (LETT |k| NIL |ES-;unwrap|) + (LETT #1# (NREVERSE |l|) |ES-;unwrap|) + G190 + (COND + ((OR (ATOM #1#) (PROGN (LETT |k| (CAR #1#) |ES-;unwrap|) NIL)) + (GO G191))) + (SEQ + (EXIT + (LETT |x| + (SPADCALL |x| |k| + (|SPADfirst| (SPADCALL |k| (QREFELT |$| 85))) + (QREFELT |$| 115)) + |ES-;unwrap|))) + (LETT #1# (CDR #1#) |ES-;unwrap|) + (GO G190) + G191 + (EXIT NIL)) + (EXIT |x|))))) + +(DEFUN |ES-;distribute;3S;39| (|x| |y| |$|) + (PROG (|ky| #1=#:G82512 |k| #2=#:G82513) + (RETURN + (SEQ + (LETT |ky| (SPADCALL |y| (QREFELT |$| 56)) |ES-;distribute;3S;39|) + (EXIT + (|ES-;unwrap| + (PROGN + (LETT #1# NIL |ES-;distribute;3S;39|) + (SEQ + (LETT |k| NIL |ES-;distribute;3S;39|) + (LETT #2# (|ES-;listk| |x| |$|) |ES-;distribute;3S;39|) + G190 + (COND + ((OR + (ATOM #2#) + (PROGN (LETT |k| (CAR #2#) |ES-;distribute;3S;39|) NIL)) + (GO G191))) + (SEQ + (EXIT + (COND + ((COND + ((SPADCALL |k| + (SPADCALL "%paren" (QREFELT |$| 9)) + (QREFELT |$| 112)) + (SPADCALL |ky| + (|ES-;listk| (SPADCALL |k| (QREFELT |$| 87)) |$|) + (QREFELT |$| 57))) + ((QUOTE T) (QUOTE NIL))) + (LETT #1# (CONS |k| #1#) |ES-;distribute;3S;39|))))) + (LETT #2# (CDR #2#) |ES-;distribute;3S;39|) + (GO G190) + G191 + (EXIT (NREVERSE0 #1#)))) + |x| + |$|)))))) + +(DEFUN |ES-;eval;SLS;40| (|f| |leq| |$|) + (PROG (|rec|) + (RETURN + (SEQ + (LETT |rec| (|ES-;mkKerLists| |leq| |$|) |ES-;eval;SLS;40|) + (EXIT (SPADCALL |f| (QCAR |rec|) (QCDR |rec|) (QREFELT |$| 117))))))) + +(DEFUN |ES-;subst;SLS;41| (|f| |leq| |$|) + (PROG (|rec|) + (RETURN + (SEQ + (LETT |rec| (|ES-;mkKerLists| |leq| |$|) |ES-;subst;SLS;41|) + (EXIT (SPADCALL |f| (QCAR |rec|) (QCDR |rec|) (QREFELT |$| 119))))))) + +(DEFUN |ES-;mkKerLists| (|leq| |$|) + (PROG (|eq| #1=#:G82530 |k| |lk| |lv|) + (RETURN + (SEQ + (LETT |lk| NIL |ES-;mkKerLists|) + (LETT |lv| NIL |ES-;mkKerLists|) + (SEQ + (LETT |eq| NIL |ES-;mkKerLists|) + (LETT #1# |leq| |ES-;mkKerLists|) + G190 + (COND + ((OR (ATOM #1#) (PROGN (LETT |eq| (CAR #1#) |ES-;mkKerLists|) NIL)) + (GO G191))) + (SEQ + (LETT |k| + (SPADCALL (SPADCALL |eq| (QREFELT |$| 122)) (QREFELT |$| 111)) + |ES-;mkKerLists|) + (EXIT + (COND + ((QEQCAR |k| 1) (|error| "left hand side must be a single kernel")) + ((NULL (SPADCALL (QCDR |k|) |lk| (QREFELT |$| 57))) + (SEQ + (LETT |lk| (CONS (QCDR |k|) |lk|) |ES-;mkKerLists|) + (EXIT + (LETT |lv| + (CONS (SPADCALL |eq| (QREFELT |$| 123)) |lv|) + |ES-;mkKerLists|))))))) + (LETT #1# (CDR #1#) |ES-;mkKerLists|) + (GO G190) + G191 + (EXIT NIL)) + (EXIT (CONS |lk| |lv|)))))) + +(DEFUN |ES-;even?;SB;43| (|x| |$|) + (|ES-;intpred?| |x| (ELT |$| 125) |$|)) + +(DEFUN |ES-;odd?;SB;44| (|x| |$|) + (|ES-;intpred?| |x| (ELT |$| 127) |$|)) + +(DEFUN |ES-;intpred?| (|x| |pred?| |$|) + (PROG (|u|) + (RETURN + (SEQ + (LETT |u| (SPADCALL |x| (QREFELT |$| 130)) |ES-;intpred?|) + (EXIT + (COND + ((QEQCAR |u| 0) (SPADCALL (QCDR |u|) |pred?|)) + ((QUOTE T) (QUOTE NIL)))))))) + +(DEFUN |ExpressionSpace&| (|#1|) + (PROG (|DV$1| |dv$| |$| |pv$|) + (RETURN + (PROGN + (LETT |DV$1| (|devaluate| |#1|) . #1=(|ExpressionSpace&|)) + (LETT |dv$| (LIST (QUOTE |ExpressionSpace&|) |DV$1|) . #1#) + (LETT |$| (GETREFV 131) . #1#) + (QSETREFV |$| 0 |dv$|) + (QSETREFV |$| 3 + (LETT |pv$| + (|buildPredVector| 0 0 + (LIST + (|HasCategory| |#1| (QUOTE (|RetractableTo| (|Integer|)))) + (|HasCategory| |#1| (QUOTE (|Ring|))))) . #1#)) + (|stuffDomainSlots| |$|) + (QSETREFV |$| 6 |#1|) + (QSETREFV |$| 13 + (SPADCALL (SPADCALL "%paren" (QREFELT |$| 9)) (QREFELT |$| 12))) + (QSETREFV |$| 14 + (SPADCALL (SPADCALL "%box" (QREFELT |$| 9)) (QREFELT |$| 12))) + (COND + ((|testBitVector| |pv$| 1) + (PROGN + (QSETREFV |$| 126 (CONS (|dispatchFunction| |ES-;even?;SB;43|) |$|)) + (QSETREFV |$| 128 (CONS (|dispatchFunction| |ES-;odd?;SB;44|) |$|))))) + |$|)))) + +(MAKEPROP + (QUOTE |ExpressionSpace&|) + (QUOTE |infovec|) + (LIST + (QUOTE #( + NIL NIL NIL NIL NIL NIL (|local| |#1|) (|String|) (|Symbol|) + (0 . |coerce|) (|BasicOperator|) (|CommonOperators|) (5 . |operator|) + (QUOTE |oppren|) (QUOTE |opbox|) (|List| |$|) (10 . |box|) + |ES-;box;2S;1| (15 . |paren|) |ES-;paren;2S;2| (|Boolean|) + (20 . |=|) |ES-;belong?;BoB;3| (|List| 34) (|Set| 34) + (26 . |parts|) (31 . |sort!|) (|List| 55) |ES-;tower;SL;5| + (36 . |brace|) (41 . |union|) (|Mapping| 24 24 24) (|List| 24) + (47 . |reduce|) (|Kernel| 6) (54 . |operator|) (|List| 10) + |ES-;operators;SL;7| (59 . |kernels|) (|NonNegativeInteger|) + (64 . |height|) (69 . |max|) (|Mapping| 39 39 39) (|List| 39) + (75 . |reduce|) |ES-;height;SNni;8| (82 . |name|) (|List| 8) + (87 . |member?|) |ES-;freeOf?;SSB;9| (93 . |is?|) + |ES-;distribute;2S;10| (99 . |elt|) |ES-;box;LS;11| + |ES-;paren;LS;12| (|Kernel| |$|) (105 . |retract|) + (110 . |member?|) |ES-;freeOf?;2SB;13| (116 . |kernel|) + |ES-;kernel;Bo2S;14| |ES-;elt;Bo2S;15| |ES-;elt;Bo3S;16| + |ES-;elt;Bo4S;17| |ES-;elt;Bo5S;18| (|Mapping| |$| 15) + (|List| 65) (122 . |eval|) |ES-;eval;SSMS;19| (129 . |name|) + |ES-;eval;SBoMS;20| (|List| 6) (134 . |first|) + (|Mapping| |$| |$|) |ES-;eval;SSMS;21| (139 . |eval|) + |ES-;eval;SBoMS;22| (|List| 79) (146 . |subst|) (|Equation| |$|) + |ES-;subst;SES;23| (|List| 73) |ES-;eval;SLLS;24| + |ES-;eval;SLLS;25| |ES-;eval;SLLS;26| (152 . |argument|) + (157 . |=|) (163 . |coerce|) |ES-;map;MKS;27| (168 . |is?|) + |ES-;operator;2Bo;28| (|Union| 55 (QUOTE "failed")) + |ES-;mainKernel;SU;29| (|Union| (|None|) (QUOTE "failed")) + (174 . |property|) (180 . |second|) (185 . |remove!|) + (191 . |belong?|) |ES-;kernel;BoLS;31| (196 . |height|) + (201 . |kernel|) (|Union| 39 (QUOTE "failed")) (208 . |arity|) + (|Union| 6 (QUOTE "failed")) (|BasicOperatorFunctions1| 6) + (213 . |evaluate|) |ES-;elt;BoLS;33| (219 . |mainKernel|) + (224 . |=|) |ES-;retract;SK;34| |ES-;retractIfCan;SU;35| + (230 . |retractIfCan|) (235 . |is?|) |ES-;is?;SSB;36| + |ES-;is?;SBoB;37| (241 . |eval|) |ES-;distribute;3S;39| + (248 . |eval|) |ES-;eval;SLS;40| (255 . |subst|) + |ES-;subst;SLS;41| (|Equation| 6) (262 . |lhs|) (267 . |rhs|) + (|Integer|) (272 . |even?|) (277 . |even?|) (282 . |odd?|) + (287 . |odd?|) (|Union| 124 (QUOTE "failed")) (292 . |retractIfCan|))) + (QUOTE #( + |tower| 297 |subst| 302 |retractIfCan| 314 |retract| 319 |paren| 324 + |operators| 334 |operator| 339 |odd?| 344 |map| 349 |mainKernel| 355 + |kernel| 360 |is?| 372 |height| 384 |freeOf?| 389 |even?| 401 |eval| 406 + |elt| 461 |distribute| 497 |box| 508 |belong?| 518)) + (QUOTE NIL) + (CONS + (|makeByteWordVec2| 1 (QUOTE NIL)) + (CONS + (QUOTE #()) + (CONS + (QUOTE #()) + (|makeByteWordVec2| 130 (QUOTE + (1 8 0 7 9 1 11 10 8 12 1 6 0 15 16 1 6 0 15 18 2 10 20 0 0 21 1 24 + 23 0 25 1 23 0 0 26 1 24 0 23 29 2 24 0 0 0 30 3 32 24 31 0 24 33 + 1 34 10 0 35 1 6 27 0 38 1 34 39 0 40 2 39 0 0 0 41 3 43 39 42 0 + 39 44 1 34 8 0 46 2 47 20 8 0 48 2 34 20 0 10 50 2 6 0 10 15 52 1 + 6 55 0 56 2 23 20 34 0 57 2 6 0 10 15 59 3 6 0 0 47 66 67 1 10 8 + 0 69 1 71 6 0 72 3 6 0 0 36 66 75 2 6 0 0 77 78 1 34 71 0 85 2 71 + 20 0 0 86 1 6 0 55 87 2 10 20 0 8 89 2 10 93 0 7 94 1 71 6 0 95 + 2 24 0 34 0 96 1 6 20 10 97 1 6 39 0 99 3 34 0 10 71 39 100 1 10 + 101 0 102 2 104 103 10 71 105 1 6 91 0 107 2 6 20 0 0 108 1 6 91 + 0 111 2 34 20 0 8 112 3 6 0 0 55 0 115 3 6 0 0 27 15 117 3 6 0 0 + 27 15 119 1 121 6 0 122 1 121 6 0 123 1 124 20 0 125 1 0 20 0 126 + 1 124 20 0 127 1 0 20 0 128 1 6 129 0 130 1 0 27 0 28 2 0 0 0 77 + 120 2 0 0 0 79 80 1 0 91 0 110 1 0 55 0 109 1 0 0 0 19 1 0 0 15 + 54 1 0 36 0 37 1 0 10 10 90 1 0 20 0 128 2 0 0 73 55 88 1 0 91 0 + 92 2 0 0 10 15 98 2 0 0 10 0 60 2 0 20 0 8 113 2 0 20 0 10 114 1 + 0 39 0 45 2 0 20 0 8 49 2 0 20 0 0 58 1 0 20 0 126 3 0 0 0 10 73 + 76 3 0 0 0 36 66 84 3 0 0 0 10 65 70 3 0 0 0 36 81 82 3 0 0 0 8 + 65 68 3 0 0 0 8 73 74 3 0 0 0 47 81 83 2 0 0 0 77 118 2 0 0 10 + 15 106 5 0 0 10 0 0 0 0 64 3 0 0 10 0 0 62 4 0 0 10 0 0 0 63 2 + 0 0 10 0 61 2 0 0 0 0 116 1 0 0 0 51 1 0 0 15 53 1 0 0 0 17 1 0 + 20 10 22)))))) + (QUOTE |lookupComplete|))) +@ \section{EUCDOM.lsp BOOTSTRAP} {\bf EUCDOM} depends on {\bf INT} which depends on {\bf EUCDOM}. We need to break this cycle to build @@ -41816,6 +45099,500 @@ Note that this code is not included in the generated catdef.spad file. (QUOTE |lookupComplete|))) @ +\section{QFCAT.lsp BOOTSTRAP} +{\bf QFCAT} depends on a chain of files. We need to break this cycle to build +the algebra. So we keep a cached copy of the translated {\bf QFCAT} +category which we can write into the {\bf MID} directory. We compile +the lisp code and copy the {\bf QFCAT.o} file to the {\bf OUT} directory. +This is eventually forcibly replaced by a recompiled version. + +Note that this code is not included in the generated catdef.spad file. + +<>= + +(|/VERSIONCHECK| 2) + +(SETQ |QuotientFieldCategory;CAT| (QUOTE NIL)) + +(SETQ |QuotientFieldCategory;AL| (QUOTE NIL)) + +(DEFUN |QuotientFieldCategory| (#1=#:G103631) + (LET (#2=#:G103632) + (COND + ((SETQ #2# (|assoc| (|devaluate| #1#) |QuotientFieldCategory;AL|)) + (CDR #2#)) + (T + (SETQ |QuotientFieldCategory;AL| + (|cons5| + (CONS (|devaluate| #1#) (SETQ #2# (|QuotientFieldCategory;| #1#))) + |QuotientFieldCategory;AL|)) + #2#)))) + +(DEFUN |QuotientFieldCategory;| (|t#1|) + (PROG (#1=#:G103630) + (RETURN + (PROG1 + (LETT #1# + (|sublisV| + (PAIR (QUOTE (|t#1|)) (LIST (|devaluate| |t#1|))) + (COND + (|QuotientFieldCategory;CAT|) + ((QUOTE T) + (LETT |QuotientFieldCategory;CAT| + (|Join| + (|Field|) + (|Algebra| (QUOTE |t#1|)) + (|RetractableTo| (QUOTE |t#1|)) + (|FullyEvalableOver| (QUOTE |t#1|)) + (|DifferentialExtension| (QUOTE |t#1|)) + (|FullyLinearlyExplicitRingOver| (QUOTE |t#1|)) + (|Patternable| (QUOTE |t#1|)) + (|FullyPatternMatchable| (QUOTE |t#1|)) + (|mkCategory| + (QUOTE |domain|) + (QUOTE ( + ((|/| (|$| |t#1| |t#1|)) T) + ((|numer| (|t#1| |$|)) T) + ((|denom| (|t#1| |$|)) T) + ((|numerator| (|$| |$|)) T) + ((|denominator| (|$| |$|)) T) + ((|wholePart| (|t#1| |$|)) (|has| |t#1| (|EuclideanDomain|))) + ((|fractionPart| (|$| |$|)) (|has| |t#1| (|EuclideanDomain|))) + ((|random| (|$|)) (|has| |t#1| (|IntegerNumberSystem|))) + ((|ceiling| (|t#1| |$|)) (|has| |t#1| (|IntegerNumberSystem|))) + ((|floor| (|t#1| |$|)) (|has| |t#1| (|IntegerNumberSystem|))))) + (QUOTE ( + ((|StepThrough|) (|has| |t#1| (|StepThrough|))) + ((|RetractableTo| (|Integer|)) + (|has| |t#1| (|RetractableTo| (|Integer|)))) + ((|RetractableTo| (|Fraction| (|Integer|))) + (|has| |t#1| (|RetractableTo| (|Integer|)))) + ((|OrderedSet|) (|has| |t#1| (|OrderedSet|))) + ((|OrderedIntegralDomain|) (|has| |t#1| (|OrderedIntegralDomain|))) + ((|RealConstant|) (|has| |t#1| (|RealConstant|))) + ((|ConvertibleTo| (|InputForm|)) + (|has| |t#1| (|ConvertibleTo| (|InputForm|)))) + ((|CharacteristicZero|) (|has| |t#1| (|CharacteristicZero|))) + ((|CharacteristicNonZero|) (|has| |t#1| (|CharacteristicNonZero|))) + ((|RetractableTo| (|Symbol|)) + (|has| |t#1| (|RetractableTo| (|Symbol|)))) + ((|PolynomialFactorizationExplicit|) + (|has| |t#1| (|PolynomialFactorizationExplicit|))))) + (QUOTE NIL) NIL)) . #2=(|QuotientFieldCategory|))))) . #2#) + (SETELT #1# 0 + (LIST (QUOTE |QuotientFieldCategory|) (|devaluate| |t#1|))))))) +@ +\section{QFCAT-.lsp BOOTSTRAP} +{\bf QFCAT-} depends on {\bf QFCAT}. We need to break this cycle to build +the algebra. So we keep a cached copy of the translated {\bf QFCAT-} +category which we can write into the {\bf MID} directory. We compile +the lisp code and copy the {\bf QFCAT-.o} file to the {\bf OUT} directory. +This is eventually forcibly replaced by a recompiled version. + +Note that this code is not included in the generated catdef.spad file. + +<>= + +(|/VERSIONCHECK| 2) + +(DEFUN |QFCAT-;numerator;2A;1| (|x| |$|) + (SPADCALL (SPADCALL |x| (QREFELT |$| 8)) (QREFELT |$| 9))) + +(DEFUN |QFCAT-;denominator;2A;2| (|x| |$|) + (SPADCALL (SPADCALL |x| (QREFELT |$| 11)) (QREFELT |$| 9))) + +(DEFUN |QFCAT-;init;A;3| (|$|) + (SPADCALL (|spadConstant| |$| 13) (|spadConstant| |$| 14) (QREFELT |$| 15))) + +(DEFUN |QFCAT-;nextItem;AU;4| (|n| |$|) + (PROG (|m|) + (RETURN + (SEQ + (LETT |m| + (SPADCALL + (SPADCALL |n| (QREFELT |$| 8)) + (QREFELT |$| 18)) + |QFCAT-;nextItem;AU;4|) + (EXIT + (COND + ((QEQCAR |m| 1) + (|error| "We seem to have a Fraction of a finite object")) + ((QUOTE T) + (CONS 0 + (SPADCALL (QCDR |m|) (|spadConstant| |$| 14) (QREFELT |$| 15)))))))))) + +(DEFUN |QFCAT-;map;M2A;5| (|fn| |x| |$|) + (SPADCALL + (SPADCALL (SPADCALL |x| (QREFELT |$| 8)) |fn|) + (SPADCALL (SPADCALL |x| (QREFELT |$| 11)) |fn|) + (QREFELT |$| 15))) + +(DEFUN |QFCAT-;reducedSystem;MM;6| (|m| |$|) + (SPADCALL |m| (QREFELT |$| 26))) + +(DEFUN |QFCAT-;characteristic;Nni;7| (|$|) + (SPADCALL (QREFELT |$| 30))) + +(DEFUN |QFCAT-;differentiate;AMA;8| (|x| |deriv| |$|) + (PROG (|n| |d|) + (RETURN + (SEQ + (LETT |n| (SPADCALL |x| (QREFELT |$| 8)) |QFCAT-;differentiate;AMA;8|) + (LETT |d| (SPADCALL |x| (QREFELT |$| 11)) |QFCAT-;differentiate;AMA;8|) + (EXIT + (SPADCALL + (SPADCALL + (SPADCALL (SPADCALL |n| |deriv|) |d| (QREFELT |$| 32)) + (SPADCALL |n| (SPADCALL |d| |deriv|) (QREFELT |$| 32)) + (QREFELT |$| 33)) + (SPADCALL |d| 2 (QREFELT |$| 35)) (QREFELT |$| 15))))))) + +(DEFUN |QFCAT-;convert;AIf;9| (|x| |$|) + (SPADCALL + (SPADCALL (SPADCALL |x| (QREFELT |$| 8)) (QREFELT |$| 38)) + (SPADCALL (SPADCALL |x| (QREFELT |$| 11)) (QREFELT |$| 38)) + (QREFELT |$| 39))) + +(DEFUN |QFCAT-;convert;AF;10| (|x| |$|) + (SPADCALL + (SPADCALL (SPADCALL |x| (QREFELT |$| 8)) (QREFELT |$| 42)) + (SPADCALL (SPADCALL |x| (QREFELT |$| 11)) (QREFELT |$| 42)) + (QREFELT |$| 43))) + +(DEFUN |QFCAT-;convert;ADf;11| (|x| |$|) + (|/| + (SPADCALL (SPADCALL |x| (QREFELT |$| 8)) (QREFELT |$| 46)) + (SPADCALL (SPADCALL |x| (QREFELT |$| 11)) (QREFELT |$| 46)))) + +(DEFUN |QFCAT-;<;2AB;12| (|x| |y| |$|) + (SPADCALL + (SPADCALL + (SPADCALL |x| (QREFELT |$| 8)) + (SPADCALL |y| (QREFELT |$| 11)) + (QREFELT |$| 32)) + (SPADCALL + (SPADCALL |y| (QREFELT |$| 8)) + (SPADCALL |x| (QREFELT |$| 11)) + (QREFELT |$| 32)) + (QREFELT |$| 49))) + +(DEFUN |QFCAT-;<;2AB;13| (|x| |y| |$|) + (PROG (|#G19| |#G20| |#G21| |#G22|) + (RETURN + (SEQ + (COND + ((SPADCALL + (SPADCALL |x| (QREFELT |$| 11)) + (|spadConstant| |$| 51) + (QREFELT |$| 49)) + (PROGN + (LETT |#G19| |y| |QFCAT-;<;2AB;13|) + (LETT |#G20| |x| |QFCAT-;<;2AB;13|) + (LETT |x| |#G19| |QFCAT-;<;2AB;13|) + (LETT |y| |#G20| |QFCAT-;<;2AB;13|)))) + (COND + ((SPADCALL + (SPADCALL |y| (QREFELT |$| 11)) + (|spadConstant| |$| 51) + (QREFELT |$| 49)) + (PROGN + (LETT |#G21| |y| |QFCAT-;<;2AB;13|) + (LETT |#G22| |x| |QFCAT-;<;2AB;13|) + (LETT |x| |#G21| |QFCAT-;<;2AB;13|) + (LETT |y| |#G22| |QFCAT-;<;2AB;13|)))) + (EXIT + (SPADCALL + (SPADCALL + (SPADCALL |x| (QREFELT |$| 8)) + (SPADCALL |y| (QREFELT |$| 11)) + (QREFELT |$| 32)) + (SPADCALL + (SPADCALL |y| (QREFELT |$| 8)) + (SPADCALL |x| (QREFELT |$| 11)) + (QREFELT |$| 32)) + (QREFELT |$| 49))))))) + +(DEFUN |QFCAT-;<;2AB;14| (|x| |y| |$|) + (SPADCALL + (SPADCALL + (SPADCALL |x| (QREFELT |$| 8)) + (SPADCALL |y| (QREFELT |$| 11)) + (QREFELT |$| 32)) + (SPADCALL + (SPADCALL |y| (QREFELT |$| 8)) + (SPADCALL |x| (QREFELT |$| 11)) + (QREFELT |$| 32)) + (QREFELT |$| 49))) + +(DEFUN |QFCAT-;fractionPart;2A;15| (|x| |$|) + (SPADCALL |x| + (SPADCALL (SPADCALL |x| (QREFELT |$| 52)) (QREFELT |$| 9)) + (QREFELT |$| 53))) + +(DEFUN |QFCAT-;coerce;SA;16| (|s| |$|) + (SPADCALL (SPADCALL |s| (QREFELT |$| 56)) (QREFELT |$| 9))) + +(DEFUN |QFCAT-;retract;AS;17| (|x| |$|) + (SPADCALL (SPADCALL |x| (QREFELT |$| 58)) (QREFELT |$| 59))) + +(DEFUN |QFCAT-;retractIfCan;AU;18| (|x| |$|) + (PROG (|r|) + (RETURN + (SEQ + (LETT |r| (SPADCALL |x| (QREFELT |$| 62)) |QFCAT-;retractIfCan;AU;18|) + (EXIT + (COND + ((QEQCAR |r| 1) (CONS 1 "failed")) + ((QUOTE T) (SPADCALL (QCDR |r|) (QREFELT |$| 64))))))))) + +(DEFUN |QFCAT-;convert;AP;19| (|x| |$|) + (SPADCALL + (SPADCALL (SPADCALL |x| (QREFELT |$| 8)) (QREFELT |$| 67)) + (SPADCALL (SPADCALL |x| (QREFELT |$| 11)) (QREFELT |$| 67)) + (QREFELT |$| 68))) + +(DEFUN |QFCAT-;patternMatch;AP2Pmr;20| (|x| |p| |l| |$|) + (SPADCALL |x| |p| |l| (QREFELT |$| 72))) + +(DEFUN |QFCAT-;convert;AP;21| (|x| |$|) + (SPADCALL + (SPADCALL (SPADCALL |x| (QREFELT |$| 8)) (QREFELT |$| 76)) + (SPADCALL (SPADCALL |x| (QREFELT |$| 11)) (QREFELT |$| 76)) + (QREFELT |$| 77))) + +(DEFUN |QFCAT-;patternMatch;AP2Pmr;22| (|x| |p| |l| |$|) + (SPADCALL |x| |p| |l| (QREFELT |$| 81))) + +(DEFUN |QFCAT-;coerce;FA;23| (|x| |$|) + (SPADCALL + (SPADCALL (SPADCALL |x| (QREFELT |$| 86)) (QREFELT |$| 87)) + (SPADCALL (SPADCALL |x| (QREFELT |$| 88)) (QREFELT |$| 87)) + (QREFELT |$| 89))) + +(DEFUN |QFCAT-;retract;AI;24| (|x| |$|) + (SPADCALL (SPADCALL |x| (QREFELT |$| 58)) (QREFELT |$| 91))) + +(DEFUN |QFCAT-;retractIfCan;AU;25| (|x| |$|) + (PROG (|u|) + (RETURN + (SEQ + (LETT |u| (SPADCALL |x| (QREFELT |$| 62)) |QFCAT-;retractIfCan;AU;25|) + (EXIT + (COND + ((QEQCAR |u| 1) (CONS 1 "failed")) + ((QUOTE T) (SPADCALL (QCDR |u|) (QREFELT |$| 94))))))))) + +(DEFUN |QFCAT-;random;A;26| (|$|) + (PROG (|d|) + (RETURN + (SEQ + (SEQ + G190 + (COND + ((NULL + (SPADCALL + (LETT |d| (SPADCALL (QREFELT |$| 96)) |QFCAT-;random;A;26|) + (QREFELT |$| 97))) + (GO G191))) + (SEQ (EXIT |d|)) + NIL + (GO G190) + G191 + (EXIT NIL)) + (EXIT (SPADCALL (SPADCALL (QREFELT |$| 96)) |d| (QREFELT |$| 15))))))) + +(DEFUN |QFCAT-;reducedSystem;MVR;27| (|m| |v| |$|) + (PROG (|n|) + (RETURN + (SEQ + (LETT |n| + (SPADCALL + (SPADCALL (SPADCALL |v| (QREFELT |$| 100)) |m| (QREFELT |$| 101)) + (QREFELT |$| 102)) + |QFCAT-;reducedSystem;MVR;27|) + (EXIT + (CONS + (SPADCALL |n| + (SPADCALL |n| (QREFELT |$| 103)) + (SPADCALL |n| (QREFELT |$| 104)) + (|+| 1 (SPADCALL |n| (QREFELT |$| 105))) + (SPADCALL |n| (QREFELT |$| 106)) + (QREFELT |$| 107)) + (SPADCALL |n| (SPADCALL |n| (QREFELT |$| 105)) (QREFELT |$| 109)))))))) + +(DEFUN |QuotientFieldCategory&| (|#1| |#2|) + (PROG (|DV$1| |DV$2| |dv$| |$| |pv$|) + (RETURN + (PROGN + (LETT |DV$1| (|devaluate| |#1|) . #1=(|QuotientFieldCategory&|)) + (LETT |DV$2| (|devaluate| |#2|) . #1#) + (LETT |dv$| (LIST (QUOTE |QuotientFieldCategory&|) |DV$1| |DV$2|) . #1#) + (LETT |$| (GETREFV 119) . #1#) + (QSETREFV |$| 0 |dv$|) + (QSETREFV |$| 3 + (LETT |pv$| + (|buildPredVector| 0 0 (LIST + (|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|))))) . #1#)) + (|stuffDomainSlots| |$|) + (QSETREFV |$| 6 |#1|) + (QSETREFV |$| 7 |#2|) + (COND + ((|testBitVector| |pv$| 12) + (PROGN + (QSETREFV |$| 16 (CONS (|dispatchFunction| |QFCAT-;init;A;3|) |$|)) + (QSETREFV |$| 20 + (CONS (|dispatchFunction| |QFCAT-;nextItem;AU;4|) |$|))))) + (COND + ((|testBitVector| |pv$| 7) + (QSETREFV |$| 40 + (CONS (|dispatchFunction| |QFCAT-;convert;AIf;9|) |$|)))) + (COND + ((|testBitVector| |pv$| 8) + (PROGN + (QSETREFV |$| 44 + (CONS (|dispatchFunction| |QFCAT-;convert;AF;10|) |$|)) + (QSETREFV |$| 47 + (CONS (|dispatchFunction| |QFCAT-;convert;ADf;11|) |$|))))) + (COND + ((|testBitVector| |pv$| 9) + (COND + ((|HasAttribute| |#2| (QUOTE |canonicalUnitNormal|)) + (QSETREFV |$| 50 (CONS (|dispatchFunction| |QFCAT-;<;2AB;12|) |$|))) + ((QUOTE T) + (QSETREFV |$| 50 (CONS (|dispatchFunction| |QFCAT-;<;2AB;13|) |$|))))) + ((|testBitVector| |pv$| 10) + (QSETREFV |$| 50 (CONS (|dispatchFunction| |QFCAT-;<;2AB;14|) |$|)))) + (COND + ((|testBitVector| |pv$| 3) + (QSETREFV |$| 54 + (CONS (|dispatchFunction| |QFCAT-;fractionPart;2A;15|) |$|)))) + (COND + ((|testBitVector| |pv$| 4) + (PROGN + (QSETREFV |$| 57 (CONS (|dispatchFunction| |QFCAT-;coerce;SA;16|) |$|)) + (QSETREFV |$| 60 (CONS (|dispatchFunction| |QFCAT-;retract;AS;17|) |$|)) + (QSETREFV |$| 65 + (CONS (|dispatchFunction| |QFCAT-;retractIfCan;AU;18|) |$|))))) + (COND + ((|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Pattern| (|Integer|))))) + (PROGN + (QSETREFV |$| 69 (CONS (|dispatchFunction| |QFCAT-;convert;AP;19|) |$|)) + (COND + ((|HasCategory| |#2| (QUOTE (|PatternMatchable| (|Integer|)))) + (QSETREFV |$| 74 + (CONS + (|dispatchFunction| |QFCAT-;patternMatch;AP2Pmr;20|) |$|))))))) + (COND + ((|HasCategory| |#2| (QUOTE (|ConvertibleTo| (|Pattern| (|Float|))))) + (PROGN + (QSETREFV |$| 78 (CONS (|dispatchFunction| |QFCAT-;convert;AP;21|) |$|)) + (COND + ((|HasCategory| |#2| (QUOTE (|PatternMatchable| (|Float|)))) + (QSETREFV |$| 83 + (CONS (|dispatchFunction| |QFCAT-;patternMatch;AP2Pmr;22|) |$|))))))) + (COND + ((|testBitVector| |pv$| 11) + (PROGN + (QSETREFV |$| 90 (CONS (|dispatchFunction| |QFCAT-;coerce;FA;23|) |$|)) + (COND + ((|domainEqual| |#2| (|Integer|))) + ((QUOTE T) + (PROGN + (QSETREFV |$| 92 + (CONS (|dispatchFunction| |QFCAT-;retract;AI;24|) |$|)) + (QSETREFV |$| 95 + (CONS (|dispatchFunction| |QFCAT-;retractIfCan;AU;25|) |$|)))))))) + (COND + ((|testBitVector| |pv$| 2) + (QSETREFV |$| 98 (CONS (|dispatchFunction| |QFCAT-;random;A;26|) |$|)))) + |$|)))) + +(MAKEPROP + (QUOTE |QuotientFieldCategory&|) + (QUOTE |infovec|) + (LIST + (QUOTE #(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|) + (0 . |numer|) (5 . |coerce|) |QFCAT-;numerator;2A;1| (10 . |denom|) + |QFCAT-;denominator;2A;2| (15 . |init|) (19 . |One|) (23 . |/|) + (29 . |init|) (|Union| |$| (QUOTE "failed")) (33 . |nextItem|) + (38 . |One|) (42 . |nextItem|) (|Mapping| 7 7) |QFCAT-;map;M2A;5| + (|Matrix| 7) (|Matrix| 6) (|MatrixCommonDenominator| 7 6) + (47 . |clearDenominator|) (|Matrix| |$|) |QFCAT-;reducedSystem;MM;6| + (|NonNegativeInteger|) (52 . |characteristic|) + |QFCAT-;characteristic;Nni;7| (56 . |*|) (62 . |-|) + (|PositiveInteger|) (68 . |**|) |QFCAT-;differentiate;AMA;8| + (|InputForm|) (74 . |convert|) (79 . |/|) (85 . |convert|) + (|Float|) (90 . |convert|) (95 . |/|) (101 . |convert|) + (|DoubleFloat|) (106 . |convert|) (111 . |convert|) (|Boolean|) + (116 . |<|) (122 . |<|) (128 . |Zero|) (132 . |wholePart|) + (137 . |-|) (143 . |fractionPart|) (|Symbol|) (148 . |coerce|) + (153 . |coerce|) (158 . |retract|) (163 . |retract|) + (168 . |retract|) (|Union| 7 (QUOTE "failed")) (173 . |retractIfCan|) + (|Union| 55 (QUOTE "failed")) (178 . |retractIfCan|) + (183 . |retractIfCan|) (|Pattern| 84) (188 . |convert|) + (193 . |/|) (199 . |convert|) (|PatternMatchResult| 84 6) + (|PatternMatchQuotientFieldCategory| 84 7 6) (204 . |patternMatch|) + (|PatternMatchResult| 84 |$|) (211 . |patternMatch|) (|Pattern| 41) + (218 . |convert|) (223 . |/|) (229 . |convert|) + (|PatternMatchResult| 41 6) + (|PatternMatchQuotientFieldCategory| 41 7 6) (234 . |patternMatch|) + (|PatternMatchResult| 41 |$|) (241 . |patternMatch|) (|Integer|) + (|Fraction| 84) (248 . |numer|) (253 . |coerce|) (258 . |denom|) + (263 . |/|) (269 . |coerce|) (274 . |retract|) (279 . |retract|) + (|Union| 84 (QUOTE "failed")) (284 . |retractIfCan|) + (289 . |retractIfCan|) (294 . |random|) (298 . |zero?|) + (303 . |random|) (|Vector| 6) (307 . |coerce|) (312 . |horizConcat|) + (318 . |reducedSystem|) (323 . |minRowIndex|) (328 . |maxRowIndex|) + (333 . |minColIndex|) (338 . |maxColIndex|) (343 . |subMatrix|) + (|Vector| 7) (352 . |column|) (|Record| (|:| |mat| 23) + (|:| |vec| 108)) (|Vector| |$|) |QFCAT-;reducedSystem;MVR;27| + (|Union| 85 (QUOTE "failed")) (|Record| (|:| |mat| 115) + (|:| |vec| (|Vector| 84))) (|Matrix| 84) (|List| 55) (|List| 29) + (|OutputForm|))) + (QUOTE #(|retractIfCan| 358 |retract| 368 |reducedSystem| 378 + |random| 389 |patternMatch| 393 |numerator| 407 |nextItem| 412 + |map| 417 |init| 423 |fractionPart| 427 |differentiate| 432 + |denominator| 438 |convert| 443 |coerce| 468 |characteristic| 478 + |<| 482)) + (QUOTE NIL) + (CONS + (|makeByteWordVec2| 1 (QUOTE NIL)) + (CONS + (QUOTE #()) + (CONS (QUOTE #()) + (|makeByteWordVec2| 112 (QUOTE + (1 6 7 0 8 1 6 0 7 9 1 6 7 0 11 0 7 0 13 0 7 0 14 2 6 0 7 7 15 0 + 0 0 16 1 7 17 0 18 0 6 0 19 1 0 17 0 20 1 25 23 24 26 0 7 29 30 2 + 7 0 0 0 32 2 7 0 0 0 33 2 7 0 0 34 35 1 7 37 0 38 2 37 0 0 0 39 1 + 0 37 0 40 1 7 41 0 42 2 41 0 0 0 43 1 0 41 0 44 1 7 45 0 46 1 0 45 + 0 47 2 7 48 0 0 49 2 0 48 0 0 50 0 7 0 51 1 6 7 0 52 2 6 0 0 0 53 1 + 0 0 0 54 1 7 0 55 56 1 0 0 55 57 1 6 7 0 58 1 7 55 0 59 1 0 55 0 60 + 1 6 61 0 62 1 7 63 0 64 1 0 63 0 65 1 7 66 0 67 2 66 0 0 0 68 1 0 + 66 0 69 3 71 70 6 66 70 72 3 0 73 0 66 73 74 1 7 75 0 76 2 75 0 0 + 0 77 1 0 75 0 78 3 80 79 6 75 79 81 3 0 82 0 75 82 83 1 85 84 0 86 + 1 6 0 84 87 1 85 84 0 88 2 6 0 0 0 89 1 0 0 85 90 1 7 84 0 91 1 0 + 84 0 92 1 7 93 0 94 1 0 93 0 95 0 7 0 96 1 7 48 0 97 0 0 0 98 1 24 + 0 99 100 2 24 0 0 0 101 1 6 23 27 102 1 23 84 0 103 1 23 84 0 104 + 1 23 84 0 105 1 23 84 0 106 5 23 0 0 84 84 84 84 107 2 23 108 0 84 + 109 1 0 93 0 95 1 0 63 0 65 1 0 84 0 92 1 0 55 0 60 2 0 110 27 111 + 112 1 0 23 27 28 0 0 0 98 3 0 82 0 75 82 83 3 0 73 0 66 73 74 1 0 + 0 0 10 1 0 17 0 20 2 0 0 21 0 22 0 0 0 16 1 0 0 0 54 2 0 0 0 21 36 + 1 0 0 0 12 1 0 45 0 47 1 0 37 0 40 1 0 41 0 44 1 0 66 0 69 1 0 75 0 + 78 1 0 0 55 57 1 0 0 85 90 0 0 29 31 2 0 48 0 0 50)))))) + (QUOTE |lookupComplete|))) + +@ \section{RCAGG.lsp BOOTSTRAP} {\bf RCAGG} depends on a chain of files. We need to break this cycle to build the algebra. So we keep a cached copy of the translated {\bf RCAGG} @@ -45498,6 +49275,7 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> @@ -45505,16 +49283,20 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> +<> <> <> <> <> <> +<> <> <> <> <> +<> <> <> <> @@ -45593,6 +49375,7 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> @@ -45659,22 +49442,27 @@ digraph dotabb { <> <> <> +<> <> <> <> <> <> <> +<> <> +<> <> <> <> <> <> +<> <> <> <> <> +<> <> <> <> @@ -45752,6 +49540,7 @@ digraph dotabb { <> <> <> +<> <> <> <> @@ -45821,22 +49610,27 @@ digraph dotfull { <> <> <> +<> <> <> <> <> <> <> +<> <> +<> <> <> <> <> <> +<> <> <> <> <> +<> <> <> <> @@ -45914,6 +49708,7 @@ digraph dotfull { <> <> <> +<> <> <> <> diff --git a/books/ps/v102combinatorialopscategory.ps b/books/ps/v102combinatorialopscategory.ps new file mode 100644 index 0000000..e927780 --- /dev/null +++ b/books/ps/v102combinatorialopscategory.ps @@ -0,0 +1,335 @@ +%!PS-Adobe-2.0 +%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006) +%%For: (root) root +%%Title: pic +%%Pages: (atend) +%%BoundingBox: 36 36 250 224 +%%EndComments +save +%%BeginProlog +/DotDict 200 dict def +DotDict begin + +/setupLatin1 { +mark +/EncodingVector 256 array def + EncodingVector 0 + +ISOLatin1Encoding 0 255 getinterval putinterval +EncodingVector 45 /hyphen put + +% Set up ISO Latin 1 character encoding +/starnetISO { + dup dup findfont dup length dict begin + { 1 index /FID ne { def }{ pop pop } ifelse + } forall + /Encoding EncodingVector def + currentdict end definefont +} def +/Times-Roman starnetISO def +/Times-Italic starnetISO def +/Times-Bold starnetISO def +/Times-BoldItalic starnetISO def +/Helvetica starnetISO def +/Helvetica-Oblique starnetISO def +/Helvetica-Bold starnetISO def +/Helvetica-BoldOblique starnetISO def +/Courier starnetISO def +/Courier-Oblique starnetISO def +/Courier-Bold starnetISO def +/Courier-BoldOblique starnetISO def +cleartomark +} bind def + +%%BeginResource: procset graphviz 0 0 +/coord-font-family /Times-Roman def +/default-font-family /Times-Roman def +/coordfont coord-font-family findfont 8 scalefont def + +/InvScaleFactor 1.0 def +/set_scale { + dup 1 exch div /InvScaleFactor exch def + dup scale +} bind def + +% styles +/solid { [] 0 setdash } bind def +/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def +/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def +/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def +/bold { 2 setlinewidth } bind def +/filled { } bind def +/unfilled { } bind def +/rounded { } bind def +/diagonals { } bind def + +% hooks for setting color +/nodecolor { sethsbcolor } bind def +/edgecolor { sethsbcolor } bind def +/graphcolor { sethsbcolor } bind def +/nopcolor {pop pop pop} bind def + +/beginpage { % i j npages + /npages exch def + /j exch def + /i exch def + /str 10 string def + npages 1 gt { + gsave + coordfont setfont + 0 0 moveto + (\() show i str cvs show (,) show j str cvs show (\)) show + grestore + } if +} bind def + +/set_font { + findfont exch + scalefont setfont +} def + +% draw aligned label in bounding box aligned to current point +/alignedtext { % width adj text + /text exch def + /adj exch def + /width exch def + gsave + width 0 gt { + text stringwidth pop adj mul 0 rmoveto + } if + [] 0 setdash + text show + grestore +} def + +/boxprim { % xcorner ycorner xsize ysize + 4 2 roll + moveto + 2 copy + exch 0 rlineto + 0 exch rlineto + pop neg 0 rlineto + closepath +} bind def + +/ellipse_path { + /ry exch def + /rx exch def + /y exch def + /x exch def + matrix currentmatrix + newpath + x y translate + rx ry scale + 0 0 1 0 360 arc + setmatrix +} bind def + +/endpage { showpage } bind def +/showpage { } def + +/layercolorseq + [ % layer color sequence - darkest to lightest + [0 0 0] + [.2 .8 .8] + [.4 .8 .8] + [.6 .8 .8] + [.8 .8 .8] + ] +def + +/layerlen layercolorseq length def + +/setlayer {/maxlayer exch def /curlayer exch def + layercolorseq curlayer 1 sub layerlen mod get + aload pop sethsbcolor + /nodecolor {nopcolor} def + /edgecolor {nopcolor} def + /graphcolor {nopcolor} def +} bind def + +/onlayer { curlayer ne {invis} if } def + +/onlayers { + /myupper exch def + /mylower exch def + curlayer mylower lt + curlayer myupper gt + or + {invis} if +} def + +/curlayer 0 def + +%%EndResource +%%EndProlog +%%BeginSetup +14 default-font-family set_font +1 setmiterlimit +% /arrowlength 10 def +% /arrowwidth 5 def + +% make sure pdfmark is harmless for PS-interpreters other than Distiller +/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse +% make '<<' and '>>' safe on PS Level 1 devices +/languagelevel where {pop languagelevel}{1} ifelse +2 lt { + userdict (<<) cvn ([) cvn load put + userdict (>>) cvn ([) cvn load put +} if + +%%EndSetup +%%Page: 1 1 +%%PageBoundingBox: 36 36 250 224 +%%PageOrientation: Portrait +gsave +36 36 214 188 boxprim clip newpath +36 36 translate +0 0 1 beginpage +1.0000 set_scale +4 4 translate 0 rotate +0.167 0.600 1.000 graphcolor +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 186 lineto +212 186 lineto +212 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 186 lineto +212 186 lineto +212 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% CombinatorialOpsCategory() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 193 180 moveto +13 180 lineto +13 144 lineto +193 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 193 180 moveto +13 180 lineto +13 144 lineto +193 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +20 157 moveto +(CombinatorialOpsCategory\(\)) +[9.36 6.96 10.8 6.96 3.84 6.96 6.24 3.84 6.96 5.04 3.84 6.24 3.84 10.08 6.96 5.52 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 4.56] +xshow +end grestore +end grestore +% CombinatorialFunctionCategory() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 206 108 moveto +0 108 lineto +0 72 lineto +206 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 206 108 moveto +0 108 lineto +0 72 lineto +206 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 85 moveto +(CombinatorialFunctionCategory\(\)) +[9.36 6.96 10.8 6.96 3.84 6.96 6.24 3.84 6.96 5.04 3.84 6.24 3.84 7.44 6.96 6.96 6.24 3.84 3.84 6.96 6.96 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 4.56] +xshow +end grestore +end grestore +% CombinatorialOpsCategory()->CombinatorialFunctionCategory() +newpath 103 144 moveto +103 136 103 127 103 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 107 118 moveto +103 108 lineto +100 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 107 118 moveto +103 108 lineto +100 118 lineto +closepath +stroke +end grestore +% Category +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 137 36 moveto +69 36 lineto +69 0 lineto +137 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 137 36 moveto +69 36 lineto +69 0 lineto +137 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +77 13 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% CombinatorialFunctionCategory()->Category +newpath 103 72 moveto +103 64 103 55 103 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 107 46 moveto +103 36 lineto +100 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 107 46 moveto +103 36 lineto +100 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102differentialpolynomialcategory.ps b/books/ps/v102differentialpolynomialcategory.ps new file mode 100644 index 0000000..e8c4465 --- /dev/null +++ b/books/ps/v102differentialpolynomialcategory.ps @@ -0,0 +1,1157 @@ +%!PS-Adobe-2.0 +%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006) +%%For: (root) root +%%Title: pic +%%Pages: (atend) +%%BoundingBox: 36 36 1584 296 +%%EndComments +save +%%BeginProlog +/DotDict 200 dict def +DotDict begin + +/setupLatin1 { +mark +/EncodingVector 256 array def + EncodingVector 0 + +ISOLatin1Encoding 0 255 getinterval putinterval +EncodingVector 45 /hyphen put + +% Set up ISO Latin 1 character encoding +/starnetISO { + dup dup findfont dup length dict begin + { 1 index /FID ne { def }{ pop pop } ifelse + } forall + /Encoding EncodingVector def + currentdict end definefont +} def +/Times-Roman starnetISO def +/Times-Italic starnetISO def +/Times-Bold starnetISO def +/Times-BoldItalic starnetISO def +/Helvetica starnetISO def +/Helvetica-Oblique starnetISO def +/Helvetica-Bold starnetISO def +/Helvetica-BoldOblique starnetISO def +/Courier starnetISO def +/Courier-Oblique starnetISO def +/Courier-Bold starnetISO def +/Courier-BoldOblique starnetISO def +cleartomark +} bind def + +%%BeginResource: procset graphviz 0 0 +/coord-font-family /Times-Roman def +/default-font-family /Times-Roman def +/coordfont coord-font-family findfont 8 scalefont def + +/InvScaleFactor 1.0 def +/set_scale { + dup 1 exch div /InvScaleFactor exch def + dup scale +} bind def + +% styles +/solid { [] 0 setdash } bind def +/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def +/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def +/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def +/bold { 2 setlinewidth } bind def +/filled { } bind def +/unfilled { } bind def +/rounded { } bind def +/diagonals { } bind def + +% hooks for setting color +/nodecolor { sethsbcolor } bind def +/edgecolor { sethsbcolor } bind def +/graphcolor { sethsbcolor } bind def +/nopcolor {pop pop pop} bind def + +/beginpage { % i j npages + /npages exch def + /j exch def + /i exch def + /str 10 string def + npages 1 gt { + gsave + coordfont setfont + 0 0 moveto + (\() show i str cvs show (,) show j str cvs show (\)) show + grestore + } if +} bind def + +/set_font { + findfont exch + scalefont setfont +} def + +% draw aligned label in bounding box aligned to current point +/alignedtext { % width adj text + /text exch def + /adj exch def + /width exch def + gsave + width 0 gt { + text stringwidth pop adj mul 0 rmoveto + } if + [] 0 setdash + text show + grestore +} def + +/boxprim { % xcorner ycorner xsize ysize + 4 2 roll + moveto + 2 copy + exch 0 rlineto + 0 exch rlineto + pop neg 0 rlineto + closepath +} bind def + +/ellipse_path { + /ry exch def + /rx exch def + /y exch def + /x exch def + matrix currentmatrix + newpath + x y translate + rx ry scale + 0 0 1 0 360 arc + setmatrix +} bind def + +/endpage { showpage } bind def +/showpage { } def + +/layercolorseq + [ % layer color sequence - darkest to lightest + [0 0 0] + [.2 .8 .8] + [.4 .8 .8] + [.6 .8 .8] + [.8 .8 .8] + ] +def + +/layerlen layercolorseq length def + +/setlayer {/maxlayer exch def /curlayer exch def + layercolorseq curlayer 1 sub layerlen mod get + aload pop sethsbcolor + /nodecolor {nopcolor} def + /edgecolor {nopcolor} def + /graphcolor {nopcolor} def +} bind def + +/onlayer { curlayer ne {invis} if } def + +/onlayers { + /myupper exch def + /mylower exch def + curlayer mylower lt + curlayer myupper gt + or + {invis} if +} def + +/curlayer 0 def + +%%EndResource +%%EndProlog +%%BeginSetup +14 default-font-family set_font +1 setmiterlimit +% /arrowlength 10 def +% /arrowwidth 5 def + +% make sure pdfmark is harmless for PS-interpreters other than Distiller +/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse +% make '<<' and '>>' safe on PS Level 1 devices +/languagelevel where {pop languagelevel}{1} ifelse +2 lt { + userdict (<<) cvn ([) cvn load put + userdict (>>) cvn ([) cvn load put +} if + +%%EndSetup +%%Page: 1 1 +%%PageBoundingBox: 36 36 1584 296 +%%PageOrientation: Portrait +gsave +36 36 1548 260 boxprim clip newpath +36 36 translate +0 0 1 beginpage +1.0000 set_scale +4 4 translate 0 rotate +0.167 0.600 1.000 graphcolor +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 258 lineto +1546 258 lineto +1546 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 258 lineto +1546 258 lineto +1546 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% DifferentialPolynomialCategory(a:Ring,b:OrderedSet,c:DifferentialVariableCategory(b),d:OrderedAbelianMonoidSup) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 1108 252 moveto +424 252 lineto +424 216 lineto +1108 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 1108 252 moveto +424 252 lineto +424 216 lineto +1108 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +431 229 moveto +(DifferentialPolynomialCategory\(a:Ring,b:OrderedSet,c:DifferentialVariableCategory\(b\),d:OrderedAbelianMonoidSup\)) +[10.08 3.84 4.56 4.08 6.24 4.8 6.24 6.96 3.84 3.84 6.24 3.84 7.44 6.96 3.6 6.96 6.96 6.96 10.8 3.84 6.24 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 6.24 3.84 9.36 3.84 6.96 6.96 3.6 6.96 3.84 10.08 4.56 6.96 6.24 4.8 6.24 6.96 7.68 6 3.84 3.6 6.24 3.84 10.08 3.84 4.56 4.08 6.24 4.8 6.24 6.96 3.84 3.84 6.24 3.84 8.88 6.24 5.04 3.84 6.24 6.96 3.84 6.24 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 6.96 4.56 3.6 6.96 3.84 10.08 4.56 6.96 6.24 4.8 6.24 6.96 9.84 6.96 6.24 3.84 3.84 6.24 6.96 12.48 6.96 6.96 6.96 3.84 6.96 7.68 6.96 6.96 4.56] +xshow +end grestore +end grestore +% DifferentialExtension(a:Ring) +[ /Rect [ 78 144 262 180 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=DIFEXT) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 262 180 moveto +78 180 lineto +78 144 lineto +262 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 262 180 moveto +78 180 lineto +78 144 lineto +262 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +86 157 moveto +(DifferentialExtension\(a:Ring\)) +[10.08 3.84 4.56 4.08 6.24 4.8 6.24 6.96 3.84 3.84 6.24 3.84 8.64 6.96 3.84 6.24 6.96 5.52 3.84 6.96 6.96 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% DifferentialPolynomialCategory(a:Ring,b:OrderedSet,c:DifferentialVariableCategory(b),d:OrderedAbelianMonoidSup)->DifferentialExtension(a:Ring) +newpath 617 216 moveto +509 203 367 186 272 174 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 272 171 moveto +262 173 lineto +272 177 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 272 171 moveto +262 173 lineto +272 177 lineto +closepath +stroke +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet) +[ /Rect [ 553 144 979 180 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=POLYCAT) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 979 180 moveto +553 180 lineto +553 144 lineto +979 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 979 180 moveto +553 180 lineto +553 144 lineto +979 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +561 157 moveto +(PolynomialCategory\(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet\)) +[7.44 6.96 3.6 6.96 6.96 6.96 10.8 3.84 6.24 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 6.24 3.84 9.36 3.84 6.96 6.96 3.6 6.96 3.84 10.08 4.56 6.96 6.24 4.8 6.24 6.96 9.84 6.96 6.24 3.84 3.84 6.24 6.96 12.48 6.96 6.96 6.96 3.84 6.96 7.68 6.96 6.96 3.6 6.24 3.84 10.08 4.56 6.96 6.24 4.8 6.24 6.96 7.68 6 3.84 4.56] +xshow +end grestore +end grestore +% DifferentialPolynomialCategory(a:Ring,b:OrderedSet,c:DifferentialVariableCategory(b),d:OrderedAbelianMonoidSup)->PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet) +newpath 766 216 moveto +766 208 766 199 766 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 770 190 moveto +766 180 lineto +763 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 770 190 moveto +766 180 lineto +763 190 lineto +closepath +stroke +end grestore +% RetractableTo(OrderedSet) +[ /Rect [ 1216 144 1382 180 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=RETRACT) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 1382 180 moveto +1216 180 lineto +1216 144 lineto +1382 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 1382 180 moveto +1216 180 lineto +1216 144 lineto +1382 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +1223 157 moveto +(RetractableTo\(OrderedSet\)) +[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 10.08 4.56 6.96 6.24 4.8 6.24 6.96 7.68 6 3.84 4.56] +xshow +end grestore +end grestore +% DifferentialPolynomialCategory(a:Ring,b:OrderedSet,c:DifferentialVariableCategory(b),d:OrderedAbelianMonoidSup)->RetractableTo(OrderedSet) +newpath 899 216 moveto +994 203 1121 186 1206 174 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 1206 177 moveto +1216 173 lineto +1206 171 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 1206 177 moveto +1216 173 lineto +1206 171 lineto +closepath +stroke +end grestore +% RING... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 60 108 moveto +0 108 lineto +0 72 lineto +60 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 60 108 moveto +0 108 lineto +0 72 lineto +60 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 85 moveto +(RING...) +[9.36 4.56 9.84 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% DifferentialExtension(a:Ring)->RING... +newpath 135 144 moveto +115 134 90 121 69 111 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 70 108 moveto +60 106 lineto +67 114 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 70 108 moveto +60 106 lineto +67 114 lineto +closepath +stroke +end grestore +% DIFRING... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 162 108 moveto +78 108 lineto +78 72 lineto +162 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 162 108 moveto +78 108 lineto +78 72 lineto +162 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +85 85 moveto +(DIFRING...) +[10.08 4.56 7.68 9.36 4.56 9.84 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% DifferentialExtension(a:Ring)->DIFRING... +newpath 157 144 moveto +152 136 145 126 139 116 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 142 114 moveto +133 108 lineto +136 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 142 114 moveto +133 108 lineto +136 118 lineto +closepath +stroke +end grestore +% PDRING... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 260 108 moveto +180 108 lineto +180 72 lineto +260 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 260 108 moveto +180 108 lineto +180 72 lineto +260 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +188 85 moveto +(PDRING...) +[7.68 10.08 9.36 4.56 9.84 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% DifferentialExtension(a:Ring)->PDRING... +newpath 183 144 moveto +188 136 195 126 201 116 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 204 118 moveto +207 108 lineto +198 114 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 204 118 moveto +207 108 lineto +198 114 lineto +closepath +stroke +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->PDRING... +newpath 553 150 moveto +467 142 368 130 270 107 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 270 104 moveto +260 105 lineto +269 110 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 270 104 moveto +260 105 lineto +269 110 lineto +closepath +stroke +end grestore +% FAMR... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 344 108 moveto +278 108 lineto +278 72 lineto +344 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 344 108 moveto +278 108 lineto +278 72 lineto +344 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +286 85 moveto +(FAMR...) +[6.72 10.08 12.48 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->FAMR... +newpath 553 145 moveto +491 137 423 126 354 108 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 355 105 moveto +344 105 lineto +353 111 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 355 105 moveto +344 105 lineto +353 111 lineto +closepath +stroke +end grestore +% EVALAB... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 444 108 moveto +362 108 lineto +362 72 lineto +444 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 444 108 moveto +362 108 lineto +362 72 lineto +444 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +369 85 moveto +(EVALAB...) +[8.64 8.4 10.08 8.64 10.08 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->EVALAB... +newpath 631 144 moveto +578 135 516 124 454 108 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 455 105 moveto +444 105 lineto +453 111 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 455 105 moveto +444 105 lineto +453 111 lineto +closepath +stroke +end grestore +% IEVALAB... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 550 108 moveto +462 108 lineto +462 72 lineto +550 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 550 108 moveto +462 108 lineto +462 72 lineto +550 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +470 85 moveto +(IEVALAB...) +[4.56 8.64 8.4 10.08 8.64 10.08 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->IEVALAB... +newpath 692 144 moveto +654 135 609 123 560 108 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 561 105 moveto +550 105 lineto +559 111 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 561 105 moveto +550 105 lineto +559 111 lineto +closepath +stroke +end grestore +% RETRACT... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 658 108 moveto +568 108 lineto +568 72 lineto +658 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 658 108 moveto +568 108 lineto +568 72 lineto +658 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +576 85 moveto +(RETRACT...) +[9.36 8.64 8.64 9.36 9.36 9.36 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->RETRACT... +newpath 727 144 moveto +707 134 682 123 660 112 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 662 109 moveto +651 108 lineto +659 115 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 662 109 moveto +651 108 lineto +659 115 lineto +closepath +stroke +end grestore +% FLINEXP... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 758 108 moveto +676 108 lineto +676 72 lineto +758 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 758 108 moveto +676 108 lineto +676 72 lineto +758 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +683 85 moveto +(FLINEXP...) +[7.68 8.64 4.56 10.08 8.64 10.08 6.24 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->FLINEXP... +newpath 754 144 moveto +748 136 741 126 735 116 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 738 114 moveto +729 108 lineto +732 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 738 114 moveto +729 108 lineto +732 118 lineto +closepath +stroke +end grestore +% ORDSET... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 856 108 moveto +776 108 lineto +776 72 lineto +856 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 856 108 moveto +776 108 lineto +776 72 lineto +856 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +783 85 moveto +(ORDSET...) +[10.08 9.36 10.08 7.68 8.64 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->ORDSET... +newpath 779 144 moveto +784 136 791 126 797 116 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 800 118 moveto +803 108 lineto +794 114 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 800 118 moveto +803 108 lineto +794 114 lineto +closepath +stroke +end grestore +% GCDDOM... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 964 108 moveto +874 108 lineto +874 72 lineto +964 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 964 108 moveto +874 108 lineto +874 72 lineto +964 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +882 85 moveto +(GCDDOM...) +[10.08 9.36 10.08 10.08 10.08 12.48 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->GCDDOM... +newpath 805 144 moveto +825 134 850 123 872 112 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 873 115 moveto +881 108 lineto +870 109 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 873 115 moveto +881 108 lineto +870 109 lineto +closepath +stroke +end grestore +% PFECAT... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 1060 108 moveto +982 108 lineto +982 72 lineto +1060 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 1060 108 moveto +982 108 lineto +982 72 lineto +1060 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +990 85 moveto +(PFECAT...) +[7.68 7.68 8.64 9.12 9.36 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->PFECAT... +newpath 842 144 moveto +879 135 924 123 972 108 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 973 111 moveto +982 105 lineto +971 105 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 973 111 moveto +982 105 lineto +971 105 lineto +closepath +stroke +end grestore +% KONVERT... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 1170 108 moveto +1078 108 lineto +1078 72 lineto +1170 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 1170 108 moveto +1078 108 lineto +1078 72 lineto +1170 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +1085 85 moveto +(KONVERT...) +[9.12 10.08 10.08 10.08 8.64 8.88 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->KONVERT... +newpath 889 144 moveto +941 135 1004 124 1068 108 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 1069 111 moveto +1078 105 lineto +1067 105 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 1069 111 moveto +1078 105 lineto +1067 105 lineto +closepath +stroke +end grestore +% PATMAB... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 1272 108 moveto +1188 108 lineto +1188 72 lineto +1272 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 1272 108 moveto +1188 108 lineto +1188 72 lineto +1272 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +1195 85 moveto +(PATMAB...) +[6.48 9.36 8.64 12.48 10.08 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->PATMAB... +newpath 969 144 moveto +1033 136 1105 125 1178 108 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 1179 111 moveto +1188 106 lineto +1178 105 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 1179 111 moveto +1188 106 lineto +1178 105 lineto +closepath +stroke +end grestore +% COMRING... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 1382 108 moveto +1290 108 lineto +1290 72 lineto +1382 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 1382 108 moveto +1290 108 lineto +1290 72 lineto +1382 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +1297 85 moveto +(COMRING...) +[9.12 10.08 12.48 9.36 4.56 9.84 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet)->COMRING... +newpath 979 150 moveto +1069 142 1176 130 1280 108 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 1281 111 moveto +1290 106 lineto +1280 105 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 1281 111 moveto +1290 106 lineto +1280 105 lineto +closepath +stroke +end grestore +% RetractableTo(a:Type) +[ /Rect [ 1400 72 1540 108 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=RETRACT) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 1540 108 moveto +1400 108 lineto +1400 72 lineto +1540 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 1540 108 moveto +1400 108 lineto +1400 72 lineto +1540 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +1407 85 moveto +(RetractableTo\(a:Type\)) +[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% RetractableTo(OrderedSet)->RetractableTo(a:Type) +newpath 1342 144 moveto +1365 134 1394 122 1419 112 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 1420 115 moveto +1428 108 lineto +1417 109 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 1420 115 moveto +1428 108 lineto +1417 109 lineto +closepath +stroke +end grestore +% Category +gsave 10 dict begin +filled +0.000 0.000 1.000 nodecolor +0.000 0.000 1.000 nodecolor +newpath 1504 36 moveto +1436 36 lineto +1436 0 lineto +1504 0 lineto +closepath +fill +0.000 0.000 1.000 nodecolor +newpath 1504 36 moveto +1436 36 lineto +1436 0 lineto +1504 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +1444 13 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% RetractableTo(a:Type)->Category +newpath 1470 72 moveto +1470 64 1470 55 1470 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 1474 46 moveto +1470 36 lineto +1467 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 1474 46 moveto +1470 36 lineto +1467 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102differentialvariablecategory.ps b/books/ps/v102differentialvariablecategory.ps new file mode 100644 index 0000000..140b802 --- /dev/null +++ b/books/ps/v102differentialvariablecategory.ps @@ -0,0 +1,653 @@ +%!PS-Adobe-2.0 +%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006) +%%For: (root) root +%%Title: pic +%%Pages: (atend) +%%BoundingBox: 36 36 438 440 +%%EndComments +save +%%BeginProlog +/DotDict 200 dict def +DotDict begin + +/setupLatin1 { +mark +/EncodingVector 256 array def + EncodingVector 0 + +ISOLatin1Encoding 0 255 getinterval putinterval +EncodingVector 45 /hyphen put + +% Set up ISO Latin 1 character encoding +/starnetISO { + dup dup findfont dup length dict begin + { 1 index /FID ne { def }{ pop pop } ifelse + } forall + /Encoding EncodingVector def + currentdict end definefont +} def +/Times-Roman starnetISO def +/Times-Italic starnetISO def +/Times-Bold starnetISO def +/Times-BoldItalic starnetISO def +/Helvetica starnetISO def +/Helvetica-Oblique starnetISO def +/Helvetica-Bold starnetISO def +/Helvetica-BoldOblique starnetISO def +/Courier starnetISO def +/Courier-Oblique starnetISO def +/Courier-Bold starnetISO def +/Courier-BoldOblique starnetISO def +cleartomark +} bind def + +%%BeginResource: procset graphviz 0 0 +/coord-font-family /Times-Roman def +/default-font-family /Times-Roman def +/coordfont coord-font-family findfont 8 scalefont def + +/InvScaleFactor 1.0 def +/set_scale { + dup 1 exch div /InvScaleFactor exch def + dup scale +} bind def + +% styles +/solid { [] 0 setdash } bind def +/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def +/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def +/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def +/bold { 2 setlinewidth } bind def +/filled { } bind def +/unfilled { } bind def +/rounded { } bind def +/diagonals { } bind def + +% hooks for setting color +/nodecolor { sethsbcolor } bind def +/edgecolor { sethsbcolor } bind def +/graphcolor { sethsbcolor } bind def +/nopcolor {pop pop pop} bind def + +/beginpage { % i j npages + /npages exch def + /j exch def + /i exch def + /str 10 string def + npages 1 gt { + gsave + coordfont setfont + 0 0 moveto + (\() show i str cvs show (,) show j str cvs show (\)) show + grestore + } if +} bind def + +/set_font { + findfont exch + scalefont setfont +} def + +% draw aligned label in bounding box aligned to current point +/alignedtext { % width adj text + /text exch def + /adj exch def + /width exch def + gsave + width 0 gt { + text stringwidth pop adj mul 0 rmoveto + } if + [] 0 setdash + text show + grestore +} def + +/boxprim { % xcorner ycorner xsize ysize + 4 2 roll + moveto + 2 copy + exch 0 rlineto + 0 exch rlineto + pop neg 0 rlineto + closepath +} bind def + +/ellipse_path { + /ry exch def + /rx exch def + /y exch def + /x exch def + matrix currentmatrix + newpath + x y translate + rx ry scale + 0 0 1 0 360 arc + setmatrix +} bind def + +/endpage { showpage } bind def +/showpage { } def + +/layercolorseq + [ % layer color sequence - darkest to lightest + [0 0 0] + [.2 .8 .8] + [.4 .8 .8] + [.6 .8 .8] + [.8 .8 .8] + ] +def + +/layerlen layercolorseq length def + +/setlayer {/maxlayer exch def /curlayer exch def + layercolorseq curlayer 1 sub layerlen mod get + aload pop sethsbcolor + /nodecolor {nopcolor} def + /edgecolor {nopcolor} def + /graphcolor {nopcolor} def +} bind def + +/onlayer { curlayer ne {invis} if } def + +/onlayers { + /myupper exch def + /mylower exch def + curlayer mylower lt + curlayer myupper gt + or + {invis} if +} def + +/curlayer 0 def + +%%EndResource +%%EndProlog +%%BeginSetup +14 default-font-family set_font +1 setmiterlimit +% /arrowlength 10 def +% /arrowwidth 5 def + +% make sure pdfmark is harmless for PS-interpreters other than Distiller +/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse +% make '<<' and '>>' safe on PS Level 1 devices +/languagelevel where {pop languagelevel}{1} ifelse +2 lt { + userdict (<<) cvn ([) cvn load put + userdict (>>) cvn ([) cvn load put +} if + +%%EndSetup +%%Page: 1 1 +%%PageBoundingBox: 36 36 438 440 +%%PageOrientation: Portrait +gsave +36 36 402 404 boxprim clip newpath +36 36 translate +0 0 1 beginpage +1.0000 set_scale +4 4 translate 0 rotate +0.167 0.600 1.000 graphcolor +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 402 lineto +400 402 lineto +400 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 402 lineto +400 402 lineto +400 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% DifferentialVariableCategory(a:OrderedSet) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 374 396 moveto +110 396 lineto +110 360 lineto +374 360 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 374 396 moveto +110 396 lineto +110 360 lineto +374 360 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +118 373 moveto +(DifferentialVariableCategory\(a:OrderedSet\)) +[10.08 3.84 4.56 4.08 6.24 4.8 6.24 6.96 3.84 3.84 6.24 3.84 8.88 6.24 5.04 3.84 6.24 6.96 3.84 6.24 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 6.24 3.84 10.08 4.56 6.96 6.24 4.8 6.24 6.96 7.68 6 3.84 4.56] +xshow +end grestore +end grestore +% OrderedSet() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 239 324 moveto +151 324 lineto +151 288 lineto +239 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 239 324 moveto +151 324 lineto +151 288 lineto +239 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +158 301 moveto +(OrderedSet\(\)) +[10.08 4.56 6.96 6.24 4.8 6.24 6.96 7.68 6 3.84 4.56 4.56] +xshow +end grestore +end grestore +% DifferentialVariableCategory(a:OrderedSet)->OrderedSet() +newpath 230 360 moveto +225 352 218 342 212 332 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 215 331 moveto +207 324 lineto +209 334 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 215 331 moveto +207 324 lineto +209 334 lineto +closepath +stroke +end grestore +% RetractableTo(OrderedSet) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 394 252 moveto +228 252 lineto +228 216 lineto +394 216 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 394 252 moveto +228 252 lineto +228 216 lineto +394 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +235 229 moveto +(RetractableTo\(OrderedSet\)) +[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 10.08 4.56 6.96 6.24 4.8 6.24 6.96 7.68 6 3.84 4.56] +xshow +end grestore +end grestore +% DifferentialVariableCategory(a:OrderedSet)->RetractableTo(OrderedSet) +newpath 251 360 moveto +263 335 284 290 298 261 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 301 263 moveto +302 252 lineto +295 260 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 301 263 moveto +302 252 lineto +295 260 lineto +closepath +stroke +end grestore +% SetCategory() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 199 252 moveto +105 252 lineto +105 216 lineto +199 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 199 252 moveto +105 252 lineto +105 216 lineto +199 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +112 229 moveto +(SetCategory\(\)) +[7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 4.56] +xshow +end grestore +end grestore +% OrderedSet()->SetCategory() +newpath 184 288 moveto +179 280 173 270 168 261 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 171 259 moveto +163 252 lineto +165 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 171 259 moveto +163 252 lineto +165 262 lineto +closepath +stroke +end grestore +% RetractableTo(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 392 180 moveto +252 180 lineto +252 144 lineto +392 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 392 180 moveto +252 180 lineto +252 144 lineto +392 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +259 157 moveto +(RetractableTo\(a:Type\)) +[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% RetractableTo(OrderedSet)->RetractableTo(a:Type) +newpath 314 216 moveto +315 208 317 199 318 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 321 190 moveto +319 180 lineto +315 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 321 190 moveto +319 180 lineto +315 190 lineto +closepath +stroke +end grestore +% Category +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 202 36 moveto +134 36 lineto +134 0 lineto +202 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 202 36 moveto +134 36 lineto +134 0 lineto +202 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +142 13 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% RetractableTo(a:Type)->Category +newpath 308 144 moveto +293 125 268 94 243 72 curveto +231 61 217 51 204 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 206 39 moveto +196 36 lineto +202 45 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 206 39 moveto +196 36 lineto +202 45 lineto +closepath +stroke +end grestore +% BasicType() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 84 108 moveto +0 108 lineto +0 72 lineto +84 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 84 108 moveto +0 108 lineto +0 72 lineto +84 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 85 moveto +(BasicType\(\)) +[9.36 6.24 5.52 3.84 6.24 7.2 6.96 6.96 6.24 4.56 4.56] +xshow +end grestore +end grestore +% SetCategory()->BasicType() +newpath 105 216 moveto +89 207 72 195 61 180 curveto +48 162 44 137 43 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 46 118 moveto +42 108 lineto +40 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 46 118 moveto +42 108 lineto +40 118 lineto +closepath +stroke +end grestore +% CoercibleTo(OutputForm) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 234 180 moveto +70 180 lineto +70 144 lineto +234 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 234 180 moveto +70 180 lineto +70 144 lineto +234 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +78 157 moveto +(CoercibleTo\(OutputForm\)) +[9.36 6.96 6.24 4.8 6.24 3.84 6.96 3.84 6.24 7.44 6.96 4.56 10.08 6.96 3.84 6.96 6.96 3.84 7.44 6.96 5.04 10.8 4.56] +xshow +end grestore +end grestore +% SetCategory()->CoercibleTo(OutputForm) +newpath 152 216 moveto +152 208 152 199 152 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 156 190 moveto +152 180 lineto +149 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 156 190 moveto +152 180 lineto +149 190 lineto +closepath +stroke +end grestore +% BasicType()->Category +newpath 74 72 moveto +90 63 110 51 128 41 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 130 44 moveto +137 36 lineto +127 38 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 130 44 moveto +137 36 lineto +127 38 lineto +closepath +stroke +end grestore +% CoercibleTo(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 234 108 moveto +102 108 lineto +102 72 lineto +234 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 234 108 moveto +102 108 lineto +102 72 lineto +234 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +110 85 moveto +(CoercibleTo\(a:Type\)) +[9.36 6.96 6.24 4.8 6.24 3.84 6.96 3.84 6.24 7.44 6.96 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% CoercibleTo(OutputForm)->CoercibleTo(a:Type) +newpath 156 144 moveto +158 136 160 127 162 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 165 118 moveto +164 108 lineto +159 117 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 165 118 moveto +164 108 lineto +159 117 lineto +closepath +stroke +end grestore +% CoercibleTo(a:Type)->Category +newpath 168 72 moveto +168 64 168 55 168 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 172 46 moveto +168 36 lineto +165 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 172 46 moveto +168 36 lineto +165 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102expressionspace.ps b/books/ps/v102expressionspace.ps new file mode 100644 index 0000000..2a85b2e --- /dev/null +++ b/books/ps/v102expressionspace.ps @@ -0,0 +1,929 @@ +%!PS-Adobe-2.0 +%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006) +%%For: (root) root +%%Title: pic +%%Pages: (atend) +%%BoundingBox: 36 36 964 440 +%%EndComments +save +%%BeginProlog +/DotDict 200 dict def +DotDict begin + +/setupLatin1 { +mark +/EncodingVector 256 array def + EncodingVector 0 + +ISOLatin1Encoding 0 255 getinterval putinterval +EncodingVector 45 /hyphen put + +% Set up ISO Latin 1 character encoding +/starnetISO { + dup dup findfont dup length dict begin + { 1 index /FID ne { def }{ pop pop } ifelse + } forall + /Encoding EncodingVector def + currentdict end definefont +} def +/Times-Roman starnetISO def +/Times-Italic starnetISO def +/Times-Bold starnetISO def +/Times-BoldItalic starnetISO def +/Helvetica starnetISO def +/Helvetica-Oblique starnetISO def +/Helvetica-Bold starnetISO def +/Helvetica-BoldOblique starnetISO def +/Courier starnetISO def +/Courier-Oblique starnetISO def +/Courier-Bold starnetISO def +/Courier-BoldOblique starnetISO def +cleartomark +} bind def + +%%BeginResource: procset graphviz 0 0 +/coord-font-family /Times-Roman def +/default-font-family /Times-Roman def +/coordfont coord-font-family findfont 8 scalefont def + +/InvScaleFactor 1.0 def +/set_scale { + dup 1 exch div /InvScaleFactor exch def + dup scale +} bind def + +% styles +/solid { [] 0 setdash } bind def +/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def +/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def +/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def +/bold { 2 setlinewidth } bind def +/filled { } bind def +/unfilled { } bind def +/rounded { } bind def +/diagonals { } bind def + +% hooks for setting color +/nodecolor { sethsbcolor } bind def +/edgecolor { sethsbcolor } bind def +/graphcolor { sethsbcolor } bind def +/nopcolor {pop pop pop} bind def + +/beginpage { % i j npages + /npages exch def + /j exch def + /i exch def + /str 10 string def + npages 1 gt { + gsave + coordfont setfont + 0 0 moveto + (\() show i str cvs show (,) show j str cvs show (\)) show + grestore + } if +} bind def + +/set_font { + findfont exch + scalefont setfont +} def + +% draw aligned label in bounding box aligned to current point +/alignedtext { % width adj text + /text exch def + /adj exch def + /width exch def + gsave + width 0 gt { + text stringwidth pop adj mul 0 rmoveto + } if + [] 0 setdash + text show + grestore +} def + +/boxprim { % xcorner ycorner xsize ysize + 4 2 roll + moveto + 2 copy + exch 0 rlineto + 0 exch rlineto + pop neg 0 rlineto + closepath +} bind def + +/ellipse_path { + /ry exch def + /rx exch def + /y exch def + /x exch def + matrix currentmatrix + newpath + x y translate + rx ry scale + 0 0 1 0 360 arc + setmatrix +} bind def + +/endpage { showpage } bind def +/showpage { } def + +/layercolorseq + [ % layer color sequence - darkest to lightest + [0 0 0] + [.2 .8 .8] + [.4 .8 .8] + [.6 .8 .8] + [.8 .8 .8] + ] +def + +/layerlen layercolorseq length def + +/setlayer {/maxlayer exch def /curlayer exch def + layercolorseq curlayer 1 sub layerlen mod get + aload pop sethsbcolor + /nodecolor {nopcolor} def + /edgecolor {nopcolor} def + /graphcolor {nopcolor} def +} bind def + +/onlayer { curlayer ne {invis} if } def + +/onlayers { + /myupper exch def + /mylower exch def + curlayer mylower lt + curlayer myupper gt + or + {invis} if +} def + +/curlayer 0 def + +%%EndResource +%%EndProlog +%%BeginSetup +14 default-font-family set_font +1 setmiterlimit +% /arrowlength 10 def +% /arrowwidth 5 def + +% make sure pdfmark is harmless for PS-interpreters other than Distiller +/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse +% make '<<' and '>>' safe on PS Level 1 devices +/languagelevel where {pop languagelevel}{1} ifelse +2 lt { + userdict (<<) cvn ([) cvn load put + userdict (>>) cvn ([) cvn load put +} if + +%%EndSetup +%%Page: 1 1 +%%PageBoundingBox: 36 36 964 440 +%%PageOrientation: Portrait +gsave +36 36 928 404 boxprim clip newpath +36 36 translate +0 0 1 beginpage +1.0000 set_scale +4 4 translate 0 rotate +0.167 0.600 1.000 graphcolor +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 402 lineto +926 402 lineto +926 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 402 lineto +926 402 lineto +926 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% ExpressionSpace() +[ /Rect [ 326 360 448 396 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=ES) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 448 396 moveto +326 396 lineto +326 360 lineto +448 360 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 448 396 moveto +326 396 lineto +326 360 lineto +448 360 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +334 373 moveto +(ExpressionSpace\(\)) +[8.64 6.96 6.96 4.8 6.24 5.52 5.52 3.84 6.96 6.96 7.68 6.96 6.24 6.24 6.24 4.56 4.56] +xshow +end grestore +end grestore +% OrderedSet() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 171 324 moveto +83 324 lineto +83 288 lineto +171 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 171 324 moveto +83 324 lineto +83 288 lineto +171 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +90 301 moveto +(OrderedSet\(\)) +[10.08 4.56 6.96 6.24 4.8 6.24 6.96 7.68 6 3.84 4.56 4.56] +xshow +end grestore +end grestore +% ExpressionSpace()->OrderedSet() +newpath 326 363 moveto +287 354 235 340 181 324 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 182 321 moveto +171 321 lineto +180 327 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 182 321 moveto +171 321 lineto +180 327 lineto +closepath +stroke +end grestore +% RetractableTo(Kernel(ExpressionSpace)) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 435 324 moveto +189 324 lineto +189 288 lineto +435 288 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 435 324 moveto +189 324 lineto +189 288 lineto +435 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +196 301 moveto +(RetractableTo\(Kernel\(ExpressionSpace\)\)) +[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 9.6 6.24 5.04 6.96 6.24 3.84 4.56 8.64 6.96 6.96 4.8 6.24 5.52 5.52 3.84 6.96 6.96 7.68 6.96 6.24 6.24 6.24 4.56 4.56] +xshow +end grestore +end grestore +% ExpressionSpace()->RetractableTo(Kernel(ExpressionSpace)) +newpath 368 360 moveto +359 351 348 341 338 331 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 341 329 moveto +331 324 lineto +336 334 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 341 329 moveto +331 324 lineto +336 334 lineto +closepath +stroke +end grestore +% InnerEvalable(Kernal(ExpressionSpace),ExpressionSpace) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 636 180 moveto +290 180 lineto +290 144 lineto +636 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 636 180 moveto +290 180 lineto +290 144 lineto +636 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +297 157 moveto +(InnerEvalable\(Kernal\(ExpressionSpace\),ExpressionSpace\)) +[4.56 6.96 6.96 6.24 4.8 8.64 6.72 6.24 3.84 6.24 6.96 3.84 6.24 4.56 9.6 6.24 5.04 6.96 6.24 3.84 4.56 8.64 6.96 6.96 4.8 6.24 5.52 5.52 3.84 6.96 6.96 7.68 6.96 6.24 6.24 6.24 4.56 3.6 8.64 6.96 6.96 4.8 6.24 5.52 5.52 3.84 6.96 6.96 7.68 6.96 6.24 6.24 6.24 4.56] +xshow +end grestore +end grestore +% ExpressionSpace()->InnerEvalable(Kernal(ExpressionSpace),ExpressionSpace) +newpath 413 360 moveto +424 350 437 338 444 324 curveto +466 281 467 224 466 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 469 190 moveto +465 180 lineto +463 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 469 190 moveto +465 180 lineto +463 190 lineto +closepath +stroke +end grestore +% Evalable(ExpressionSpace) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 714 324 moveto +544 324 lineto +544 288 lineto +714 288 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 714 324 moveto +544 324 lineto +544 288 lineto +714 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +552 301 moveto +(Evalable\(ExpressionSpace\)) +[8.64 6.72 6.24 3.84 6.24 6.96 3.84 6.24 4.56 8.64 6.96 6.96 4.8 6.24 5.52 5.52 3.84 6.96 6.96 7.68 6.96 6.24 6.24 6.24 4.56] +xshow +end grestore +end grestore +% ExpressionSpace()->Evalable(ExpressionSpace) +newpath 448 360 moveto +482 350 524 337 559 327 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 560 330 moveto +569 324 lineto +558 324 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 560 330 moveto +569 324 lineto +558 324 lineto +closepath +stroke +end grestore +% SetCategory() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 174 252 moveto +80 252 lineto +80 216 lineto +174 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 174 252 moveto +80 252 lineto +80 216 lineto +174 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +87 229 moveto +(SetCategory\(\)) +[7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 4.56] +xshow +end grestore +end grestore +% OrderedSet()->SetCategory() +newpath 127 288 moveto +127 280 127 271 127 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 131 262 moveto +127 252 lineto +124 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 131 262 moveto +127 252 lineto +124 262 lineto +closepath +stroke +end grestore +% RetractableTo(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 357 252 moveto +217 252 lineto +217 216 lineto +357 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 357 252 moveto +217 252 lineto +217 216 lineto +357 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +224 229 moveto +(RetractableTo\(a:Type\)) +[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% RetractableTo(Kernel(ExpressionSpace))->RetractableTo(a:Type) +newpath 306 288 moveto +303 280 300 270 296 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 299 261 moveto +293 252 lineto +293 263 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 299 261 moveto +293 252 lineto +293 263 lineto +closepath +stroke +end grestore +% InnerEvalable(a:SetCategory,b:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 575 108 moveto +351 108 lineto +351 72 lineto +575 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 575 108 moveto +351 108 lineto +351 72 lineto +575 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +358 85 moveto +(InnerEvalable\(a:SetCategory,b:Type\)) +[4.56 6.96 6.96 6.24 4.8 8.64 6.72 6.24 3.84 6.24 6.96 3.84 6.24 4.56 6.24 3.84 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6 3.6 6.96 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% InnerEvalable(Kernal(ExpressionSpace),ExpressionSpace)->InnerEvalable(a:SetCategory,b:Type) +newpath 463 144 moveto +463 136 463 127 463 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 467 118 moveto +463 108 lineto +460 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 467 118 moveto +463 108 lineto +460 118 lineto +closepath +stroke +end grestore +% Evalable(a:SetCategory) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 811 252 moveto +657 252 lineto +657 216 lineto +811 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 811 252 moveto +657 252 lineto +657 216 lineto +811 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +665 229 moveto +(Evalable\(a:SetCategory\)) +[8.64 6.72 6.24 3.84 6.24 6.96 3.84 6.24 4.56 6.24 3.84 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56] +xshow +end grestore +end grestore +% Evalable(ExpressionSpace)->Evalable(a:SetCategory) +newpath 655 288 moveto +669 279 685 268 699 258 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 702 260 moveto +708 252 lineto +698 255 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 702 260 moveto +708 252 lineto +698 255 lineto +closepath +stroke +end grestore +% InnerEvalable(a:SetCategory,b:SetCategory) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 920 180 moveto +654 180 lineto +654 144 lineto +920 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 920 180 moveto +654 180 lineto +654 144 lineto +920 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +661 157 moveto +(InnerEvalable\(a:SetCategory,b:SetCategory\)) +[4.56 6.96 6.96 6.24 4.8 8.64 6.72 6.24 3.84 6.24 6.96 3.84 6.24 4.56 6.24 3.84 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6 3.6 6.96 3.84 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56] +xshow +end grestore +end grestore +% Evalable(a:SetCategory)->InnerEvalable(a:SetCategory,b:SetCategory) +newpath 747 216 moveto +753 208 761 197 768 188 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 771 190 moveto +774 180 lineto +765 186 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 771 190 moveto +774 180 lineto +765 186 lineto +closepath +stroke +end grestore +% InnerEvalable(a:SetCategory,b:SetCategory)->InnerEvalable(a:SetCategory,b:Type) +newpath 706 144 moveto +659 134 601 121 554 110 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 554 107 moveto +544 108 lineto +553 113 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 554 107 moveto +544 108 lineto +553 113 lineto +closepath +stroke +end grestore +% Category +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 249 36 moveto +181 36 lineto +181 0 lineto +249 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 249 36 moveto +181 36 lineto +181 0 lineto +249 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +189 13 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% InnerEvalable(a:SetCategory,b:Type)->Category +newpath 401 72 moveto +357 59 298 42 259 31 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 260 28 moveto +249 28 lineto +258 34 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 260 28 moveto +249 28 lineto +258 34 lineto +closepath +stroke +end grestore +% RetractableTo(a:Type)->Category +newpath 283 216 moveto +277 185 263 122 243 72 curveto +239 63 235 53 231 45 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 234 43 moveto +226 36 lineto +228 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 234 43 moveto +226 36 lineto +228 46 lineto +closepath +stroke +end grestore +% BasicType() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 84 108 moveto +0 108 lineto +0 72 lineto +84 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 84 108 moveto +0 108 lineto +0 72 lineto +84 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 85 moveto +(BasicType\(\)) +[9.36 6.24 5.52 3.84 6.24 7.2 6.96 6.96 6.24 4.56 4.56] +xshow +end grestore +end grestore +% SetCategory()->BasicType() +newpath 97 216 moveto +84 207 70 194 61 180 curveto +50 162 46 137 43 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 46 118 moveto +42 108 lineto +40 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 46 118 moveto +42 108 lineto +40 118 lineto +closepath +stroke +end grestore +% CoercibleTo(OutputForm) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 234 180 moveto +70 180 lineto +70 144 lineto +234 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 234 180 moveto +70 180 lineto +70 144 lineto +234 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +78 157 moveto +(CoercibleTo\(OutputForm\)) +[9.36 6.96 6.24 4.8 6.24 3.84 6.96 3.84 6.24 7.44 6.96 4.56 10.08 6.96 3.84 6.96 6.96 3.84 7.44 6.96 5.04 10.8 4.56] +xshow +end grestore +end grestore +% SetCategory()->CoercibleTo(OutputForm) +newpath 133 216 moveto +136 208 139 198 143 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 146 191 moveto +146 180 lineto +140 189 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 146 191 moveto +146 180 lineto +140 189 lineto +closepath +stroke +end grestore +% BasicType()->Category +newpath 84 72 moveto +111 61 145 47 172 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 173 39 moveto +181 32 lineto +170 33 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 173 39 moveto +181 32 lineto +170 33 lineto +closepath +stroke +end grestore +% CoercibleTo(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 234 108 moveto +102 108 lineto +102 72 lineto +234 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 234 108 moveto +102 108 lineto +102 72 lineto +234 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +110 85 moveto +(CoercibleTo\(a:Type\)) +[9.36 6.96 6.24 4.8 6.24 3.84 6.96 3.84 6.24 7.44 6.96 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% CoercibleTo(OutputForm)->CoercibleTo(a:Type) +newpath 156 144 moveto +158 136 160 127 162 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 165 118 moveto +164 108 lineto +159 117 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 165 118 moveto +164 108 lineto +159 117 lineto +closepath +stroke +end grestore +% CoercibleTo(a:Type)->Category +newpath 180 72 moveto +185 64 192 54 198 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 201 46 moveto +203 36 lineto +195 43 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 201 46 moveto +203 36 lineto +195 43 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102finitedivisorcategory.ps b/books/ps/v102finitedivisorcategory.ps new file mode 100644 index 0000000..31fe32e --- /dev/null +++ b/books/ps/v102finitedivisorcategory.ps @@ -0,0 +1,678 @@ +%!PS-Adobe-2.0 +%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006) +%%For: (root) root +%%Title: pic +%%Pages: (atend) +%%BoundingBox: 36 36 511 584 +%%EndComments +save +%%BeginProlog +/DotDict 200 dict def +DotDict begin + +/setupLatin1 { +mark +/EncodingVector 256 array def + EncodingVector 0 + +ISOLatin1Encoding 0 255 getinterval putinterval +EncodingVector 45 /hyphen put + +% Set up ISO Latin 1 character encoding +/starnetISO { + dup dup findfont dup length dict begin + { 1 index /FID ne { def }{ pop pop } ifelse + } forall + /Encoding EncodingVector def + currentdict end definefont +} def +/Times-Roman starnetISO def +/Times-Italic starnetISO def +/Times-Bold starnetISO def +/Times-BoldItalic starnetISO def +/Helvetica starnetISO def +/Helvetica-Oblique starnetISO def +/Helvetica-Bold starnetISO def +/Helvetica-BoldOblique starnetISO def +/Courier starnetISO def +/Courier-Oblique starnetISO def +/Courier-Bold starnetISO def +/Courier-BoldOblique starnetISO def +cleartomark +} bind def + +%%BeginResource: procset graphviz 0 0 +/coord-font-family /Times-Roman def +/default-font-family /Times-Roman def +/coordfont coord-font-family findfont 8 scalefont def + +/InvScaleFactor 1.0 def +/set_scale { + dup 1 exch div /InvScaleFactor exch def + dup scale +} bind def + +% styles +/solid { [] 0 setdash } bind def +/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def +/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def +/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def +/bold { 2 setlinewidth } bind def +/filled { } bind def +/unfilled { } bind def +/rounded { } bind def +/diagonals { } bind def + +% hooks for setting color +/nodecolor { sethsbcolor } bind def +/edgecolor { sethsbcolor } bind def +/graphcolor { sethsbcolor } bind def +/nopcolor {pop pop pop} bind def + +/beginpage { % i j npages + /npages exch def + /j exch def + /i exch def + /str 10 string def + npages 1 gt { + gsave + coordfont setfont + 0 0 moveto + (\() show i str cvs show (,) show j str cvs show (\)) show + grestore + } if +} bind def + +/set_font { + findfont exch + scalefont setfont +} def + +% draw aligned label in bounding box aligned to current point +/alignedtext { % width adj text + /text exch def + /adj exch def + /width exch def + gsave + width 0 gt { + text stringwidth pop adj mul 0 rmoveto + } if + [] 0 setdash + text show + grestore +} def + +/boxprim { % xcorner ycorner xsize ysize + 4 2 roll + moveto + 2 copy + exch 0 rlineto + 0 exch rlineto + pop neg 0 rlineto + closepath +} bind def + +/ellipse_path { + /ry exch def + /rx exch def + /y exch def + /x exch def + matrix currentmatrix + newpath + x y translate + rx ry scale + 0 0 1 0 360 arc + setmatrix +} bind def + +/endpage { showpage } bind def +/showpage { } def + +/layercolorseq + [ % layer color sequence - darkest to lightest + [0 0 0] + [.2 .8 .8] + [.4 .8 .8] + [.6 .8 .8] + [.8 .8 .8] + ] +def + +/layerlen layercolorseq length def + +/setlayer {/maxlayer exch def /curlayer exch def + layercolorseq curlayer 1 sub layerlen mod get + aload pop sethsbcolor + /nodecolor {nopcolor} def + /edgecolor {nopcolor} def + /graphcolor {nopcolor} def +} bind def + +/onlayer { curlayer ne {invis} if } def + +/onlayers { + /myupper exch def + /mylower exch def + curlayer mylower lt + curlayer myupper gt + or + {invis} if +} def + +/curlayer 0 def + +%%EndResource +%%EndProlog +%%BeginSetup +14 default-font-family set_font +1 setmiterlimit +% /arrowlength 10 def +% /arrowwidth 5 def + +% make sure pdfmark is harmless for PS-interpreters other than Distiller +/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse +% make '<<' and '>>' safe on PS Level 1 devices +/languagelevel where {pop languagelevel}{1} ifelse +2 lt { + userdict (<<) cvn ([) cvn load put + userdict (>>) cvn ([) cvn load put +} if + +%%EndSetup +%%Page: 1 1 +%%PageBoundingBox: 36 36 511 584 +%%PageOrientation: Portrait +gsave +36 36 475 548 boxprim clip newpath +36 36 translate +0 0 1 beginpage +1.0000 set_scale +4 4 translate 0 rotate +0.167 0.600 1.000 graphcolor +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 546 lineto +473 546 lineto +473 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 546 lineto +473 546 lineto +473 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% FiniteDivisorCategory() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 348 540 moveto +196 540 lineto +196 504 lineto +348 504 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 348 540 moveto +196 540 lineto +196 504 lineto +348 504 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +204 517 moveto +(FiniteDivisorCategory\(\)) +[7.44 3.84 6.96 3.84 3.84 6.24 10.08 3.84 6.96 3.84 5.52 6.96 4.8 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 4.56] +xshow +end grestore +end grestore +% AbelianGroup() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 325 468 moveto +219 468 lineto +219 432 lineto +325 432 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 325 468 moveto +219 468 lineto +219 432 lineto +325 432 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +227 445 moveto +(AbelianGroup\(\)) +[9.84 6.96 6.24 3.84 3.84 6.24 6.96 10.08 4.8 6.96 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% FiniteDivisorCategory()->AbelianGroup() +newpath 272 504 moveto +272 496 272 487 272 478 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 276 478 moveto +272 468 lineto +269 478 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 276 478 moveto +272 468 lineto +269 478 lineto +closepath +stroke +end grestore +% CancellationAbelianMonoid() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 289 396 moveto +105 396 lineto +105 360 lineto +289 360 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 289 396 moveto +105 396 lineto +105 360 lineto +289 360 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +113 373 moveto +(CancellationAbelianMonoid\(\)) +[9.36 6.24 6.96 6.24 6.24 3.84 3.84 6.24 3.84 3.84 6.96 6.96 9.84 6.96 6.24 3.84 3.84 6.24 6.96 12.48 6.96 6.96 6.96 3.84 6.96 4.56 4.56] +xshow +end grestore +end grestore +% AbelianGroup()->CancellationAbelianMonoid() +newpath 253 432 moveto +244 423 233 413 223 403 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 226 401 moveto +216 396 lineto +221 406 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 226 401 moveto +216 396 lineto +221 406 lineto +closepath +stroke +end grestore +% RepeatedDoubling(AbelianGroup) +gsave 10 dict begin +filled +0.333 1.000 0.933 nodecolor +0.333 1.000 0.933 nodecolor +newpath 467 324 moveto +257 324 lineto +257 288 lineto +467 288 lineto +closepath +fill +0.333 1.000 0.933 nodecolor +newpath 467 324 moveto +257 324 lineto +257 288 lineto +467 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +265 301 moveto +(RepeatedDoubling\(AbelianGroup\)) +[9.12 6.24 6.96 6.24 6.24 3.84 6.24 6.96 10.08 6.96 6.96 6.96 3.84 3.84 6.96 6.96 4.56 9.84 6.96 6.24 3.84 3.84 6.24 6.96 10.08 4.8 6.96 6.96 6.96 4.56] +xshow +end grestore +end grestore +% AbelianGroup()->RepeatedDoubling(AbelianGroup) +newpath 283 432 moveto +299 407 328 362 346 333 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 349 334 moveto +351 324 lineto +343 331 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 349 334 moveto +351 324 lineto +343 331 lineto +closepath +stroke +end grestore +% AbelianMonoid() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 239 324 moveto +125 324 lineto +125 288 lineto +239 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 239 324 moveto +125 324 lineto +125 288 lineto +239 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +132 301 moveto +(AbelianMonoid\(\)) +[9.84 6.96 6.24 3.84 3.84 6.24 6.96 12.48 6.96 6.96 6.96 3.84 6.96 4.56 4.56] +xshow +end grestore +end grestore +% CancellationAbelianMonoid()->AbelianMonoid() +newpath 193 360 moveto +192 352 190 343 188 334 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 191 333 moveto +186 324 lineto +185 334 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 191 333 moveto +186 324 lineto +185 334 lineto +closepath +stroke +end grestore +% RepeatedDoubling(a:SetCategory) +gsave 10 dict begin +filled +0.333 1.000 0.933 nodecolor +0.333 1.000 0.933 nodecolor +newpath 344 108 moveto +136 108 lineto +136 72 lineto +344 72 lineto +closepath +fill +0.333 1.000 0.933 nodecolor +newpath 344 108 moveto +136 108 lineto +136 72 lineto +344 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +143 85 moveto +(RepeatedDoubling\(a:SetCategory\)) +[9.12 6.24 6.96 6.24 6.24 3.84 6.24 6.96 10.08 6.96 6.96 6.96 3.84 3.84 6.96 6.96 4.56 6.24 3.84 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56] +xshow +end grestore +end grestore +% RepeatedDoubling(AbelianGroup)->RepeatedDoubling(a:SetCategory) +newpath 365 288 moveto +369 256 373 188 343 144 curveto +334 131 320 120 306 113 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 307 110 moveto +297 108 lineto +304 116 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 307 110 moveto +297 108 lineto +304 116 lineto +closepath +stroke +end grestore +% Package +gsave 10 dict begin +filled +0.333 1.000 0.933 nodecolor +0.333 1.000 0.933 nodecolor +newpath 271 36 moveto +209 36 lineto +209 0 lineto +271 0 lineto +closepath +fill +0.333 1.000 0.933 nodecolor +newpath 271 36 moveto +209 36 lineto +209 0 lineto +271 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +216 13 moveto +(Package) +[7.44 6.24 6 6.96 6.24 6.72 6.24] +xshow +end grestore +end grestore +% RepeatedDoubling(a:SetCategory)->Package +newpath 240 72 moveto +240 64 240 55 240 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 244 46 moveto +240 36 lineto +237 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 244 46 moveto +240 36 lineto +237 46 lineto +closepath +stroke +end grestore +% RepeatedDoubling(AbelianSemiGroup) +gsave 10 dict begin +filled +0.333 1.000 0.933 nodecolor +0.333 1.000 0.933 nodecolor +newpath 238 180 moveto +0 180 lineto +0 144 lineto +238 144 lineto +closepath +fill +0.333 1.000 0.933 nodecolor +newpath 238 180 moveto +0 180 lineto +0 144 lineto +238 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 157 moveto +(RepeatedDoubling\(AbelianSemiGroup\)) +[9.12 6.24 6.96 6.24 6.24 3.84 6.24 6.96 10.08 6.96 6.96 6.96 3.84 3.84 6.96 6.96 4.56 9.84 6.96 6.24 3.84 3.84 6.24 6.96 7.68 6.24 10.8 3.84 10.08 4.8 6.96 6.96 6.96 4.56] +xshow +end grestore +end grestore +% RepeatedDoubling(AbelianSemiGroup)->RepeatedDoubling(a:SetCategory) +newpath 150 144 moveto +165 135 184 123 201 113 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 203 116 moveto +210 108 lineto +200 110 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 203 116 moveto +210 108 lineto +200 110 lineto +closepath +stroke +end grestore +% AbelianSemiGroup() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 249 252 moveto +115 252 lineto +115 216 lineto +249 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 249 252 moveto +115 252 lineto +115 216 lineto +249 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +122 229 moveto +(AbelianSemiGroup\(\)) +[9.84 6.96 6.24 3.84 3.84 6.24 6.96 7.68 6.24 10.8 3.84 10.08 4.8 6.96 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% AbelianMonoid()->AbelianSemiGroup() +newpath 182 288 moveto +182 280 182 271 182 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 186 262 moveto +182 252 lineto +179 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 186 262 moveto +182 252 lineto +179 262 lineto +closepath +stroke +end grestore +% AbelianSemiGroup()->RepeatedDoubling(AbelianSemiGroup) +newpath 166 216 moveto +158 207 149 197 142 188 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 144 185 moveto +135 180 lineto +139 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 144 185 moveto +135 180 lineto +139 190 lineto +closepath +stroke +end grestore +% SETCAT... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 334 180 moveto +256 180 lineto +256 144 lineto +334 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 334 180 moveto +256 180 lineto +256 144 lineto +334 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +264 157 moveto +(SETCAT...) +[7.68 8.64 8.64 9.12 9.36 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% AbelianSemiGroup()->SETCAT... +newpath 211 216 moveto +225 207 243 196 258 186 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 261 188 moveto +267 180 lineto +257 183 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 261 188 moveto +267 180 lineto +257 183 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102quotientfieldcategory.ps b/books/ps/v102quotientfieldcategory.ps new file mode 100644 index 0000000..338a1d2 --- /dev/null +++ b/books/ps/v102quotientfieldcategory.ps @@ -0,0 +1,611 @@ +%!PS-Adobe-2.0 +%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006) +%%For: (root) root +%%Title: pic +%%Pages: (atend) +%%BoundingBox: 36 36 832 152 +%%EndComments +save +%%BeginProlog +/DotDict 200 dict def +DotDict begin + +/setupLatin1 { +mark +/EncodingVector 256 array def + EncodingVector 0 + +ISOLatin1Encoding 0 255 getinterval putinterval +EncodingVector 45 /hyphen put + +% Set up ISO Latin 1 character encoding +/starnetISO { + dup dup findfont dup length dict begin + { 1 index /FID ne { def }{ pop pop } ifelse + } forall + /Encoding EncodingVector def + currentdict end definefont +} def +/Times-Roman starnetISO def +/Times-Italic starnetISO def +/Times-Bold starnetISO def +/Times-BoldItalic starnetISO def +/Helvetica starnetISO def +/Helvetica-Oblique starnetISO def +/Helvetica-Bold starnetISO def +/Helvetica-BoldOblique starnetISO def +/Courier starnetISO def +/Courier-Oblique starnetISO def +/Courier-Bold starnetISO def +/Courier-BoldOblique starnetISO def +cleartomark +} bind def + +%%BeginResource: procset graphviz 0 0 +/coord-font-family /Times-Roman def +/default-font-family /Times-Roman def +/coordfont coord-font-family findfont 8 scalefont def + +/InvScaleFactor 1.0 def +/set_scale { + dup 1 exch div /InvScaleFactor exch def + dup scale +} bind def + +% styles +/solid { [] 0 setdash } bind def +/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def +/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def +/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def +/bold { 2 setlinewidth } bind def +/filled { } bind def +/unfilled { } bind def +/rounded { } bind def +/diagonals { } bind def + +% hooks for setting color +/nodecolor { sethsbcolor } bind def +/edgecolor { sethsbcolor } bind def +/graphcolor { sethsbcolor } bind def +/nopcolor {pop pop pop} bind def + +/beginpage { % i j npages + /npages exch def + /j exch def + /i exch def + /str 10 string def + npages 1 gt { + gsave + coordfont setfont + 0 0 moveto + (\() show i str cvs show (,) show j str cvs show (\)) show + grestore + } if +} bind def + +/set_font { + findfont exch + scalefont setfont +} def + +% draw aligned label in bounding box aligned to current point +/alignedtext { % width adj text + /text exch def + /adj exch def + /width exch def + gsave + width 0 gt { + text stringwidth pop adj mul 0 rmoveto + } if + [] 0 setdash + text show + grestore +} def + +/boxprim { % xcorner ycorner xsize ysize + 4 2 roll + moveto + 2 copy + exch 0 rlineto + 0 exch rlineto + pop neg 0 rlineto + closepath +} bind def + +/ellipse_path { + /ry exch def + /rx exch def + /y exch def + /x exch def + matrix currentmatrix + newpath + x y translate + rx ry scale + 0 0 1 0 360 arc + setmatrix +} bind def + +/endpage { showpage } bind def +/showpage { } def + +/layercolorseq + [ % layer color sequence - darkest to lightest + [0 0 0] + [.2 .8 .8] + [.4 .8 .8] + [.6 .8 .8] + [.8 .8 .8] + ] +def + +/layerlen layercolorseq length def + +/setlayer {/maxlayer exch def /curlayer exch def + layercolorseq curlayer 1 sub layerlen mod get + aload pop sethsbcolor + /nodecolor {nopcolor} def + /edgecolor {nopcolor} def + /graphcolor {nopcolor} def +} bind def + +/onlayer { curlayer ne {invis} if } def + +/onlayers { + /myupper exch def + /mylower exch def + curlayer mylower lt + curlayer myupper gt + or + {invis} if +} def + +/curlayer 0 def + +%%EndResource +%%EndProlog +%%BeginSetup +14 default-font-family set_font +1 setmiterlimit +% /arrowlength 10 def +% /arrowwidth 5 def + +% make sure pdfmark is harmless for PS-interpreters other than Distiller +/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse +% make '<<' and '>>' safe on PS Level 1 devices +/languagelevel where {pop languagelevel}{1} ifelse +2 lt { + userdict (<<) cvn ([) cvn load put + userdict (>>) cvn ([) cvn load put +} if + +%%EndSetup +%%Page: 1 1 +%%PageBoundingBox: 36 36 832 152 +%%PageOrientation: Portrait +gsave +36 36 796 116 boxprim clip newpath +36 36 translate +0 0 1 beginpage +1.0000 set_scale +4 4 translate 0 rotate +0.167 0.600 1.000 graphcolor +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 114 lineto +794 114 lineto +794 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 114 lineto +794 114 lineto +794 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% QuotientFieldCategory(a:IntegralDomain) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 513 108 moveto +261 108 lineto +261 72 lineto +513 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 513 108 moveto +261 108 lineto +261 72 lineto +513 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +268 85 moveto +(QuotientFieldCategory\(a:IntegralDomain\)) +[10.08 6.96 6.72 3.84 3.84 6.24 6.96 3.84 7.44 3.84 6.24 3.84 6.96 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 6.24 3.84 4.56 6.96 3.84 6.24 7.2 4.8 6.24 3.84 10.08 6.96 10.8 6.24 3.84 6.96 4.56] +xshow +end grestore +end grestore +% ALGEBRA... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 94 36 moveto +0 36 lineto +0 0 lineto +94 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 94 36 moveto +0 36 lineto +0 0 lineto +94 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 13 moveto +(ALGEBRA...) +[10.08 8.64 10.08 8.64 9.36 9.36 9.84 3.6 3.6 3.6] +xshow +end grestore +end grestore +% QuotientFieldCategory(a:IntegralDomain)->ALGEBRA... +newpath 277 72 moveto +227 63 166 51 104 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 105 33 moveto +94 33 lineto +103 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 105 33 moveto +94 33 lineto +103 39 lineto +closepath +stroke +end grestore +% DIFEXT... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 188 36 moveto +112 36 lineto +112 0 lineto +188 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 188 36 moveto +112 36 lineto +112 0 lineto +188 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +119 13 moveto +(DIFEXT...) +[10.08 4.56 7.68 8.64 10.08 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% QuotientFieldCategory(a:IntegralDomain)->DIFEXT... +newpath 319 72 moveto +285 63 243 51 198 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 199 33 moveto +188 33 lineto +197 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 199 33 moveto +188 33 lineto +197 39 lineto +closepath +stroke +end grestore +% FIELD... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 272 36 moveto +206 36 lineto +206 0 lineto +272 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 272 36 moveto +206 36 lineto +206 0 lineto +272 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +213 13 moveto +(FIELD...) +[7.68 4.56 8.64 8.64 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% QuotientFieldCategory(a:IntegralDomain)->FIELD... +newpath 350 72 moveto +329 62 303 50 281 39 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 282 36 moveto +272 34 lineto +279 42 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 282 36 moveto +272 34 lineto +279 42 lineto +closepath +stroke +end grestore +% FEVALAB... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 380 36 moveto +290 36 lineto +290 0 lineto +380 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 380 36 moveto +290 36 lineto +290 0 lineto +380 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +298 13 moveto +(FEVALAB...) +[7.68 8.64 8.4 10.08 8.64 10.08 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% QuotientFieldCategory(a:IntegralDomain)->FEVALAB... +newpath 374 72 moveto +368 64 361 53 354 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 357 42 moveto +348 36 lineto +351 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 357 42 moveto +348 36 lineto +351 46 lineto +closepath +stroke +end grestore +% FLINEXP... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 480 36 moveto +398 36 lineto +398 0 lineto +480 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 480 36 moveto +398 36 lineto +398 0 lineto +480 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +405 13 moveto +(FLINEXP...) +[7.68 8.64 4.56 10.08 8.64 10.08 6.24 3.6 3.6 3.6] +xshow +end grestore +end grestore +% QuotientFieldCategory(a:IntegralDomain)->FLINEXP... +newpath 400 72 moveto +406 64 413 53 420 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 423 46 moveto +426 36 lineto +417 42 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 423 46 moveto +426 36 lineto +417 42 lineto +closepath +stroke +end grestore +% FPATMAB... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 590 36 moveto +498 36 lineto +498 0 lineto +590 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 590 36 moveto +498 36 lineto +498 0 lineto +590 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +506 13 moveto +(FPATMAB...) +[7.68 6.48 9.36 8.64 12.48 10.08 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% QuotientFieldCategory(a:IntegralDomain)->FPATMAB... +newpath 427 72 moveto +448 62 474 50 496 40 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 497 43 moveto +505 36 lineto +494 37 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 497 43 moveto +505 36 lineto +494 37 lineto +closepath +stroke +end grestore +% PATAB... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 680 36 moveto +608 36 lineto +608 0 lineto +680 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 680 36 moveto +608 36 lineto +608 0 lineto +680 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +616 13 moveto +(PATAB...) +[6.48 9.36 7.92 10.08 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% QuotientFieldCategory(a:IntegralDomain)->PATAB... +newpath 468 72 moveto +506 63 550 51 598 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 599 39 moveto +608 33 lineto +597 33 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 599 39 moveto +608 33 lineto +597 33 lineto +closepath +stroke +end grestore +% RETRACT... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 788 36 moveto +698 36 lineto +698 0 lineto +788 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 788 36 moveto +698 36 lineto +698 0 lineto +788 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +706 13 moveto +(RETRACT...) +[9.36 8.64 8.64 9.36 9.36 9.36 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% QuotientFieldCategory(a:IntegralDomain)->RETRACT... +newpath 509 72 moveto +561 63 624 52 688 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 689 39 moveto +698 33 lineto +687 33 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 689 39 moveto +698 33 lineto +687 33 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/changelog b/changelog index 8ac1b44..e159796 100644 --- a/changelog +++ b/changelog @@ -1,3 +1,14 @@ +20081023 tpd books/bookvol10.2 add categories +20081023 tpd books/ps/v102quotientfieldcategory.ps added +20081023 tpd books/ps/v102finitedivisorcategory.ps added +20081023 tpd books/ps/v102expressionspace.ps added +20081023 tpd books/ps/v102differentialvariablecategory.ps added +20081023 tpd books/ps/v102differentialpolynomialcategory.ps added +20081023 tpd books/ps/v102combinatorialopscategory.ps added +20081023 tpd src/algebra/dpolcat.spad move categories to bookvol10.2 +20081023 tpd src/algebra/divisor.spad move categories to bookvol10.2 +20081023 tpd src/algebra/combfunc.spad move categories to bookvol10.2 +20081017 tpd src/algebra/algcat.spad move categories to bookvol10.2 20081008 tpd books/bookvol10.2 add ACF, cleanup MONOGEN, FFCAT 20081008 tpd books/ps/v102algebraicallyclosedfield.ps added 20081008 tpd src/algebra/algfunc.spad move ACF to bookvol10.2 diff --git a/src/algebra/algcat.spad.pamphlet b/src/algebra/algcat.spad.pamphlet index 0462ae2..6eacd5c 100644 --- a/src/algebra/algcat.spad.pamphlet +++ b/src/algebra/algcat.spad.pamphlet @@ -9,282 +9,11 @@ \eject \tableofcontents \eject -\section{category FINRALG FiniteRankAlgebra} -<>= -"FINRALG" -> "ALGEBRA" -"FiniteRankAlgebra(a:CommutativeRing,b:UnivariatePolynomialCategory(a))" -> - "Algebra(a:CommutativeRing)" -@ -<>= -)abbrev category FINRALG FiniteRankAlgebra -++ Author: Barry Trager -++ Date Created: -++ Date Last Updated: -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ References: -++ Description: -++ A FiniteRankAlgebra is an algebra over a commutative ring R which -++ is a free R-module of finite rank. - -FiniteRankAlgebra(R:CommutativeRing, UP:UnivariatePolynomialCategory R): - Category == Algebra R with - rank : () -> PositiveInteger - ++ rank() returns the rank of the algebra. - regularRepresentation : (% , Vector %) -> Matrix R - ++ regularRepresentation(a,basis) returns the matrix of the - ++ linear map defined by left multiplication by \spad{a} with respect - ++ to the basis \spad{basis}. - trace : % -> R - ++ trace(a) returns the trace of the regular representation - ++ of \spad{a} with respect to any basis. - norm : % -> R - ++ norm(a) returns the determinant of the regular representation - ++ of \spad{a} with respect to any basis. - coordinates : (%, Vector %) -> Vector R - ++ coordinates(a,basis) returns the coordinates of \spad{a} with - ++ respect to the basis \spad{basis}. - coordinates : (Vector %, Vector %) -> Matrix R - ++ coordinates([v1,...,vm], basis) returns the coordinates of the - ++ vi's with to the basis \spad{basis}. The coordinates of vi are - ++ contained in the ith row of the matrix returned by this - ++ function. - represents : (Vector R, Vector %) -> % - ++ represents([a1,..,an],[v1,..,vn]) returns \spad{a1*v1 + ... + an*vn}. - discriminant : Vector % -> R - ++ discriminant([v1,..,vn]) returns - ++ \spad{determinant(traceMatrix([v1,..,vn]))}. - traceMatrix : Vector % -> Matrix R - ++ traceMatrix([v1,..,vn]) is the n-by-n matrix ( Tr(vi * vj) ) - characteristicPolynomial: % -> UP - ++ characteristicPolynomial(a) returns the characteristic - ++ polynomial of the regular representation of \spad{a} with respect - ++ to any basis. - if R has Field then minimalPolynomial : % -> UP - ++ minimalPolynomial(a) returns the minimal polynomial of \spad{a}. - if R has CharacteristicZero then CharacteristicZero - if R has CharacteristicNonZero then CharacteristicNonZero - - add - - discriminant v == determinant traceMatrix v - - coordinates(v:Vector %, b:Vector %) == - m := new(#v, #b, 0)$Matrix(R) - for i in minIndex v .. maxIndex v for j in minRowIndex m .. repeat - setRow_!(m, j, coordinates(qelt(v, i), b)) - m - - represents(v, b) == - m := minIndex v - 1 - _+/[v(i+m) * b(i+m) for i in 1..rank()] - - traceMatrix v == - matrix [[trace(v.i*v.j) for j in minIndex v..maxIndex v]$List(R) - for i in minIndex v .. maxIndex v]$List(List R) - - regularRepresentation(x, b) == - m := minIndex b - 1 - matrix - [parts coordinates(x*b(i+m),b) for i in 1..rank()]$List(List R) - -@ -\section{category FRAMALG FramedAlgebra} -<>= -"FRAMALG" -> "FINRALG" -"FramedAlgebra(a:CommutativeRing,b:UnivariatePolynomialCategory(a))" -> - "FiniteRankAlgebra(a:CommutativeRing,b:UnivariatePolynomialCategory(a))" -@ -<>= -)abbrev category FRAMALG FramedAlgebra -++ Author: Barry Trager -++ Date Created: -++ Date Last Updated: -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ References: -++ Description: -++ A \spadtype{FramedAlgebra} is a \spadtype{FiniteRankAlgebra} together -++ with a fixed R-module basis. - -FramedAlgebra(R:CommutativeRing, UP:UnivariatePolynomialCategory R): - Category == FiniteRankAlgebra(R, UP) with - --operations - basis : () -> Vector % - ++ basis() returns the fixed R-module basis. - coordinates : % -> Vector R - ++ coordinates(a) returns the coordinates of \spad{a} with respect to the - ++ fixed R-module basis. - coordinates : Vector % -> Matrix R - ++ coordinates([v1,...,vm]) returns the coordinates of the - ++ vi's with to the fixed basis. The coordinates of vi are - ++ contained in the ith row of the matrix returned by this - ++ function. - represents : Vector R -> % - ++ represents([a1,..,an]) returns \spad{a1*v1 + ... + an*vn}, where - ++ v1, ..., vn are the elements of the fixed basis. - convert : % -> Vector R - ++ convert(a) returns the coordinates of \spad{a} with respect to the - ++ fixed R-module basis. - convert : Vector R -> % - ++ convert([a1,..,an]) returns \spad{a1*v1 + ... + an*vn}, where - ++ v1, ..., vn are the elements of the fixed basis. - traceMatrix : () -> Matrix R - ++ traceMatrix() is the n-by-n matrix ( \spad{Tr(vi * vj)} ), where - ++ v1, ..., vn are the elements of the fixed basis. - discriminant : () -> R - ++ discriminant() = determinant(traceMatrix()). - regularRepresentation : % -> Matrix R - ++ regularRepresentation(a) returns the matrix of the linear - ++ map defined by left multiplication by \spad{a} with respect - ++ to the fixed basis. - --attributes - --separable <=> discriminant() ^= 0 - add - convert(x:%):Vector(R) == coordinates(x) - convert(v:Vector R):% == represents(v) - traceMatrix() == traceMatrix basis() - discriminant() == discriminant basis() - regularRepresentation x == regularRepresentation(x, basis()) - coordinates x == coordinates(x, basis()) - represents x == represents(x, basis()) - - coordinates(v:Vector %) == - m := new(#v, rank(), 0)$Matrix(R) - for i in minIndex v .. maxIndex v for j in minRowIndex m .. repeat - setRow_!(m, j, coordinates qelt(v, i)) - m - - regularRepresentation x == - m := new(n := rank(), n, 0)$Matrix(R) - b := basis() - for i in minIndex b .. maxIndex b for j in minRowIndex m .. repeat - setRow_!(m, j, coordinates(x * qelt(b, i))) - m - - characteristicPolynomial x == - mat00 := (regularRepresentation x) - mat0 := map(#1 :: UP,mat00)$MatrixCategoryFunctions2(R, Vector R, - Vector R, Matrix R, UP, Vector UP,Vector UP, Matrix UP) - mat1 : Matrix UP := scalarMatrix(rank(),monomial(1,1)$UP) - determinant(mat1 - mat0) - - if R has Field then - -- depends on the ordering of results from nullSpace, also see FFP - minimalPolynomial(x:%):UP == - y:%:=1 - n:=rank() - m:Matrix R:=zero(n,n+1) - for i in 1..n+1 repeat - setColumn_!(m,i,coordinates(y)) - y:=y*x - v:=first nullSpace(m) - +/[monomial(v.(i+1),i) for i in 0..#v-1] - -@ -\section{category MONOGEN MonogenicAlgebra} -<>= -"MONOGEN" -> "FRAMALG" -"MonogenicAlgebra(a:CommutativeRing,b:UnivariatePolynomialCategory(a))" -> - "FramedAlgebra(a:CommutativeRing,b:UnivariatePolynomialCategory(a))" -"MONOGEN" -> "COMRING" -"MonogenicAlgebra(a:CommutativeRing,b:UnivariatePolynomialCategory(a))" -> - "CommutativeRing()" -"MONOGEN" -> "KONVERT" -"MonogenicAlgebra(a:CommutativeRing,b:UnivariatePolynomialCategory(a))" -> - "ConvertibleTo(UnivariatePolynomialCategory(CommutativeRing))" -"MONOGEN" -> "FRETRCT" -"MonogenicAlgebra(a:CommutativeRing,b:UnivariatePolynomialCategory(a))" -> - "FullyRetractableTo(a:CommutativeRing)" -"MONOGEN" -> "FLINEXP" -"MonogenicAlgebra(a:CommutativeRing,b:UnivariatePolynomialCategory(a))" -> - "FullyLinearlyExplicitRingOver(a:CommutativeRing)" -@ -<>= -)abbrev category MONOGEN MonogenicAlgebra -++ Author: Barry Trager -++ Date Created: -++ Date Last Updated: -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ References: -++ Description: -++ A \spadtype{MonogenicAlgebra} is an algebra of finite rank which -++ can be generated by a single element. - -MonogenicAlgebra(R:CommutativeRing, UP:UnivariatePolynomialCategory R): - Category == - Join(FramedAlgebra(R, UP), CommutativeRing, ConvertibleTo UP, - FullyRetractableTo R, FullyLinearlyExplicitRingOver R) with - generator : () -> % - ++ generator() returns the generator for this domain. - definingPolynomial: () -> UP - ++ definingPolynomial() returns the minimal polynomial which - ++ \spad{generator()} satisfies. - reduce : UP -> % - ++ reduce(up) converts the univariate polynomial up to an algebra - ++ element, reducing by the \spad{definingPolynomial()} if necessary. - convert : UP -> % - ++ convert(up) converts the univariate polynomial up to an algebra - ++ element, reducing by the \spad{definingPolynomial()} if necessary. - lift : % -> UP - ++ lift(z) returns a minimal degree univariate polynomial up such that - ++ \spad{z=reduce up}. - if R has Finite then Finite - if R has Field then - Field - DifferentialExtension R - reduce : Fraction UP -> Union(%, "failed") - ++ reduce(frac) converts the fraction frac to an algebra element. - derivationCoordinates: (Vector %, R -> R) -> Matrix R - ++ derivationCoordinates(b, ') returns M such that \spad{b' = M b}. - if R has FiniteFieldCategory then FiniteFieldCategory - add - convert(x:%):UP == lift x - convert(p:UP):% == reduce p - generator() == reduce monomial(1, 1)$UP - norm x == resultant(definingPolynomial(), lift x) - retract(x:%):R == retract lift x - retractIfCan(x:%):Union(R, "failed") == retractIfCan lift x - - basis() == - [reduce monomial(1,i)$UP for i in 0..(rank()-1)::NonNegativeInteger] - - characteristicPolynomial(x:%):UP == - characteristicPolynomial(x)$CharacteristicPolynomialInMonogenicalAlgebra(R,UP,%) - - if R has Finite then - size() == size()$R ** rank() - random() == represents [random()$R for i in 1..rank()]$Vector(R) - - if R has Field then - reduce(x:Fraction UP) == reduce(numer x) exquo reduce(denom x) - - differentiate(x:%, d:R -> R) == - p := definingPolynomial() - yprime := - reduce(map(d, p)) / reduce(differentiate p) - reduce(map(d, lift x)) + yprime * reduce differentiate lift x - - derivationCoordinates(b, d) == - coordinates(map(differentiate(#1, d), b), b) - - recip x == - (bc := extendedEuclidean(lift x, definingPolynomial(), 1)) - case "failed" => "failed" - reduce(bc.coef1) - -@ \section{package CPIMA CharacteristicPolynomialInMonogenicalAlgebra} <>= +"CPIMA" [color=orange,style=filled]; +"CharacteristicPolynomialInMonogenicalAlgebra(a:COMRING,b:UPOLYC(a),c:MONOGEN(a,b))" + [color=orange,style=filled]; "CPIMA" -> "PACKAGE" "CharacteristicPolynomialInMonogenicalAlgebra(a:COMRING,b:UPOLYC(a),c:MONOGEN(a,b))" -> "Package" @@ -327,6 +56,9 @@ CharacteristicPolynomialInMonogenicalAlgebra(R : CommutativeRing, @ \section{package NORMMA NormInMonogenicAlgebra} <>= +"NORMMA" [color=orange,style=filled]; +"NormInMonogenicAlgebra(a:GcdDomain,b:UPOLYC(a),c:MONOGEN(a,b),d:UPOLYC(c))" + [color=orange,style=filled]; "NORMMA" -> "PACKAGE" "NormInMonogenicAlgebra(a:GcdDomain,b:UPOLYC(a),c:MONOGEN(a,b),d:UPOLYC(c))" -> "Package" @@ -406,9 +138,6 @@ NormInMonogenicAlgebra(R, PolR, E, PolE): Exports == Implementation where <<*>>= <> -<> -<> -<> <> <> @ diff --git a/src/algebra/combfunc.spad.pamphlet b/src/algebra/combfunc.spad.pamphlet index 24dd91a..da46ed0 100644 --- a/src/algebra/combfunc.spad.pamphlet +++ b/src/algebra/combfunc.spad.pamphlet @@ -9,37 +9,9 @@ \eject \tableofcontents \eject -\section{category COMBOPC CombinatorialOpsCategory} -<>= -)abbrev category COMBOPC CombinatorialOpsCategory -++ Category for summations and products -++ Author: Manuel Bronstein -++ Date Created: ??? -++ Date Last Updated: 22 February 1993 (JHD/BMT) -++ Description: -++ CombinatorialOpsCategory is the category obtaining by adjoining -++ summations and products to the usual combinatorial operations; -CombinatorialOpsCategory(): Category == - CombinatorialFunctionCategory with - factorials : $ -> $ - ++ factorials(f) rewrites the permutations and binomials in f - ++ in terms of factorials; - factorials : ($, Symbol) -> $ - ++ factorials(f, x) rewrites the permutations and binomials in f - ++ involving x in terms of factorials; - summation : ($, Symbol) -> $ - ++ summation(f(n), n) returns the formal sum S(n) which verifies - ++ S(n+1) - S(n) = f(n); - summation : ($, SegmentBinding $) -> $ - ++ summation(f(n), n = a..b) returns f(a) + ... + f(b) as a - ++ formal sum; - product : ($, Symbol) -> $ - ++ product(f(n), n) returns the formal product P(n) which verifies - ++ P(n+1)/P(n) = f(n); - product : ($, SegmentBinding $) -> $ - ++ product(f(n), n = a..b) returns f(a) * ... * f(b) as a - ++ formal product; - +<>= +"COMBF" -> "PACKAGE" +"CombinatorialFunction(a:Join(ORDSET,INTDOM),b:FS(a))" -> "Package" @ <>= )abbrev package COMBF CombinatorialFunction @@ -52,8 +24,6 @@ CombinatorialOpsCategory(): Category == ++ Keywords: combinatorial, function, factorial. ++ Examples: )r COMBF INPUT - - CombinatorialFunction(R, F): Exports == Implementation where R: Join(OrderedSet, IntegralDomain) F: FunctionSpace R @@ -670,6 +640,10 @@ equality. \section{package FSPECF FunctionalSpecialFunction} +<>= +"FSPECF" -> "PACKAGE" +"FunctionalSpecialFunction(a:Join(ORDSET,INTDOM),b:FS(a))" -> "Package" +@ <>= )abbrev package FSPECF FunctionalSpecialFunction ++ Provides the special functions @@ -1057,6 +1031,10 @@ component of the gradient failed, it resulted in an infinite loop for @ \section{package SUMFS FunctionSpaceSum} +<>= +"SUMFS" -> "PACKAGE" +"FunctionSpaceSum(a:Join(...),b:Join(...))" -> "Package" +@ <>= )abbrev package SUMFS FunctionSpaceSum ++ Top-level sum function @@ -1155,7 +1133,6 @@ FunctionSpaceSum(R, F): Exports == Implementation where -- op kl function funcpkgs manip algfunc -- elemntry constant funceval COMBFUNC fe -<> <> <> <> diff --git a/src/algebra/divisor.spad.pamphlet b/src/algebra/divisor.spad.pamphlet index 1d402c7..ffe3681 100644 --- a/src/algebra/divisor.spad.pamphlet +++ b/src/algebra/divisor.spad.pamphlet @@ -563,62 +563,6 @@ FramedModule(R, F, UP, A, ibasis): Exports == Implementation where module(basis i) * module(ibasis) @ -\section{category FDIVCAT FiniteDivisorCategory} -<>= -)abbrev category FDIVCAT FiniteDivisorCategory -++ Category for finite rational divisors on a curve -++ Author: Manuel Bronstein -++ Date Created: 19 May 1993 -++ Date Last Updated: 19 May 1993 -++ Description: -++ This category describes finite rational divisors on a curve, that -++ is finite formal sums SUM(n * P) where the n's are integers and the -++ P's are finite rational points on the curve. -++ Keywords: divisor, algebraic, curve. -++ Examples: )r FDIV INPUT -FiniteDivisorCategory(F, UP, UPUP, R): Category == Result where - F : Field - UP : UnivariatePolynomialCategory F - UPUP: UnivariatePolynomialCategory Fraction UP - R : FunctionFieldCategory(F, UP, UPUP) - - ID ==> FractionalIdeal(UP, Fraction UP, UPUP, R) - - Result ==> AbelianGroup with - ideal : % -> ID - ++ ideal(D) returns the ideal corresponding to a divisor D. - divisor : ID -> % - ++ divisor(I) makes a divisor D from an ideal I. - divisor : R -> % - ++ divisor(g) returns the divisor of the function g. - divisor : (F, F) -> % - ++ divisor(a, b) makes the divisor P: \spad{(x = a, y = b)}. - ++ Error: if P is singular. - divisor : (F, F, Integer) -> % - ++ divisor(a, b, n) makes the divisor - ++ \spad{nP} where P: \spad{(x = a, y = b)}. - ++ P is allowed to be singular if n is a multiple of the rank. - decompose : % -> Record(id:ID, principalPart: R) - ++ decompose(d) returns \spad{[id, f]} where \spad{d = (id) + div(f)}. - reduce : % -> % - ++ reduce(D) converts D to some reduced form (the reduced forms can - ++ be differents in different implementations). - principal? : % -> Boolean - ++ principal?(D) tests if the argument is the divisor of a function. - generator : % -> Union(R, "failed") - ++ generator(d) returns f if \spad{(f) = d}, - ++ "failed" if d is not principal. - divisor : (R, UP, UP, UP, F) -> % - ++ divisor(h, d, d', g, r) returns the sum of all the finite points - ++ where \spad{h/d} has residue \spad{r}. - ++ \spad{h} must be integral. - ++ \spad{d} must be squarefree. - ++ \spad{d'} is some derivative of \spad{d} (not necessarily dd/dx). - ++ \spad{g = gcd(d,discriminant)} contains the ramified zeros of \spad{d} - add - principal? d == generator(d) case R - -@ \section{domain HELLFDIV HyperellipticFiniteDivisor} <>= )abbrev domain HELLFDIV HyperellipticFiniteDivisor @@ -997,7 +941,6 @@ FiniteDivisorFunctions2(R1, UP1, UPUP1, F1, R2, UP2, UPUP2, F2): <> <> <> -<> <> <> <> diff --git a/src/algebra/dpolcat.spad.pamphlet b/src/algebra/dpolcat.spad.pamphlet index f01f7df..226a5e2 100644 --- a/src/algebra/dpolcat.spad.pamphlet +++ b/src/algebra/dpolcat.spad.pamphlet @@ -9,118 +9,6 @@ \eject \tableofcontents \eject -\section{category DVARCAT DifferentialVariableCategory} -<>= -)abbrev category DVARCAT DifferentialVariableCategory -++ Author: William Sit -++ Date Created: 19 July 1990 -++ Date Last Updated: 13 September 1991 -++ Basic Operations: -++ Related Constructors:DifferentialPolynomialCategory -++ See Also:OrderedDifferentialVariable, -++ SequentialDifferentialVariable, -++ DifferentialSparseMultivariatePolynomial. -++ AMS Classifications:12H05 -++ Keywords: differential indeterminates, ranking, order, weight -++ References:Ritt, J.F. "Differential Algebra" (Dover, 1950). -++ Description: -++ \spadtype{DifferentialVariableCategory} constructs the -++ set of derivatives of a given set of -++ (ordinary) differential indeterminates. -++ If x,...,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 -++ x,\spad{x'},\spad{x''},..., y,\spad{y'},\spad{y''},... -++ (Note: in the interpreter, the n-th derivative of y is displayed as -++ y with a subscript 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. -++ -++ 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. -++ -++ 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. -DifferentialVariableCategory(S:OrderedSet): Category == - Join(OrderedSet, RetractableTo S) with - -- Examples: - -- v:=makeVariable('s,5) - makeVariable : (S, NonNegativeInteger) -> $ - ++ makeVariable(s, n) returns the n-th derivative of a - ++ differential indeterminate s as an algebraic indeterminate. - -- Example: makeVariable('s, 5) - order : $ -> NonNegativeInteger - ++ order(v) returns n if v is the n-th derivative of any - ++ differential indeterminate. - -- Example: order(v) - variable : $ -> S - ++ variable(v) returns s if v is any derivative of the differential - ++ indeterminate s. - -- Example: variable(v) - -- default implementation using above primitives -- - - weight : $ -> NonNegativeInteger - ++ weight(v) returns the weight of the derivative v. - -- Example: weight(v) - differentiate : $ -> $ - ++ differentiate(v) returns the derivative of v. - -- Example: differentiate(v) - differentiate : ($, NonNegativeInteger) -> $ - ++ differentiate(v, n) returns the n-th derivative of v. - -- Example: differentiate(v,2) - coerce : S -> $ - ++ coerce(s) returns s, viewed as the zero-th order derivative of s. - -- Example: coerce('s); differentiate(%,5) - add - import NumberFormats - coerce (s:S):$ == makeVariable(s, 0) - differentiate v == differentiate(v, 1) - differentiate(v, n) == makeVariable(variable v, n + order v) - retractIfCan v == (zero?(order v) => variable v; "failed") - v = u == (variable v = variable u) and (order v = order u) - - coerce(v:$):OutputForm == - a := variable(v)::OutputForm - zero?(nn := order v) => a - sub(a, outputForm nn) - retract v == - zero?(order v) => variable v - error "Not retractable" - v < u == - -- the ranking below is orderly, and is the default -- - order v = order u => variable v < variable u - order v < order u - weight v == order v - -- the default weight is just the order - -@ \section{domain ODVAR OrderlyDifferentialVariable} <>= )abbrev domain ODVAR OrderlyDifferentialVariable @@ -192,237 +80,6 @@ SequentialDifferentialVariable(S:OrderedSet):DifferentialVariableCategory(S) variable v < variable u @ -\section{category DPOLCAT DifferentialPolynomialCategory} -<>= -)abbrev category DPOLCAT DifferentialPolynomialCategory -++ Author: William Sit -++ Date Created: 19 July 1990 -++ Date Last Updated: 13 September 1991 -++ Basic Operations:PolynomialCategory -++ Related Constructors:DifferentialVariableCategory -++ See Also: -++ AMS Classifications:12H05 -++ Keywords: differential indeterminates, ranking, differential polynomials, -++ order, weight, leader, separant, initial, isobaric -++ References:Kolchin, E.R. "Differential Algebra and Algebraic Groups" -++ (Academic Press, 1973). -++ Description: -++ \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}. -++ -++ To construct a domain using this constructor, one needs -++ to provide a ground ring R, an ordered set S of differential -++ indeterminates, a ranking V on the set of derivatives -++ of the differential indeterminates, and a set E of -++ exponents in bijection with the set of differential monomials -++ in the given differential indeterminates. -++ - -DifferentialPolynomialCategory(R:Ring,S:OrderedSet, - V:DifferentialVariableCategory S, E:OrderedAbelianMonoidSup): - Category == - Join(PolynomialCategory(R,E,V), - DifferentialExtension R, RetractableTo S) with - -- Examples: - -- s:=makeVariable('s) - -- p:= 3*(s 1)**2 + s*(s 2)**3 - -- all functions below have default implementations - -- using primitives from V - - makeVariable: S -> (NonNegativeInteger -> $) - ++ makeVariable(s) views s as a differential - ++ indeterminate, in such a way that the n-th - ++ derivative of s may be simply referenced as z.n - ++ where z :=makeVariable(s). - ++ Note: In the interpreter, z is - ++ given as an internal map, which may be ignored. - -- Example: makeVariable('s); %.5 - - differentialVariables: $ -> List S - ++ differentialVariables(p) returns a list of differential - ++ indeterminates occurring in a differential polynomial p. - order : ($, S) -> NonNegativeInteger - ++ order(p,s) returns the order of the differential - ++ polynomial p in differential indeterminate s. - order : $ -> NonNegativeInteger - ++ order(p) returns the order of the differential polynomial p, - ++ which is the maximum number of differentiations of a - ++ differential indeterminate, among all those appearing in p. - degree: ($, S) -> NonNegativeInteger - ++ degree(p, s) returns the maximum degree of - ++ the differential polynomial p viewed as a differential polynomial - ++ in the differential indeterminate s alone. - weights: $ -> List NonNegativeInteger - ++ weights(p) returns a list of weights of differential monomials - ++ appearing in differential polynomial p. - weight: $ -> NonNegativeInteger - ++ weight(p) returns the maximum weight of all differential monomials - ++ appearing in the differential polynomial p. - weights: ($, S) -> List NonNegativeInteger - ++ weights(p, s) returns a list of - ++ weights of differential monomials - ++ appearing in the differential polynomial p when p is viewed - ++ as a differential polynomial in the differential indeterminate s - ++ alone. - weight: ($, S) -> NonNegativeInteger - ++ weight(p, s) returns the maximum weight of all differential - ++ monomials appearing in the differential polynomial p - ++ when p is viewed as a differential polynomial in - ++ the differential indeterminate s alone. - isobaric?: $ -> Boolean - ++ isobaric?(p) returns true if every differential monomial appearing - ++ in the differential polynomial p has same weight, - ++ and returns false otherwise. - leader: $ -> V - ++ leader(p) returns the derivative of the highest rank - ++ appearing in the differential polynomial p - ++ Note: an error occurs if p is in the ground ring. - initial:$ -> $ - ++ initial(p) returns the - ++ leading coefficient when the differential polynomial p - ++ is written as a univariate polynomial in its leader. - separant:$ -> $ - ++ separant(p) returns the - ++ partial derivative of the differential polynomial p - ++ with respect to its leader. - if R has DifferentialRing then - InnerEvalable(S, R) - InnerEvalable(S, $) - Evalable $ - makeVariable: $ -> (NonNegativeInteger -> $) - ++ makeVariable(p) views p as an element of a differential - ++ ring, in such a way that the n-th - ++ derivative of p may be simply referenced as z.n - ++ where z := makeVariable(p). - ++ Note: In the interpreter, z is - ++ given as an internal map, which may be ignored. - -- Example: makeVariable(p); %.5; makeVariable(%**2); %.2 - - add - p:$ - s:S - makeVariable s == makeVariable(s,#1)::$ - - if R has IntegralDomain then - differentiate(p:$, d:R -> R) == - ans:$ := 0 - l := variables p - while (u:=retractIfCan(p)@Union(R, "failed")) case "failed" repeat - t := leadingMonomial p - lc := leadingCoefficient t - ans := ans + d(lc)::$ * (t exquo lc)::$ - + +/[differentiate(t, v) * (differentiate v)::$ for v in l] - p := reductum p - ans + d(u::R)::$ - - order (p:$):NonNegativeInteger == - ground? p => 0 - "max"/[order v for v in variables p] - order (p:$,s:S):NonNegativeInteger == - ground? p => 0 - empty? (vv:= [order v for v in variables p | (variable v) = s ]) =>0 - "max"/vv - - degree (p, s) == - d:NonNegativeInteger:=0 - for lp in monomials p repeat - lv:= [v for v in variables lp | (variable v) = s ] - if not empty? lv then d:= max(d, +/degree(lp, lv)) - d - - weights p == - ws:List NonNegativeInteger := nil - empty? (mp:=monomials p) => ws - for lp in mp repeat - lv:= variables lp - if not empty? lv then - dv:= degree(lp, lv) - w:=+/[(weight v) * d for v in lv for d in dv]$(List NonNegativeInteger) - ws:= concat(ws, w) - ws - weight p == - empty? (ws:=weights p) => 0 - "max"/ws - - weights (p, s) == - ws:List NonNegativeInteger := nil - empty?(mp:=monomials p) => ws - for lp in mp repeat - lv:= [v for v in variables lp | (variable v) = s ] - if not empty? lv then - dv:= degree(lp, lv) - w:=+/[(weight v) * d for v in lv for d in dv]$(List NonNegativeInteger) - ws:= concat(ws, w) - ws - weight (p,s) == - empty? (ws:=weights(p,s)) => 0 - "max"/ws - - isobaric? p == (# removeDuplicates weights p) = 1 - - leader p == -- depends on the ranking - vl:= variables p - -- it's not enough just to look at leadingMonomial p - -- the term-ordering need not respect the ranking - empty? vl => error "leader is not defined " - "max"/vl - initial p == leadingCoefficient univariate(p,leader p) - separant p == differentiate(p, leader p) - - coerce(s:S):$ == s::V::$ - - retractIfCan(p:$):Union(S, "failed") == - (v := retractIfCan(p)@Union(V,"failed")) case "failed" => "failed" - retractIfCan(v::V) - - differentialVariables p == - removeDuplicates [variable v for v in variables p] - - if R has DifferentialRing then - - makeVariable p == differentiate(p, #1) - - eval(p:$, sl:List S, rl:List R) == - ordp:= order p - vl := concat [[makeVariable(s,j)$V for j in 0..ordp] - for s in sl]$List(List V) - rrl:=nil$List(R) - for r in rl repeat - t:= r - rrl:= concat(rrl, - concat(r, [t := differentiate t for i in 1..ordp])) - eval(p, vl, rrl) - - eval(p:$, sl:List S, rl:List $) == - ordp:= order p - vl := concat [[makeVariable(s,j)$V for j in 0..ordp] - for s in sl]$List(List V) - rrl:=nil$List($) - for r in rl repeat - t:=r - rrl:=concat(rrl, - concat(r, [t:=differentiate t for i in 1..ordp])) - eval(p, vl, rrl) - eval(p:$, l:List Equation $) == - eval(p, [retract(lhs e)@S for e in l]$List(S), - [rhs e for e in l]$List($)) - -@ \section{domain DSMP DifferentialSparseMultivariatePolynomial} <>= )abbrev domain DSMP DifferentialSparseMultivariatePolynomial @@ -1227,10 +884,8 @@ SequentialDifferentialPolynomial(R): <<*>>= <> -<> <> <> -<> <> <> <>