diff --git a/books/bookvol10.2.pamphlet b/books/bookvol10.2.pamphlet index 0b5d3db..635a0c6 100644 --- a/books/bookvol10.2.pamphlet +++ b/books/bookvol10.2.pamphlet @@ -798,6 +798,7 @@ digraph pic { {\bf See:}\\ \pageto{CombinatorialOpsCategory}{COMBOPC} +\pageto{IntegerNumberSystem}{INS} \pagefrom{Category}{CATEGORY} {\bf Exports:}\\ @@ -868,6 +869,7 @@ digraph pic { {\bf See:}\\ \pageto{Collection}{CLAGG} \pageto{FunctionSpace}{FS} +\pageto{IntegerNumberSystem}{INS} \pageto{MonogenicAlgebra}{MONOGEN} \pageto{QuotientFieldCategory}{QFCAT} \pageto{RealConstant}{REAL} @@ -1414,6 +1416,7 @@ digraph pic { {\bf See:}\\ \pageto{FunctionSpace}{FS} +\pageto{IntegerNumberSystem}{INS} \pageto{QuotientFieldCategory}{QFCAT} \pagefrom{Category}{CATEGORY} @@ -1636,10 +1639,12 @@ digraph pic { \pageto{FullyRetractableTo}{FRETRCT} \pageto{FunctionSpace}{FS} \pageto{GradedAlgebra}{GRALG} +\pageto{IntegerNumberSystem}{INS} \pageto{IntervalCategory}{INTCAT} \pageto{PolynomialCategory}{POLYCAT} \pageto{QuotientFieldCategory}{QFCAT} \pageto{RealNumberSystem}{RNS} +\pageto{UnivariateLaurentSeriesConstructorCategory}{ULSCCAT} \pageto{XFreeAlgebra}{XFALG} \pagefrom{Category}{CATEGORY} @@ -2213,6 +2218,7 @@ digraph pic { \pagepic{ps/v102realconstant.ps}{REAL}{1.00} {\bf See:}\\ +\pageto{IntegerNumberSystem}{INS} \pageto{QuotientFieldCategory}{QFCAT} \pageto{RealNumberSystem}{RNS} \pagefrom{ConvertibleTo}{KONVERT} @@ -6706,6 +6712,7 @@ digraph pic { {\bf See:}\\ \pageto{FiniteFieldCategory}{FFIELDC} +\pageto{IntegerNumberSystem}{INS} \pageto{QuotientFieldCategory}{QFCAT} \pageto{UnivariatePolynomialCategory}{UPOLYC} \pagefrom{SetCategory}{SETCAT} @@ -11212,6 +11219,7 @@ digraph pic { {\bf See:}\\ \pageto{FunctionSpace}{FS} +\pageto{PermutationCategory}{PERMCAT} \pagefrom{Monoid}{MONOID} {\bf Exports:}\\ @@ -11257,10 +11265,6 @@ These are implemented by this category: ?**? : (%,Integer) -> % \end{verbatim} -These exports come from \refto{Aggregate}: -\begin{verbatim} -\end{verbatim} - These exports come from \refto{Monoid}(): \begin{verbatim} 1 : () -> % @@ -11382,7 +11386,6 @@ digraph pic { "Category" [color=lightblue]; } -} @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -15835,6 +15838,202 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{PermutationCategory}{PERMCAT} +\pagepic{ps/v102permutationcategory.ps}{PERMCAT}{0.65} + +{\bf See:}\\ +\pagefrom{Group}{GROUP} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{PERMCAT}{1} & +\cross{PERMCAT}{coerce} & +\cross{PERMCAT}{commutator} & +\cross{PERMCAT}{conjugate} & +\cross{PERMCAT}{cycle} \\ +\cross{PERMCAT}{cycles} & +\cross{PERMCAT}{eval} & +\cross{PERMCAT}{hash} & +\cross{PERMCAT}{inv} & +\cross{PERMCAT}{latex} \\ +\cross{PERMCAT}{max} & +\cross{PERMCAT}{min} & +\cross{PERMCAT}{one?} & +\cross{PERMCAT}{orbit} & +\cross{PERMCAT}{recip} \\ +\cross{PERMCAT}{sample} & +\cross{PERMCAT}{?\^{}?} & +\cross{PERMCAT}{?.?} & +\cross{PERMCAT}{?\~{}=?} & +\cross{PERMCAT}{?**?} \\ +\cross{PERMCAT}{?$<$?} & +\cross{PERMCAT}{?$<=$?} & +\cross{PERMCAT}{?$>$?} & +\cross{PERMCAT}{?$>=$?} & +\cross{PERMCAT}{?*?} \\ +\cross{PERMCAT}{?**?} & +\cross{PERMCAT}{?/?} & +\cross{PERMCAT}{?=?} && +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item {\bf \cross{ATTREG}{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. +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + cycle : List S -> % + cycles : List List S -> % + eval : (%,S) -> S + orbit : (%,S) -> Set S + ? Boolean + ?.? : (%,S) -> S +\end{verbatim} + +These exports come from \refto{Group}(): +\begin{verbatim} + 1 : () -> % + coerce : % -> OutputForm + commutator : (%,%) -> % + conjugate : (%,%) -> % + hash : % -> SingleInteger + inv : % -> % + latex : % -> String + one? : % -> Boolean + recip : % -> Union(%,"failed") + sample : () -> % + ?/? : (%,%) -> % + ?^? : (%,NonNegativeInteger) -> % + ?^? : (%,PositiveInteger) -> % + ?^? : (%,Integer) -> % + ?*? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?**? : (%,NonNegativeInteger) -> % + ?**? : (%,PositiveInteger) -> % + ?**? : (%,Integer) -> % +\end{verbatim} + +These exports come from \refto{OrderedSet}(): +\begin{verbatim} + max : (%,%) -> % if S has ORDSET or S has FINITE + min : (%,%) -> % if S has ORDSET or S has FINITE + ?>? : (%,%) -> Boolean if S has ORDSET or S has FINITE + ?<=? : (%,%) -> Boolean if S has ORDSET or S has FINITE + ?>=? : (%,%) -> Boolean if S has ORDSET or S has FINITE +\end{verbatim} + +<>= +)abbrev category PERMCAT PermutationCategory +++ Authors: Holger Gollan, Johannes Grabmeier, Gerhard Schneider +++ Date Created: 27 July 1989 +++ Date Last Updated: 29 March 1990 +++ Basic Operations: cycle, cycles, eval, orbit +++ Related Constructors: PermutationGroup, PermutationGroupExamples +++ Also See: RepresentationTheoryPackage1 +++ AMS Classifications: +++ Keywords: permutation, symmetric group +++ References: +++ Description: PermutationCategory provides a categorial environment +++ for subgroups of bijections of a set (i.e. permutations) + +PermutationCategory(S:SetCategory): Category == Group with + cycle : List S -> % + ++ cycle(ls) coerces a cycle {\em ls}, i.e. a list with not + ++ repetitions to a permutation, which maps {\em ls.i} to + ++ {\em ls.i+1}, indices modulo the length of the list. + ++ Error: if repetitions occur. + cycles : List List S -> % + ++ cycles(lls) coerces a list list of cycles {\em lls} + ++ to a permutation, each cycle being a list with not + ++ repetitions, is coerced to the permutation, which maps + ++ {\em ls.i} to {\em ls.i+1}, indices modulo the length of the list, + ++ then these permutations are mutiplied. + ++ Error: if repetitions occur in one cycle. + eval : (%,S) -> S + ++ eval(p, el) returns the image of {\em el} under the + ++ permutation p. + elt : (%,S) -> S + ++ elt(p, el) returns the image of {\em el} under the + ++ permutation p. + orbit : (%,S) -> Set S + ++ orbit(p, el) returns the orbit of {\em el} under the + ++ permutation p, i.e. the set which is given by applications of + ++ the powers of p to {\em el}. + "<" : (%,%) -> Boolean + ++ p < q is an order relation on permutations. + ++ Note: this order is only total if and only if S is totally ordered + ++ or S is finite. + if S has OrderedSet then OrderedSet + if S has Finite then OrderedSet + +@ +<>= +"PERMCAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=PERMCAT"]; +"PERMCAT" -> "GROUP" + +@ +<>= +"PermutationCategory(a:SetCategory)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=PERMCAT"]; +"PermutationCategory(a:SetCategory)" -> "Group()" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"PermutationCategory(a:SetCategory)" [color=lightblue]; +"PermutationCategory(a:SetCategory)" -> "Group()" + +"Group()" [color=lightblue]; +"Group()" -> "Monoid()" +"Group()" -> "RepeatedSquaring(Group)" + +"Monoid()" [color=lightblue]; +"Monoid()" -> "SemiGroup()" + +"SemiGroup()" [color=lightblue]; +"SemiGroup()" -> "SetCategory()" +"SemiGroup()" -> "RepeatedSquaring(SemiGroup)" + +"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" + +"RepeatedSquaring(Group)" [color="#00EE00"]; +"RepeatedSquaring(Group)" -> "RepeatedSquaring(a:SetCategory)" + +"RepeatedSquaring(SemiGroup)" [color="#00EE00"]; +"RepeatedSquaring(SemiGroup)" -> "RepeatedSquaring(a:SetCategory)" + +"RepeatedSquaring(a:SetCategory)" [color="#00EE00"]; +"RepeatedSquaring(a:SetCategory)" -> "Package" + +"Package" [color="#00EE00"]; + +"Category" [color=lightblue]; + +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{StreamAggregate}{STAGG} \pagepic{ps/v102streamaggregate.ps}{STAGG}{0.60} @@ -16234,6 +16433,7 @@ digraph pic { \pagepic{ps/v102triangularsetcategory.ps}{TSETCAT}{0.35} {\bf See:}\\ +\pageto{RegularTriangularSetCategory}{RSETCAT} \pagefrom{PolynomialSetCategory}{PSETCAT} {\bf Exports:}\\ @@ -16963,6 +17163,12 @@ TriangularSetCategory(R:IntegralDomain,E:OrderedAbelianMonoidSup,_ "TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" -> "PolynomialSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" +"TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=seagreen,href="bookvol10.2.pdf#nameddest=TSETCAT"]; +"TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> +"TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + @ <>= digraph pic { @@ -20269,6 +20475,664 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{RegularTriangularSetCategory}{RSETCAT} +\pagepic{ps/v102regulartriangularsetcategory.ps}{RSETCAT}{0.35} + +{\bf See:}\\ +\pageto{SquareFreeRegularTriangularSetCategory}{SFRTCAT} +\pagefrom{TriangularSetCategory}{TSETCAT} + +{\bf Exports:}\\ +\begin{tabular}{lll} +\cross{RSETCAT}{algebraicCoefficients?} & +\cross{RSETCAT}{algebraicVariables} & +\cross{RSETCAT}{any?} \\ +\cross{RSETCAT}{augment} & +\cross{RSETCAT}{autoReduced?} & +\cross{RSETCAT}{basicSet} \\ +\cross{RSETCAT}{coerce} & +\cross{RSETCAT}{coHeight} & +\cross{RSETCAT}{collect} \\ +\cross{RSETCAT}{collectQuasiMonic} & +\cross{RSETCAT}{collectUnder} & +\cross{RSETCAT}{collectUpper} \\ +\cross{RSETCAT}{construct} & +\cross{RSETCAT}{convert} & +\cross{RSETCAT}{copy} \\ +\cross{RSETCAT}{count} & +\cross{RSETCAT}{degree} & +\cross{RSETCAT}{empty} \\ +\cross{RSETCAT}{empty?} & +\cross{RSETCAT}{eq?} & +\cross{RSETCAT}{eval} \\ +\cross{RSETCAT}{every?} & +\cross{RSETCAT}{extend} & +\cross{RSETCAT}{extendIfCan} \\ +\cross{RSETCAT}{find} & +\cross{RSETCAT}{first} & +\cross{RSETCAT}{hash} \\ +\cross{RSETCAT}{headReduce} & +\cross{RSETCAT}{headReduced?} & +\cross{RSETCAT}{headRemainder} \\ +\cross{RSETCAT}{infRittWu?} & +\cross{RSETCAT}{initiallyReduce} & +\cross{RSETCAT}{initiallyReduced?} \\ +\cross{RSETCAT}{initials} & +\cross{RSETCAT}{internalAugment} & +\cross{RSETCAT}{intersect} \\ +\cross{RSETCAT}{invertible?} & +\cross{RSETCAT}{invertibleElseSplit?} & +\cross{RSETCAT}{invertibleSet} \\ +\cross{RSETCAT}{last} & +\cross{RSETCAT}{lastSubResultant} & +\cross{RSETCAT}{lastSubResultantElseSplit} \\ +\cross{RSETCAT}{less?} & +\cross{RSETCAT}{latex} & +\cross{RSETCAT}{mainVariable?} \\ +\cross{RSETCAT}{mainVariables} & +\cross{RSETCAT}{map} & +\cross{RSETCAT}{map!} \\ +\cross{RSETCAT}{member?} & +\cross{RSETCAT}{members} & +\cross{RSETCAT}{more?} \\ +\cross{RSETCAT}{mvar} & +\cross{RSETCAT}{normalized?} & +\cross{RSETCAT}{parts} \\ +\cross{RSETCAT}{purelyAlgebraic?} & +\cross{RSETCAT}{purelyAlgebraicLeadingMonomial?} & +\cross{RSETCAT}{purelyTranscendental?} \\ +\cross{RSETCAT}{quasiComponent} & +\cross{RSETCAT}{reduce} & +\cross{RSETCAT}{reduceByQuasiMonic} \\ +\cross{RSETCAT}{reduced?} & +\cross{RSETCAT}{remainder} & +\cross{RSETCAT}{remove} \\ +\cross{RSETCAT}{removeDuplicates} & +\cross{RSETCAT}{removeZero} & +\cross{RSETCAT}{rest} \\ +\cross{RSETCAT}{retract} & +\cross{RSETCAT}{retractIfCan} & +\cross{RSETCAT}{rewriteIdealWithHeadRemainder} \\ +\cross{RSETCAT}{rewriteIdealWithRemainder} & +\cross{RSETCAT}{rewriteSetWithReduction} & +\cross{RSETCAT}{roughBase?} \\ +\cross{RSETCAT}{roughEqualIdeals?} & +\cross{RSETCAT}{roughSubIdeal?} & +\cross{RSETCAT}{roughUnitIdeal?} \\ +\cross{RSETCAT}{sample} & +\cross{RSETCAT}{select} & +\cross{RSETCAT}{size?} \\ +\cross{RSETCAT}{sort} & +\cross{RSETCAT}{squareFreePart} & +\cross{RSETCAT}{stronglyReduce} \\ +\cross{RSETCAT}{stronglyReduced?} & +\cross{RSETCAT}{triangular?} & +\cross{RSETCAT}{trivialIdeal?} \\ +\cross{RSETCAT}{variables} & +\cross{RSETCAT}{zeroSetSplit} & +\cross{RSETCAT}{zeroSetSplitIntoTriangularSystems} \\ +\cross{RSETCAT}{\#?} & +\cross{RSETCAT}{?=?} & +\cross{RSETCAT}{?\~{}=?} \\ +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item {\bf \cross{RSETCAT}{shallowlyMutable}} +is true if its values have immediate components that are +updateable (mutable). Note: the properties of any component +domain are irrevelant to the shallowlyMutable proper. +\item {\bf \cross{RSETCAT}{finiteAggregate}} +is true if it is an aggregate with a finite number of elements. +\item {\bf nil} +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + augment : (P,%) -> List % + extend : (P,%) -> List % + internalAugment : (P,%) -> % + internalAugment : (List P,%) -> % + intersect : (P,%) -> List % + invertibleElseSplit? : (P,%) -> Union(Boolean,List %) + invertible? : (P,%) -> List Record(val: Boolean,tower: %) + invertible? : (P,%) -> Boolean + invertibleSet : (P,%) -> List % + lastSubResultant : (P,P,%) -> List Record(val: P,tower: %) + lastSubResultantElseSplit : (P,P,%) -> Union(P,List %) + squareFreePart : (P,%) -> List Record(val: P,tower: %) + zeroSetSplit : (List P,Boolean) -> List % +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + algebraicCoefficients? : (P,%) -> Boolean + augment : (P,List %) -> List % + augment : (List P,%) -> List % + augment : (List P,List %) -> List % + extend : (P,List %) -> List % + extend : (List P,%) -> List % + extend : (List P,List %) -> List % + intersect : (List P,List %) -> List % + intersect : (List P,%) -> List % + intersect : (P,List %) -> List % + purelyAlgebraic? : % -> Boolean + purelyAlgebraic? : (P,%) -> Boolean + purelyAlgebraicLeadingMonomial? : (P,%) -> Boolean + purelyTranscendental? : (P,%) -> Boolean +\end{verbatim} + +These exports come from \refto{TriangularSetCategory}(R,E,V,P)\\ +where R:GcdDomain, E:OrderedAbelianMonoidSup, V:OrderedSet,\\ +P:RecursivePolynomialCategory(R,E,V)): +\begin{verbatim} + algebraic? : (V,%) -> Boolean + algebraicVariables : % -> List V + any? : ((P -> Boolean),%) -> Boolean if $ has finiteAggregate + autoReduced? : (%,((P,List P) -> Boolean)) -> Boolean + basicSet : + (List P,((P,P) -> Boolean)) -> + Union(Record(bas: %,top: List P),"failed") + basicSet : + (List P,(P -> Boolean),((P,P) -> Boolean)) -> + Union(Record(bas: %,top: List P),"failed") + coerce : % -> List P + coerce : % -> OutputForm + coHeight : % -> NonNegativeInteger if V has FINITE + collect : (%,V) -> % + collectQuasiMonic : % -> % + collectUnder : (%,V) -> % + collectUpper : (%,V) -> % + construct : List P -> % + convert : % -> InputForm if P has KONVERT INFORM + copy : % -> % + count : ((P -> Boolean),%) -> NonNegativeInteger + if $ has finiteAggregate + count : (P,%) -> NonNegativeInteger + if P has SETCAT + and $ has finiteAggregate + degree : % -> NonNegativeInteger + empty : () -> % + empty? : % -> Boolean + eq? : (%,%) -> Boolean + eval : (%,List Equation P) -> % if P has EVALAB P and P has SETCAT + eval : (%,Equation P) -> % if P has EVALAB P and P has SETCAT + eval : (%,P,P) -> % if P has EVALAB P and P has SETCAT + eval : (%,List P,List P) -> % if P has EVALAB P and P has SETCAT + every? : ((P -> Boolean),%) -> Boolean if $ has finiteAggregate + extend : (%,P) -> % + extendIfCan : (%,P) -> Union(%,"failed") + find : ((P -> Boolean),%) -> Union(P,"failed") + first : % -> Union(P,"failed") + hash : % -> SingleInteger + headReduce : (P,%) -> P + headReduced? : % -> Boolean + headReduced? : (P,%) -> Boolean + headRemainder : (P,%) -> Record(num: P,den: R) if R has INTDOM + infRittWu? : (%,%) -> Boolean + initiallyReduce : (P,%) -> P + initiallyReduced? : % -> Boolean + initiallyReduced? : (P,%) -> Boolean + initials : % -> List P + last : % -> Union(P,"failed") + latex : % -> String + less? : (%,NonNegativeInteger) -> Boolean + mainVariable? : (V,%) -> Boolean + mainVariables : % -> List V + map : ((P -> P),%) -> % + map! : ((P -> P),%) -> % if $ has shallowlyMutable + member? : (P,%) -> Boolean if P has SETCAT and $ has finiteAggregate + members : % -> List P if $ has finiteAggregate + more? : (%,NonNegativeInteger) -> Boolean + mvar : % -> V + normalized? : % -> Boolean + normalized? : (P,%) -> Boolean + parts : % -> List P if $ has finiteAggregate + quasiComponent : % -> Record(close: List P,open: List P) + reduce : (((P,P) -> P),%) -> P if $ has finiteAggregate + reduce : (((P,P) -> P),%,P) -> P if $ has finiteAggregate + reduce : (((P,P) -> P),%,P,P) -> P + if P has SETCAT + and $ has finiteAggregate + reduce : (P,%,((P,P) -> P),((P,P) -> Boolean)) -> P + reduceByQuasiMonic : (P,%) -> P + reduced? : (P,%,((P,P) -> Boolean)) -> Boolean + remainder : (P,%) -> Record(rnum: R,polnum: P,den: R) if R has INTDOM + remove : ((P -> Boolean),%) -> % if $ has finiteAggregate + remove : (P,%) -> % if P has SETCAT and $ has finiteAggregate + removeDuplicates : % -> % if P has SETCAT and $ has finiteAggregate + removeZero : (P,%) -> P + rest : % -> Union(%,"failed") + retract : List P -> % + rewriteIdealWithHeadRemainder : (List P,%) -> List P if R has INTDOM + rewriteIdealWithRemainder : (List P,%) -> List P if R has INTDOM + retractIfCan : List P -> Union(%,"failed") + rewriteSetWithReduction : + (List P,%,((P,P) -> P),((P,P) -> Boolean)) -> List P + roughBase? : % -> Boolean if R has INTDOM + roughEqualIdeals? : (%,%) -> Boolean if R has INTDOM + roughSubIdeal? : (%,%) -> Boolean if R has INTDOM + roughUnitIdeal? : % -> Boolean if R has INTDOM + sample : () -> % + select : ((P -> Boolean),%) -> % if $ has finiteAggregate + select : (%,V) -> Union(P,"failed") + size? : (%,NonNegativeInteger) -> Boolean + sort : (%,V) -> Record(under: %,floor: %,upper: %) + stronglyReduce : (P,%) -> P + stronglyReduced? : (P,%) -> Boolean + stronglyReduced? : % -> Boolean + triangular? : % -> Boolean if R has INTDOM + trivialIdeal? : % -> Boolean + variables : % -> List V + zeroSetSplit : List P -> List % + zeroSetSplitIntoTriangularSystems : + List P -> List Record(close: %,open: List P) + #? : % -> NonNegativeInteger if $ has finiteAggregate + ?~=? : (%,%) -> Boolean + ?=? : (%,%) -> Boolean +\end{verbatim} + +<>= +)abbrev category RSETCAT RegularTriangularSetCategory +++ Author: Marc Moreno Maza +++ Date Created: 09/03/1998 +++ Date Last Updated: 12/15/1998 +++ Basic Functions: +++ Related Constructors: +++ Also See: essai Graphisme +++ AMS Classifications: +++ Keywords: polynomial, multivariate, ordered variables set +++ Description: +++ The category of regular triangular sets, introduced under +++ the name regular chains in [1] (and other papers). +++ In [3] it is proved that regular triangular sets and towers of simple +++ extensions of a field are equivalent notions. +++ In the following definitions, all polynomials and ideals +++ are taken from the polynomial ring \spad{k[x1,...,xn]} where \spad{k} +++ is the fraction field of \spad{R}. +++ The triangular set \spad{[t1,...,tm]} is regular +++ iff for every \spad{i} the initial of \spad{ti+1} is invertible +++ in the tower of simple extensions associated with \spad{[t1,...,ti]}. +++ A family \spad{[T1,...,Ts]} of regular triangular sets +++ is a split of Kalkbrener of a given ideal \spad{I} +++ iff the radical of \spad{I} is equal to the intersection +++ of the radical ideals generated by the saturated ideals +++ of the \spad{[T1,...,Ti]}. +++ A family \spad{[T1,...,Ts]} of regular triangular sets +++ is a split of Kalkbrener of a given triangular set \spad{T} +++ iff it is a split of Kalkbrener of the saturated ideal of \spad{T}. +++ Let \spad{K} be an algebraic closure of \spad{k}. +++ Assume that \spad{V} is finite with cardinality +++ \spad{n} and let \spad{A} be the affine space \spad{K^n}. +++ For a regular triangular set \spad{T} let denote by \spad{W(T)} the +++ set of regular zeros of \spad{T}. +++ A family \spad{[T1,...,Ts]} of regular triangular sets +++ is a split of Lazard of a given subset \spad{S} of \spad{A} +++ iff the union of the \spad{W(Ti)} contains \spad{S} and +++ is contained in the closure of \spad{S} (w.r.t. Zariski topology). +++ A family \spad{[T1,...,Ts]} of regular triangular sets +++ is a split of Lazard of a given triangular set \spad{T} +++ if it is a split of Lazard of \spad{W(T)}. +++ Note that if \spad{[T1,...,Ts]} is a split of Lazard of +++ \spad{T} then it is also a split of Kalkbrener of \spad{T}. +++ The converse is false. +++ This category provides operations related to both kinds of +++ splits, the former being related to ideals decomposition whereas +++ the latter deals with varieties decomposition. +++ See the example illustrating the \spadtype{RegularTriangularSet} constructor +++ for more explanations about decompositions by means of regular triangular sets. \newline +++ References : +++ [1] M. KALKBRENER "Three contributions to elimination theory" +++ Phd Thesis, University of Linz, Austria, 1991. +++ [2] M. KALKBRENER "Algorithmic properties of polynomial rings" +++ Journal of Symbol. Comp. 1998 +++ [3] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories +++ of Triangular Sets" Journal of Symbol. Comp. (to appear) +++ [4] M. MORENO MAZA "A new algorithm for computing triangular +++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. +++ Version: 2 + +RegularTriangularSetCategory(R:GcdDomain, E:OrderedAbelianMonoidSup,_ + V:OrderedSet,P:RecursivePolynomialCategory(R,E,V)): + Category == + TriangularSetCategory(R,E,V,P) with + purelyAlgebraic?: (P,$) -> Boolean + ++ \spad{purelyAlgebraic?(p,ts)} returns \spad{true} iff every + ++ variable of \spad{p} is algebraic w.r.t. \spad{ts}. + purelyTranscendental? : (P,$) -> Boolean + ++ \spad{purelyTranscendental?(p,ts)} returns \spad{true} iff every + ++ variable of \spad{p} is not algebraic w.r.t. \spad{ts} + algebraicCoefficients? : (P,$) -> Boolean + ++ \spad{algebraicCoefficients?(p,ts)} returns \spad{true} iff every + ++ variable of \spad{p} which is not the main one of \spad{p} + ++ is algebraic w.r.t. \spad{ts}. + purelyAlgebraic?: $ -> Boolean + ++ \spad{purelyAlgebraic?(ts)} returns true iff for every algebraic + ++ variable \spad{v} of \spad{ts} we have + ++ \spad{algebraicCoefficients?(t_v,ts_v_-)} where \spad{ts_v} + ++ is \axiomOpFrom{select}{TriangularSetCategory}(ts,v) and + ++ \spad{ts_v_-} is + ++ \axiomOpFrom{collectUnder}{TriangularSetCategory}(ts,v). + purelyAlgebraicLeadingMonomial?: (P, $) -> Boolean + ++ \spad{purelyAlgebraicLeadingMonomial?(p,ts)} returns true iff + ++ the main variable of any non-constant iterarted initial + ++ of \spad{p} is algebraic w.r.t. \spad{ts}. + invertibleElseSplit? : (P,$) -> Union(Boolean,List $) + ++ \spad{invertibleElseSplit?(p,ts)} returns \spad{true} (resp. + ++ \spad{false}) if \spad{p} is invertible in the tower + ++ associated with \spad{ts} or returns a split of Kalkbrener + ++ of \spad{ts}. + invertible? : (P,$) -> List Record(val : Boolean, tower : $) + ++ \spad{invertible?(p,ts)} returns \spad{lbwt} where \spad{lbwt.i} + ++ is the result of \spad{invertibleElseSplit?(p,lbwt.i.tower)} and + ++ the list of the \spad{(lqrwt.i).tower} is a split of Kalkbrener of + ++ \spad{ts}. + invertible?: (P,$) -> Boolean + ++ \spad{invertible?(p,ts)} returns true iff \spad{p} is invertible + ++ in the tower associated with \spad{ts}. + invertibleSet: (P,$) -> List $ + ++ \spad{invertibleSet(p,ts)} returns a split of Kalkbrener of the + ++ quotient ideal of the ideal \axiom{I} by \spad{p} where \spad{I} is + ++ the radical of saturated of \spad{ts}. + lastSubResultantElseSplit: (P, P, $) -> Union(P,List $) + ++ \spad{lastSubResultantElseSplit(p1,p2,ts)} returns either + ++ \spad{g} a quasi-monic gcd of \spad{p1} and \spad{p2} w.r.t. + ++ the \spad{ts} or a split of Kalkbrener of \spad{ts}. + ++ This assumes that \spad{p1} and \spad{p2} have the same maim + ++ variable and that this variable is greater that any variable + ++ occurring in \spad{ts}. + lastSubResultant: (P, P, $) -> List Record(val : P, tower : $) + ++ \spad{lastSubResultant(p1,p2,ts)} returns \spad{lpwt} such that + ++ \spad{lpwt.i.val} is a quasi-monic gcd of \spad{p1} and \spad{p2} + ++ w.r.t. \spad{lpwt.i.tower}, for every \spad{i}, and such + ++ that the list of the \spad{lpwt.i.tower} is a split of Kalkbrener of + ++ \spad{ts}. Moreover, if \spad{p1} and \spad{p2} do not + ++ have a non-trivial gcd w.r.t. \spad{lpwt.i.tower} then + ++ \spad{lpwt.i.val} is the resultant of these polynomials w.r.t. + ++ \spad{lpwt.i.tower}. This assumes that \spad{p1} and \spad{p2} have + ++ the same main variable and that this variable is greater that any + ++ variable occurring in \spad{ts}. + squareFreePart: (P,$) -> List Record(val : P, tower : $) + ++ \spad{squareFreePart(p,ts)} returns \spad{lpwt} such that + ++ \spad{lpwt.i.val} is a square-free polynomial + ++ w.r.t. \spad{lpwt.i.tower}, this polynomial being associated with + ++ \spad{p} modulo \spad{lpwt.i.tower}, for every \spad{i}. Moreover, + ++ the list of the \spad{lpwt.i.tower} is a split + ++ of Kalkbrener of \spad{ts}. + ++ WARNING: This assumes that \spad{p} is a non-constant polynomial + ++ such that if \spad{p} is added to \spad{ts}, then the resulting set + ++ is a regular triangular set. + intersect: (P,$) -> List $ + ++ \spad{intersect(p,ts)} returns the same as + ++ \spad{intersect([p],ts)} + intersect: (List P, $) -> List $ + ++ \spad{intersect(lp,ts)} returns \spad{lts} a split of Lazard + ++ of the intersection of the affine variety associated + ++ with \spad{lp} and the regular zero set of \spad{ts}. + intersect: (List P, List $) -> List $ + ++ \spad{intersect(lp,lts)} returns the same as + ++ \spad{concat([intersect(lp,ts) for ts in lts])|} + intersect: (P, List $) -> List $ + ++ \spad{intersect(p,lts)} returns the same as + ++ \spad{intersect([p],lts)} + augment: (P,$) -> List $ + ++ \spad{augment(p,ts)} assumes that \spad{p} is a non-constant + ++ polynomial whose main variable is greater than any variable + ++ of \spad{ts}. This operation assumes also that if \spad{p} is + ++ added to \spad{ts} the resulting set, say \spad{ts+p}, is a + ++ regular triangular set. Then it returns a split of Kalkbrener + ++ of \spad{ts+p}. This may not be \spad{ts+p} itself, if for + ++ instance \spad{ts+p} is required to be square-free. + augment: (P,List $) -> List $ + ++ \spad{augment(p,lts)} returns the same as + ++ \spad{concat([augment(p,ts) for ts in lts])} + augment: (List P,$) -> List $ + ++ \spad{augment(lp,ts)} returns \spad{ts} if \spad{empty? lp}, + ++ \spad{augment(p,ts)} if \spad{lp = [p]}, otherwise + ++ \spad{augment(first lp, augment(rest lp, ts))} + augment: (List P,List $) -> List $ + ++ \spad{augment(lp,lts)} returns the same as + ++ \spad{concat([augment(lp,ts) for ts in lts])} + internalAugment: (P, $) -> $ + ++ \spad{internalAugment(p,ts)} assumes that \spad{augment(p,ts)} + ++ returns a singleton and returns it. + internalAugment: (List P, $) -> $ + ++ \spad{internalAugment(lp,ts)} returns \spad{ts} if \spad{lp} + ++ is empty otherwise returns + ++ \spad{internalAugment(rest lp, internalAugment(first lp, ts))} + extend: (P,$) -> List $ + ++ \spad{extend(p,ts)} assumes that \spad{p} is a non-constant + ++ polynomial whose main variable is greater than any variable + ++ of \spad{ts}. Then it returns a split of Kalkbrener + ++ of \spad{ts+p}. This may not be \spad{ts+p} itself, if for + ++ instance \spad{ts+p} is not a regular triangular set. + extend: (P, List $) -> List $ + ++ \spad{extend(p,lts)} returns the same as + ++ \spad{concat([extend(p,ts) for ts in lts])|} + extend: (List P,$) -> List $ + ++ \spad{extend(lp,ts)} returns \spad{ts} if \spad{empty? lp} + ++ \spad{extend(p,ts)} if \spad{lp = [p]} else + ++ \spad{extend(first lp, extend(rest lp, ts))} + extend: (List P,List $) -> List $ + ++ \spad{extend(lp,lts)} returns the same as + ++ \spad{concat([extend(lp,ts) for ts in lts])|} + zeroSetSplit: (List P, Boolean) -> List $ + ++ \spad{zeroSetSplit(lp,clos?)} returns \spad{lts} a split of + ++ Kalkbrener of the radical ideal associated with \spad{lp}. + ++ If \spad{clos?} is false, it is also a decomposition of the + ++ variety associated with \spad{lp} into the regular zero set of the + ++ \spad{ts} in \spad{lts} (or, in other words, a split of Lazard of + ++ this variety). See the example illustrating the + ++ \spadtype{RegularTriangularSet} constructor for more explanations + ++ about decompositions by means of regular triangular sets. + + add + + NNI ==> NonNegativeInteger + INT ==> Integer + LP ==> List P + PWT ==> Record(val : P, tower : $) + LpWT ==> Record(val : (List P), tower : $) + Split ==> List $ + pack ==> PolynomialSetUtilitiesPackage(R,E,V,P) + + purelyAlgebraic?(p: P, ts: $): Boolean == + ground? p => true + not algebraic?(mvar(p),ts) => false + algebraicCoefficients?(p,ts) + + purelyTranscendental?(p:P,ts:$): Boolean == + empty? ts => true + lv : List V := variables(p)$P + while (not empty? lv) and (not algebraic?(first(lv),ts)) repeat _ + lv := rest lv + empty? lv + + purelyAlgebraicLeadingMonomial?(p: P, ts: $): Boolean == + ground? p => true + algebraic?(mvar(p),ts) and purelyAlgebraicLeadingMonomial?(init(p), ts) + + algebraicCoefficients?(p:P,ts:$): Boolean == + ground? p => true + (not ground? init(p)) and not (algebraic?(mvar(init(p)),ts)) => false + algebraicCoefficients?(init(p),ts) => + ground? tail(p) => true + mvar(tail(p)) = mvar(p) => + algebraicCoefficients?(tail(p),ts) + algebraic?(mvar(tail(p)),ts) => + algebraicCoefficients?(tail(p),ts) + false + false + + if V has Finite + then + purelyAlgebraic?(ts: $): Boolean == + empty? ts => true + size()$V = #ts => true + lp: LP := sort(infRittWu?,members(ts)) + i: NonNegativeInteger := size()$V + for p in lp repeat + v: V := mvar(p) + (i = (lookup(v)$V)::NNI) => + i := subtractIfCan(i,1)::NNI + univariate?(p)$pack => + i := subtractIfCan(i,1)::NNI + not algebraicCoefficients?(p,collectUnder(ts,v)) => + return false + i := subtractIfCan(i,1)::NNI + true + + else + + purelyAlgebraic?(ts: $): Boolean == + empty? ts => true + v: V := mvar(ts) + p: P := select(ts,v)::P + ts := collectUnder(ts,v) + empty? ts => univariate?(p)$pack + not purelyAlgebraic?(ts) => false + algebraicCoefficients?(p,ts) + + augment(p:P,lts:List $) == + toSave: Split := [] + while not empty? lts repeat + ts := first lts + lts := rest lts + toSave := concat(augment(p,ts),toSave) + toSave + + augment(lp:LP,ts:$) == + toSave: Split := [ts] + empty? lp => toSave + lp := sort(infRittWu?,lp) + while not empty? lp repeat + p := first lp + lp := rest lp + toSave := augment(p,toSave) + toSave + + augment(lp:LP,lts:List $) == + empty? lp => lts + toSave: Split := [] + while not empty? lts repeat + ts := first lts + lts := rest lts + toSave := concat(augment(lp,ts),toSave) + toSave + + extend(p:P,lts:List $) == + toSave : Split := [] + while not empty? lts repeat + ts := first lts + lts := rest lts + toSave := concat(extend(p,ts),toSave) + toSave + + extend(lp:LP,ts:$) == + toSave: Split := [ts] + empty? lp => toSave + lp := sort(infRittWu?,lp) + while not empty? lp repeat + p := first lp + lp := rest lp + toSave := extend(p,toSave) + toSave + + extend(lp:LP,lts:List $) == + empty? lp => lts + toSave: Split := [] + while not empty? lts repeat + ts := first lts + lts := rest lts + toSave := concat(extend(lp,ts),toSave) + toSave + + intersect(lp:LP,lts:List $): List $ == + -- A VERY GENERAL default algorithm + (empty? lp) or (empty? lts) => lts + lp := [primitivePart(p) for p in lp] + lp := removeDuplicates lp + lp := remove(zero?,lp) + any?(ground?,lp) => [] + toSee: List LpWT := [[lp,ts]$LpWT for ts in lts] + toSave: List $ := [] + lp: LP + p: P + ts: $ + lus: List $ + while (not empty? toSee) repeat + lpwt := first toSee; toSee := rest toSee + lp := lpwt.val; ts := lpwt.tower + empty? lp => toSave := cons(ts, toSave) + p := first lp; lp := rest lp + lus := intersect(p,ts) + toSee := concat([[lp,us]$LpWT for us in lus], toSee) + toSave + + intersect(lp: LP,ts: $): List $ == + intersect(lp,[ts]) + + intersect(p: P,lts: List $): List $ == + intersect([p],lts) + +@ +<>= +"RSETCAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=RSETCAT"]; +"RSETCAT" -> "TSETCAT" + +@ +<>= +"RegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=lightblue,href="bookvol10.2.pdf#nameddest=RSETCAT"]; +"RegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> +"TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"RegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=lightblue]; +"RegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> +"TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + +"TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=seagreen]; +"TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> +"TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" +"TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=lightblue]; +"TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> "PolynomialSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + +"PolynomialSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=seagreen]; +"PolynomialSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> "PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + +"PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=lightblue]; +"PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> "SETCAT..." +"PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> "CLAGG..." +"PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> "KOERCE..." + +"SETCAT..." [color=lightblue]; +"KOERCE..." [color=lightblue]; +"CLAGG..." [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{RightModule}{RMODULE} \pagepic{ps/v102rightmodule.ps}{RMODULE}{1.00} @@ -23241,6 +24105,351 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{SquareFreeRegularTriangularSetCategory}{SFRTCAT} +\pagepic{ps/v102squarefreeregulartriangularsetcategory.ps}{SFRTCAT}{0.50} + +{\bf See:}\\ +\pagefrom{RegularTriangularSetCategory}{RSETCAT} + +{\bf Exports:}\\ +\begin{tabular}{ll} +\cross{SFRTCAT}{algebraic?} & +\cross{SFRTCAT}{algebraicCoefficients?} \\ +\cross{SFRTCAT}{algebraicVariables} & +\cross{SFRTCAT}{any?} \\ +\cross{SFRTCAT}{augment} & +\cross{SFRTCAT}{autoReduced?} \\ +\cross{SFRTCAT}{basicSet} & +\cross{SFRTCAT}{coerce} \\ +\cross{SFRTCAT}{coHeight} & +\cross{SFRTCAT}{collect} \\ +\cross{SFRTCAT}{collectQuasiMonic} & +\cross{SFRTCAT}{collectUnder} \\ +\cross{SFRTCAT}{collectUpper} & +\cross{SFRTCAT}{construct} \\ +\cross{SFRTCAT}{copy} & +\cross{SFRTCAT}{convert} \\ +\cross{SFRTCAT}{count} & +\cross{SFRTCAT}{degree} \\ +\cross{SFRTCAT}{empty} & +\cross{SFRTCAT}{empty?} \\ +\cross{SFRTCAT}{eq?} & +\cross{SFRTCAT}{eval} \\ +\cross{SFRTCAT}{every?} & +\cross{SFRTCAT}{extend} \\ +\cross{SFRTCAT}{extendIfCan} & +\cross{SFRTCAT}{find} \\ +\cross{SFRTCAT}{first} & +\cross{SFRTCAT}{hash} \\ +\cross{SFRTCAT}{headReduce} & +\cross{SFRTCAT}{headReduced?} \\ +\cross{SFRTCAT}{headRemainder} & +\cross{SFRTCAT}{infRittWu?} \\ +\cross{SFRTCAT}{initiallyReduce} & +\cross{SFRTCAT}{initiallyReduced?} \\ +\cross{SFRTCAT}{initials} & +\cross{SFRTCAT}{internalAugment} \\ +\cross{SFRTCAT}{intersect} & +\cross{SFRTCAT}{invertible?} \\ +\cross{SFRTCAT}{invertibleElseSplit?} & +\cross{SFRTCAT}{invertibleSet} \\ +\cross{SFRTCAT}{last} & +\cross{SFRTCAT}{lastSubResultant} \\ +\cross{SFRTCAT}{lastSubResultantElseSplit} & +\cross{SFRTCAT}{latex} \\ +\cross{SFRTCAT}{less?} & +\cross{SFRTCAT}{mainVariable?} \\ +\cross{SFRTCAT}{mainVariables} & +\cross{SFRTCAT}{map} \\ +\cross{SFRTCAT}{map!} & +\cross{SFRTCAT}{member?} \\ +\cross{SFRTCAT}{members} & +\cross{SFRTCAT}{more?} \\ +\cross{SFRTCAT}{mvar} & +\cross{SFRTCAT}{normalized?} \\ +\cross{SFRTCAT}{parts} & +\cross{SFRTCAT}{purelyAlgebraic?} \\ +\cross{SFRTCAT}{purelyAlgebraicLeadingMonomial?} & +\cross{SFRTCAT}{purelyTranscendental?} \\ +\cross{SFRTCAT}{quasiComponent} & +\cross{SFRTCAT}{reduce} \\ +\cross{SFRTCAT}{reduceByQuasiMonic} & +\cross{SFRTCAT}{reduced?} \\ +\cross{SFRTCAT}{remainder} & +\cross{SFRTCAT}{remove} \\ +\cross{SFRTCAT}{removeDuplicates} & +\cross{SFRTCAT}{removeZero} \\ +\cross{SFRTCAT}{rest} & +\cross{SFRTCAT}{retract} \\ +\cross{SFRTCAT}{retractIfCan} & +\cross{SFRTCAT}{rewriteIdealWithHeadRemainder} \\ +\cross{SFRTCAT}{rewriteIdealWithRemainder} & +\cross{SFRTCAT}{rewriteSetWithReduction} \\ +\cross{SFRTCAT}{roughBase?} & +\cross{SFRTCAT}{roughEqualIdeals?} \\ +\cross{SFRTCAT}{roughSubIdeal?} & +\cross{SFRTCAT}{roughUnitIdeal?} \\ +\cross{SFRTCAT}{sample} & +\cross{SFRTCAT}{select} \\ +\cross{SFRTCAT}{size?} & +\cross{SFRTCAT}{sort} \\ +\cross{SFRTCAT}{squareFreePart} & +\cross{SFRTCAT}{stronglyReduce} \\ +\cross{SFRTCAT}{stronglyReduced?} & +\cross{SFRTCAT}{triangular?} \\ +\cross{SFRTCAT}{trivialIdeal?} & +\cross{SFRTCAT}{variables} \\ +\cross{SFRTCAT}{zeroSetSplit} & +\cross{SFRTCAT}{zeroSetSplitIntoTriangularSystems} \\ +\cross{SFRTCAT}{\#?} & +\cross{SFRTCAT}{?=?} \\ +\cross{SFRTCAT}{?\~{}=?} & +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item {\bf \cross{SFRTCAT}{shallowlyMutable}} +is true if its values have immediate components that are +updateable (mutable). Note: the properties of any component +domain are irrevelant to the shallowlyMutable proper. +\item {\bf \cross{SFRTCAT}{finiteAggregate}} +is true if it is an aggregate with a finite number of elements. +\item {\bf nil} +\end{itemize} + +These exports come from \refto{RegularTriangularSetCategory}(R,E,V,P)\\ +where R:GcdDomain, E:OrderedAbelianMonoidSup, V:OrderedSet,\\ +P:RecursivePolynomialCategory(R,E,V)): +\begin{verbatim} + algebraic? : (V,%) -> Boolean + algebraicCoefficients? : (P,%) -> Boolean + algebraicVariables : % -> List V + any? : ((P -> Boolean),%) -> Boolean if $ has finiteAggregate + augment : (List P,List %) -> List % + augment : (List P,%) -> List % + augment : (P,List %) -> List % + augment : (P,%) -> List % + autoReduced? : (%,((P,List P) -> Boolean)) -> Boolean + basicSet : + (List P,(P -> Boolean),((P,P) -> Boolean)) -> + Union(Record(bas: %,top: List P),"failed") + basicSet : + (List P,((P,P) -> Boolean)) -> + Union(Record(bas: %,top: List P),"failed") + coerce : % -> List P + coerce : % -> OutputForm + coHeight : % -> NonNegativeInteger if V has FINITE + collect : (%,V) -> % + collectQuasiMonic : % -> % + collectUnder : (%,V) -> % + collectUpper : (%,V) -> % + construct : List P -> % + copy : % -> % + convert : % -> InputForm if P has KONVERT INFORM + count : ((P -> Boolean),%) -> NonNegativeInteger + if $ has finiteAggregate + count : (P,%) -> NonNegativeInteger + if P has SETCAT + and $ has finiteAggregate + degree : % -> NonNegativeInteger + empty : () -> % + empty? : % -> Boolean + eq? : (%,%) -> Boolean + eval : (%,List Equation P) -> % if P has EVALAB P and P has SETCAT + eval : (%,Equation P) -> % if P has EVALAB P and P has SETCAT + eval : (%,P,P) -> % if P has EVALAB P and P has SETCAT + eval : (%,List P,List P) -> % if P has EVALAB P and P has SETCAT + every? : ((P -> Boolean),%) -> Boolean if $ has finiteAggregate + extend : (List P,List %) -> List % + extend : (List P,%) -> List % + extend : (P,List %) -> List % + extend : (P,%) -> List % + extend : (%,P) -> % + extendIfCan : (%,P) -> Union(%,"failed") + find : ((P -> Boolean),%) -> Union(P,"failed") + first : % -> Union(P,"failed") + hash : % -> SingleInteger + headReduce : (P,%) -> P + headReduced? : % -> Boolean + headReduced? : (P,%) -> Boolean + headRemainder : (P,%) -> Record(num: P,den: R) if R has INTDOM + infRittWu? : (%,%) -> Boolean + initiallyReduce : (P,%) -> P + initiallyReduced? : % -> Boolean + initiallyReduced? : (P,%) -> Boolean + initials : % -> List P + internalAugment : (P,%) -> % + internalAugment : (List P,%) -> % + intersect : (P,List %) -> List % + intersect : (List P,%) -> List % + intersect : (P,%) -> List % + intersect : (List P,List %) -> List % + invertible? : (P,%) -> Boolean + invertible? : (P,%) -> List Record(val: Boolean,tower: %) + invertibleElseSplit? : (P,%) -> Union(Boolean,List %) + invertibleSet : (P,%) -> List % + last : % -> Union(P,"failed") + lastSubResultant : (P,P,%) -> List Record(val: P,tower: %) + lastSubResultantElseSplit : (P,P,%) -> Union(P,List %) + latex : % -> String + less? : (%,NonNegativeInteger) -> Boolean + mainVariable? : (V,%) -> Boolean + mainVariables : % -> List V + map : ((P -> P),%) -> % + map! : ((P -> P),%) -> % if $ has shallowlyMutable + member? : (P,%) -> Boolean if P has SETCAT and $ has finiteAggregate + members : % -> List P if $ has finiteAggregate + more? : (%,NonNegativeInteger) -> Boolean + mvar : % -> V + normalized? : % -> Boolean + normalized? : (P,%) -> Boolean + parts : % -> List P if $ has finiteAggregate + purelyAlgebraic? : (P,%) -> Boolean + purelyAlgebraic? : % -> Boolean + purelyAlgebraicLeadingMonomial? : (P,%) -> Boolean + purelyTranscendental? : (P,%) -> Boolean + quasiComponent : % -> Record(close: List P,open: List P) + reduce : (P,%,((P,P) -> P),((P,P) -> Boolean)) -> P + reduce : (((P,P) -> P),%) -> P if $ has finiteAggregate + reduce : (((P,P) -> P),%,P) -> P if $ has finiteAggregate + reduce : (((P,P) -> P),%,P,P) -> P + if P has SETCAT + and $ has finiteAggregate + reduceByQuasiMonic : (P,%) -> P + reduced? : (P,%,((P,P) -> Boolean)) -> Boolean + remainder : (P,%) -> Record(rnum: R,polnum: P,den: R) + if R has INTDOM + remove : ((P -> Boolean),%) -> % if $ has finiteAggregate + remove : (P,%) -> % if P has SETCAT and $ has finiteAggregate + removeDuplicates : % -> % if P has SETCAT and $ has finiteAggregate + removeZero : (P,%) -> P + rest : % -> Union(%,"failed") + retract : List P -> % + retractIfCan : List P -> Union(%,"failed") + rewriteIdealWithHeadRemainder : (List P,%) -> List P if R has INTDOM + rewriteIdealWithRemainder : (List P,%) -> List P if R has INTDOM + rewriteSetWithReduction : + (List P,%,((P,P) -> P),((P,P) -> Boolean)) -> List P + roughBase? : % -> Boolean if R has INTDOM + roughEqualIdeals? : (%,%) -> Boolean if R has INTDOM + roughSubIdeal? : (%,%) -> Boolean if R has INTDOM + roughUnitIdeal? : % -> Boolean if R has INTDOM + sample : () -> % + select : (%,V) -> Union(P,"failed") + select : ((P -> Boolean),%) -> % if $ has finiteAggregate + size? : (%,NonNegativeInteger) -> Boolean + sort : (%,V) -> Record(under: %,floor: %,upper: %) + squareFreePart : (P,%) -> List Record(val: P,tower: %) + stronglyReduce : (P,%) -> P + stronglyReduced? : (P,%) -> Boolean + stronglyReduced? : % -> Boolean + triangular? : % -> Boolean if R has INTDOM + trivialIdeal? : % -> Boolean + variables : % -> List V + zeroSetSplit : List P -> List % + zeroSetSplit : (List P,Boolean) -> List % + zeroSetSplitIntoTriangularSystems : + List P -> List Record(close: %,open: List P) + #? : % -> NonNegativeInteger if $ has finiteAggregate + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean +\end{verbatim} + +<>= +)abbrev category SFRTCAT SquareFreeRegularTriangularSetCategory +++ Author: Marc Moreno Maza +++ Date Created: 09/03/1996 +++ Date Last Updated: 09/10/1998 +++ Basic Functions: +++ Related Constructors: +++ Also See: essai Graphisme +++ AMS Classifications: +++ Keywords: polynomial, multivariate, ordered variables set +++ Description: +++ The category of square-free regular triangular sets. +++ A regular triangular set \spad{ts} is square-free if +++ the gcd of any polynomial \spad{p} in \spad{ts} and +++ \spad{differentiate(p,mvar(p))} w.r.t. +++ \axiomOpFrom{collectUnder}{TriangularSetCategory} +++ (ts,\axiomOpFrom{mvar}{RecursivePolynomialCategory}(p)) +++ has degree zero w.r.t. \spad{mvar(p)}. Thus any square-free regular +++ set defines a tower of square-free simple extensions.\newline +++ References : +++ [1] D. LAZARD "A new method for solving algebraic systems of +++ positive dimension" Discr. App. Math. 33:147-160,1991 +++ [2] M. KALKBRENER "Algorithmic properties of polynomial rings" +++ Habilitation Thesis, ETZH, Zurich, 1995. +++ [3] M. MORENO MAZA "A new algorithm for computing triangular +++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. +SquareFreeRegularTriangularSetCategory(R:GcdDomain,E:OrderedAbelianMonoidSup,_ + V:OrderedSet,P:RecursivePolynomialCategory(R,E,V)): + Category == + RegularTriangularSetCategory(R,E,V,P) + +@ +<>= +"SFRTCAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=SFRTCAT"]; +"SFRTCAT" -> "RSETCAT" + +@ +<>= +"SquareFreeRegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=lightblue,href="bookvol10.2.pdf#nameddest=SFRTCAT"]; +"SquareFreeRegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> +"RegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"SquareFreeRegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=lightblue]; +"SquareFreeRegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> +"RegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + +"RegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=lightblue]; +"RegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> +"TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + +"TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=seagreen]; +"TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> +"TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" +"TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=lightblue]; +"TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> "PolynomialSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + +"PolynomialSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=seagreen]; +"PolynomialSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> "PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + +"PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + [color=lightblue]; +"PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> "SETCAT..." +"PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> "CLAGG..." +"PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))" + -> "KOERCE..." + +"SETCAT..." [color=lightblue]; +"KOERCE..." [color=lightblue]; +"CLAGG..." [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{StringCategory}{STRICAT} \pagepic{ps/v102stringcategory.ps}{STRICAT}{0.75} @@ -24031,6 +25240,7 @@ digraph pic { {\bf See:}\\ \pageto{FiniteRankAlgebra}{FINRALG} \pageto{FunctionSpace}{FS} +\pageto{IntegerNumberSystem}{INS} \pageto{PAdicIntegerCategory}{PADICCT} \pageto{QuotientFieldCategory}{QFCAT} \pageto{RealNumberSystem}{RNS} @@ -24340,6 +25550,7 @@ digraph pic { \pagepic{ps/v102differentialring.ps}{DIFRING}{0.90} {\bf See:}\\ +\pageto{IntegerNumberSystem}{INS} \pageto{FiniteFieldCategory}{FFIELDC} \pageto{UnivariatePolynomialCategory}{UPOLYC} \pagefrom{Ring}{RING} @@ -25040,6 +26251,7 @@ digraph pic { {\bf See:}\\ \pageto{FullyLinearlyExplicitRingOver}{FLINEXP} +\pageto{IntegerNumberSystem}{INS} \pageto{MonogenicAlgebra}{MONOGEN} \pagefrom{Ring}{RING} @@ -28124,6 +29336,7 @@ digraph pic { \pagepic{ps/v102vectorcategory.ps}{VECTCAT}{1.00} {\bf See:}\\ +\pageto{PointCategory}{PTCAT} \pagefrom{OneDimensionalArrayAggregate}{A1AGG} {\bf Exports:}\\ @@ -28425,6 +29638,10 @@ VectorCategory(R:Type): Category == OneDimensionalArrayAggregate R with [color=lightblue,href="bookvol10.2.pdf#nameddest=VECTCAT"]; "VectorCategory(a:Type)" -> "OneDimensionalArrayAggregate(a:Type)" +"VectorCategory(a:Ring)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=VECTCAT"]; +"VectorCategory(a:Ring)" -> "VectorCategory(a:Type)" + @ <>= digraph pic { @@ -29303,6 +30520,287 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{PointCategory}{PTCAT} +\pagepic{ps/v102pointcategory.ps}{PTCAT}{1.00} + +{\bf See:}\\ +\pagefrom{VectorCategory}{VECTCAT} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{PTCAT}{any?} & +\cross{PTCAT}{coerce} & +\cross{PTCAT}{concat} & +\cross{PTCAT}{construct} & +\cross{PTCAT}{convert} \\ +\cross{PTCAT}{copy} & +\cross{PTCAT}{copyInto!} & +\cross{PTCAT}{cross} & +\cross{PTCAT}{count} & +\cross{PTCAT}{delete} \\ +\cross{PTCAT}{dimension} & +\cross{PTCAT}{dot} & +\cross{PTCAT}{elt} & +\cross{PTCAT}{empty} & +\cross{PTCAT}{empty?} \\ +\cross{PTCAT}{entry?} & +\cross{PTCAT}{entries} & +\cross{PTCAT}{eq?} & +\cross{PTCAT}{eval} & +\cross{PTCAT}{every?} \\ +\cross{PTCAT}{extend} & +\cross{PTCAT}{fill!} & +\cross{PTCAT}{find} & +\cross{PTCAT}{first} & +\cross{PTCAT}{hash} \\ +\cross{PTCAT}{index?} & +\cross{PTCAT}{indices} & +\cross{PTCAT}{insert} & +\cross{PTCAT}{latex} & +\cross{PTCAT}{length} \\ +\cross{PTCAT}{less?} & +\cross{PTCAT}{magnitude} & +\cross{PTCAT}{map} & +\cross{PTCAT}{map!} & +\cross{PTCAT}{max} \\ +\cross{PTCAT}{maxIndex} & +\cross{PTCAT}{member?} & +\cross{PTCAT}{members} & +\cross{PTCAT}{merge} & +\cross{PTCAT}{min} \\ +\cross{PTCAT}{minIndex} & +\cross{PTCAT}{more?} & +\cross{PTCAT}{new} & +\cross{PTCAT}{outerProduct} & +\cross{PTCAT}{parts} \\ +\cross{PTCAT}{point} & +\cross{PTCAT}{position} & +\cross{PTCAT}{qelt} & +\cross{PTCAT}{qsetelt!} & +\cross{PTCAT}{reduce} \\ +\cross{PTCAT}{remove} & +\cross{PTCAT}{removeDuplicates} & +\cross{PTCAT}{reverse} & +\cross{PTCAT}{reverse!} & +\cross{PTCAT}{sample} \\ +\cross{PTCAT}{select} & +\cross{PTCAT}{setelt} & +\cross{PTCAT}{size?} & +\cross{PTCAT}{sort} & +\cross{PTCAT}{sort!} \\ +\cross{PTCAT}{sorted?} & +\cross{PTCAT}{swap!} & +\cross{PTCAT}{zero} & +\cross{PTCAT}{\#?} & +\cross{PTCAT}{?.?} \\ +\cross{PTCAT}{?\~{}=?} & +\cross{PTCAT}{-?} & +\cross{PTCAT}{?*?} & +\cross{PTCAT}{?+?} & +\cross{PTCAT}{?-?} \\ +\cross{PTCAT}{?$<$?} & +\cross{PTCAT}{?$<=$?} & +\cross{PTCAT}{?=?} & +\cross{PTCAT}{?$>$?} & +\cross{PTCAT}{?$>=$?} \\ +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item {\bf \cross{PTCAT}{shallowlyMutable}} +is true if its values have immediate components that are +updateable (mutable). Note: the properties of any component +domain are irrevelant to the shallowlyMutable proper. +\item {\bf \cross{PTCAT}{finiteAggregate}} +is true if it is an aggregate with a finite number of elements. +\item {\bf nil} +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + convert : List R -> % + cross : (%,%) -> % + dimension : % -> PositiveInteger + extend : (%,List R) -> % + point : List R -> % +\end{verbatim} + +These exports come from \refto{VectorCategory}(R:Ring): +\begin{verbatim} + any? : ((R -> Boolean),%) -> Boolean if $ has finiteAggregate + coerce : % -> OutputForm if R has SETCAT + concat : List % -> % + concat : (%,%) -> % + concat : (R,%) -> % + concat : (%,R) -> % + construct : List R -> % + convert : % -> InputForm if R has KONVERT INFORM + copy : % -> % + copyInto! : (%,%,Integer) -> % if $ has shallowlyMutable + count : (R,%) -> NonNegativeInteger if R has SETCAT and $ has finiteAggregate + count : ((R -> Boolean),%) -> NonNegativeInteger if $ has finiteAggregate + delete : (%,Integer) -> % + delete : (%,UniversalSegment Integer) -> % + dot : (%,%) -> R if R has RING + elt : (%,Integer,R) -> R + empty : () -> % + empty? : % -> Boolean + entry? : (R,%) -> Boolean if $ has finiteAggregate and R has SETCAT + entries : % -> List R + eq? : (%,%) -> Boolean + eval : (%,List R,List R) -> % if R has EVALAB R and R has SETCAT + eval : (%,R,R) -> % if R has EVALAB R and R has SETCAT + eval : (%,Equation R) -> % if R has EVALAB R and R has SETCAT + eval : (%,List Equation R) -> % if R has EVALAB R and R has SETCAT + every? : ((R -> Boolean),%) -> Boolean if $ has finiteAggregate + fill! : (%,R) -> % if $ has shallowlyMutable + find : ((R -> Boolean),%) -> Union(R,"failed") + first : % -> R if Integer has ORDSET + hash : % -> SingleInteger if R has SETCAT + index? : (Integer,%) -> Boolean + indices : % -> List Integer + insert : (%,%,Integer) -> % + insert : (R,%,Integer) -> % + latex : % -> String if R has SETCAT + length : % -> R if R has RING and R has RADCAT + less? : (%,NonNegativeInteger) -> Boolean + magnitude : % -> R if R has RING and R has RADCAT + map : (((R,R) -> R),%,%) -> % + map : ((R -> R),%) -> % + map! : ((R -> R),%) -> % if $ has shallowlyMutable + max : (%,%) -> % if R has ORDSET + maxIndex : % -> Integer if Integer has ORDSET + member? : (R,%) -> Boolean if R has SETCAT and $ has finiteAggregate + members : % -> List R if $ has finiteAggregate + merge : (%,%) -> % if R has ORDSET + merge : (((R,R) -> Boolean),%,%) -> % + min : (%,%) -> % if R has ORDSET + minIndex : % -> Integer if Integer has ORDSET + more? : (%,NonNegativeInteger) -> Boolean + new : (NonNegativeInteger,R) -> % + outerProduct : (%,%) -> Matrix R if R has RING + parts : % -> List R if $ has finiteAggregate + position : (R,%,Integer) -> Integer if R has SETCAT + position : (R,%) -> Integer if R has SETCAT + position : ((R -> Boolean),%) -> Integer + qelt : (%,Integer) -> R + qsetelt! : (%,Integer,R) -> R if $ has shallowlyMutable + reduce : (((R,R) -> R),%) -> R if $ has finiteAggregate + reduce : (((R,R) -> R),%,R) -> R if $ has finiteAggregate + reduce : (((R,R) -> R),%,R,R) -> R if R has SETCAT and $ has finiteAggregate + remove : ((R -> Boolean),%) -> % if $ has finiteAggregate + remove : (R,%) -> % if R has SETCAT and $ has finiteAggregate + removeDuplicates : % -> % if R has SETCAT and $ has finiteAggregate + reverse : % -> % + reverse! : % -> % if $ has shallowlyMutable + sample : () -> % + select : ((R -> Boolean),%) -> % if $ has finiteAggregate + setelt : (%,UniversalSegment Integer,R) -> R if $ has shallowlyMutable + setelt : (%,Integer,R) -> R if $ has shallowlyMutable + size? : (%,NonNegativeInteger) -> Boolean + sort : % -> % if R has ORDSET + sort : (((R,R) -> Boolean),%) -> % + sort! : % -> % if R has ORDSET and $ has shallowlyMutable + sort! : (((R,R) -> Boolean),%) -> % if $ has shallowlyMutable + sorted? : % -> Boolean if R has ORDSET + sorted? : (((R,R) -> Boolean),%) -> Boolean + swap! : (%,Integer,Integer) -> Void if $ has shallowlyMutable + zero : NonNegativeInteger -> % if R has ABELMON + #? : % -> NonNegativeInteger if $ has finiteAggregate + ?.? : (%,Integer) -> R + ?.? : (%,UniversalSegment Integer) -> % + ?~=? : (%,%) -> Boolean if R has SETCAT + ? Boolean if R has ORDSET + ?<=? : (%,%) -> Boolean if R has ORDSET + ?=? : (%,%) -> Boolean if R has SETCAT + ?>? : (%,%) -> Boolean if R has ORDSET + ?>=? : (%,%) -> Boolean if R has ORDSET + ?*? : (Integer,%) -> % if R has ABELGRP + ?*? : (%,R) -> % if R has MONOID + ?*? : (R,%) -> % if R has MONOID + ?-? : (%,%) -> % if R has ABELGRP + -? : % -> % if R has ABELGRP + ?+? : (%,%) -> % if R has ABELSG +\end{verbatim} + +<>= +)abbrev category PTCAT PointCategory +++ Author: +++ Date Created: +++ Date Last Updated: +++ Basic Operations: point, elt, setelt, copy, dimension, minIndex, maxIndex, +++ convert +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: PointCategory is the category of points in space which +++ may be plotted via the graphics facilities. Functions are provided for +++ defining points and handling elements of points. + +PointCategory(R:Ring) : Category == VectorCategory(R) with + point: List R -> % + ++ point(l) returns a point category defined by a list l of elements from + ++ the domain R. + dimension: % -> PositiveInteger + ++ dimension(s) returns the dimension of the point category s. + convert: List R -> % + ++ convert(l) takes a list of elements, l, from the domain Ring and + ++ returns the form of point category. + cross: (%,%) -> % + ++ cross(p,q) computes the cross product of the two points \spad{p} + ++ and \spad{q}. Error if the p and q are not 3 dimensional + extend : (%,List R) -> % + ++ extend(x,l,r) \undocumented + +@ +<>= +"PTCAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=PTCAT"]; +"PTCAT" -> "VECTCAT" +@ +<>= +"PointCategory(a:Ring)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=PTCAT"]; +"PointCategory(a:Ring)" -> "VectorCategory(a:Ring)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"PointCategory(a:Ring)" [color=lightblue]; +"PointCategory(a:Ring)" -> "VectorCategory(a:Ring)" + +"VectorCategory(a:Ring)" [color=seagreen]; +"VectorCategory(a:Ring)" -> "VectorCategory(a:Type)" + +"VectorCategory(a:Type)" [color=lightblue]; +"VectorCategory(a:Type)" -> "OneDimensionalArrayAggregate(a:Type)" + +"OneDimensionalArrayAggregate(a:Type)" [color=lightblue]; +"OneDimensionalArrayAggregate(a:Type)" -> + "FiniteLinearAggregate(a:Type)" + +"FiniteLinearAggregate(a:Type)" [color=lightblue]; +"FiniteLinearAggregate(a:Type)" -> "LinearAggregate(a:Type)" + +"LinearAggregate(a:Type)" [color=lightblue]; +"LinearAggregate(a:Type)" -> "IndexedAggregate(b:Integer,a:Type)" +"LinearAggregate(a:Type)" -> "CLAGG..." + +"IndexedAggregate(b:Integer,a:Type)" [color=seagreen]; +"IndexedAggregate(b:Integer,a:Type)" -> "IXAGG..." + +"CLAGG..." [color=lightblue]; +"IXAGG..." [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{SquareMatrixCategory}{SMATCAT} \pagepic{ps/v102squarematrixcategory.ps}{SMATCAT}{0.25} @@ -34151,6 +35649,7 @@ digraph pic { \pagepic{ps/v102orderedintegraldomain.ps}{OINTDOM}{0.45} {\bf See:}\\ +\pageto{IntegerNumberSystem}{INS} \pagefrom{IntegralDomain}{INTDOM} \pagefrom{QuotientFieldCategory}{QFCAT} \pagefrom{OrderedRing}{ORDRING} @@ -34884,6 +36383,7 @@ digraph pic { {\bf See:}\\ \pageto{Field}{FIELD} +\pageto{IntegerNumberSystem}{INS} \pageto{PolynomialFactorizationExplicit}{PFECAT} \pagefrom{GcdDomain}{GCDDOM} @@ -35090,6 +36590,7 @@ digraph pic { {\bf See:}\\ \pageto{Field}{FIELD} +\pageto{IntegerNumberSystem}{INS} \pageto{PAdicIntegerCategory}{PADICCT} \pageto{QuotientFieldCategory}{QFCAT} \pagefrom{PrincipalIdealDomain}{PID} @@ -35939,6 +37440,523 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{IntegerNumberSystem}{INS} +\pagepic{ps/v102integernumbersystem.ps}{INS}{0.30} + +{\bf See:}\\ +\pagefrom{CharacteristicZero}{CHARZ} +\pagefrom{CombinatorialFunctionCategory}{CFCAT} +\pagefrom{ConvertibleTo}{KONVERT} +\pagefrom{DifferentialRing}{DIFRING} +\pagefrom{EuclideanDomain}{EUCDOM} +\pagefrom{LinearlyExplicitRingOver}{LINEXP} +\pagefrom{OrderedIntegralDomain}{OINTDOM} +\pagefrom{Patternable}{PATAB} +\pagefrom{RealConstant}{REAL} +\pagefrom{RetractableTo}{RETRACT} +\pagefrom{StepThrough}{STEP} +\pagefrom{UniqueFactorizationDomain}{UFD} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{INS}{0} & +\cross{INS}{1} & +\cross{INS}{abs} & +\cross{INS}{addmod} \\ +\cross{INS}{associates?} & +\cross{INS}{base} & +\cross{INS}{binomial} & +\cross{INS}{bit?} \\ +\cross{INS}{characteristic} & +\cross{INS}{coerce} & +\cross{INS}{convert} & +\cross{INS}{copy} \\ +\cross{INS}{D} & +\cross{INS}{dec} & +\cross{INS}{differentiate} & +\cross{INS}{divide} \\ +\cross{INS}{euclideanSize} & +\cross{INS}{even?} & +\cross{INS}{expressIdealMember} & +\cross{INS}{exquo} \\ +\cross{INS}{extendedEuclidean} & +\cross{INS}{factor} & +\cross{INS}{factorial} & +\cross{INS}{gcd} \\ +\cross{INS}{gcdPolynomial} & +\cross{INS}{hash} & +\cross{INS}{inc} & +\cross{INS}{init} \\ +\cross{INS}{invmod} & +\cross{INS}{latex} & +\cross{INS}{lcm} & +\cross{INS}{length} \\ +\cross{INS}{mask} & +\cross{INS}{max} & +\cross{INS}{min} & +\cross{INS}{mulmod} \\ +\cross{INS}{multiEuclidean} & +\cross{INS}{negative?} & +\cross{INS}{nextItem} & +\cross{INS}{odd?} \\ +\cross{INS}{one?} & +\cross{INS}{patternMatch} & +\cross{INS}{permutation} & +\cross{INS}{positive?} \\ +\cross{INS}{positiveRemainder} & +\cross{INS}{powmod} & +\cross{INS}{prime?} & +\cross{INS}{principalIdeal} \\ +\cross{INS}{random} & +\cross{INS}{rational} & +\cross{INS}{rational?} & +\cross{INS}{rationalIfCan} \\ +\cross{INS}{recip} & +\cross{INS}{reducedSystem} & +\cross{INS}{retract} & +\cross{INS}{retractIfCan} \\ +\cross{INS}{sample} & +\cross{INS}{shift} & +\cross{INS}{sign} & +\cross{INS}{sizeLess?} \\ +\cross{INS}{squareFree} & +\cross{INS}{squareFreePart} & +\cross{INS}{submod} & +\cross{INS}{subtractIfCan} \\ +\cross{INS}{symmetricRemainder} & +\cross{INS}{unit?} & +\cross{INS}{unitCanonical} & +\cross{INS}{unitNormal} \\ +\cross{INS}{zero?} & +\cross{INS}{?*?} & +\cross{INS}{?**?} & +\cross{INS}{?+?} \\ +\cross{INS}{?-?} & +\cross{INS}{-?} & +\cross{INS}{?$<$?} & +\cross{INS}{?$<=$?} \\ +\cross{INS}{?=?} & +\cross{INS}{?$>$?} & +\cross{INS}{?$>=$?} & +\cross{INS}{?\^{}?} \\ +\cross{INS}{?\~{}=?} & +\cross{INS}{?quo?} & +\cross{INS}{?rem?} & +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item {\bf \cross{INS}{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{INS}{multiplicativeValuation}} +implies\\ +{\tt euclideanSize(a*b)=euclideanSize(a)*euclideanSize(b)}. +\item {\bf \cross{INS}{noZeroDivisors}} +is true if $x * y \ne 0$ implies both x and y are non-zero. +\item {\bf \cross{INS}{commutative(``*'')}} +is true if it has an operation $"*": (D,D) -> D$ +which is commutative. +\item {\bf \cross{INS}{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{INS}{leftUnitary}} +is true if $1 * x = x$ for all x. +\item {\bf \cross{INS}{rightUnitary}} +is true if $x * 1 = x$ for all x. +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + addmod : (%,%,%) -> % + base : () -> % + dec : % -> % + hash : % -> % + inc : % -> % + length : % -> % + mulmod : (%,%,%) -> % + odd? : % -> Boolean + positiveRemainder : (%,%) -> % + random : () -> % + random : % -> % + shift : (%,%) -> % + submod : (%,%,%) -> % +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + binomial : (%,%) -> % + bit? : (%,%) -> Boolean + characteristic : () -> NonNegativeInteger + convert : % -> Float + convert : % -> DoubleFloat + convert : % -> InputForm + convert : % -> Pattern Integer + copy : % -> % + differentiate : % -> % + euclideanSize : % -> NonNegativeInteger + even? : % -> Boolean + factor : % -> Factored % + factorial : % -> % + init : () -> % + invmod : (%,%) -> % + mask : % -> % + nextItem : % -> Union(%,"failed") + patternMatch : + (%,Pattern Integer,PatternMatchResult(Integer,%)) -> + PatternMatchResult(Integer,%) + permutation : (%,%) -> % + positive? : % -> Boolean + powmod : (%,%,%) -> % + prime? : % -> Boolean + rational : % -> Fraction Integer + rational? : % -> Boolean + rationalIfCan : % -> Union(Fraction Integer,"failed") + retract : % -> Integer + retractIfCan : % -> Union(Integer,"failed") + squareFree : % -> Factored % + symmetricRemainder : (%,%) -> % +\end{verbatim} + +These exports come from \refto{UniqueFactorizationDomain}(): +\begin{verbatim} + 0 : () -> % + 1 : () -> % + associates? : (%,%) -> Boolean + coerce : % -> % + coerce : Integer -> % + coerce : Integer -> % + coerce : % -> OutputForm + exquo : (%,%) -> Union(%,"failed") + gcd : List % -> % + gcd : (%,%) -> % + gcdPolynomial : + (SparseUnivariatePolynomial %, + SparseUnivariatePolynomial %) -> + SparseUnivariatePolynomial % + hash : % -> SingleInteger + latex : % -> String + lcm : List % -> % + lcm : (%,%) -> % + one? : % -> Boolean + recip : % -> Union(%,"failed") + sample : () -> % + squareFreePart : % -> % + subtractIfCan : (%,%) -> Union(%,"failed") + unit? : % -> Boolean + unitCanonical : % -> % + unitNormal : % -> Record(unit: %,canonical: %,associate: %) + zero? : % -> Boolean + ?+? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (%,%) -> % + ?*? : (Integer,%) -> % + ?*? : (PositiveInteger,%) -> % + ?*? : (NonNegativeInteger,%) -> % + ?-? : (%,%) -> % + -? : % -> % + ?**? : (%,PositiveInteger) -> % + ?**? : (%,NonNegativeInteger) -> % + ?^? : (%,PositiveInteger) -> % + ?^? : (%,NonNegativeInteger) -> % +\end{verbatim} + +These exports come from \refto{EuclideanDomain}(): +\begin{verbatim} + divide : (%,%) -> Record(quotient: %,remainder: %) + expressIdealMember : (List %,%) -> Union(List %,"failed") + extendedEuclidean : (%,%) -> Record(coef1: %,coef2: %,generator: %) + extendedEuclidean : (%,%,%) -> Union(Record(coef1: %,coef2: %),"failed") + multiEuclidean : (List %,%) -> Union(List %,"failed") + principalIdeal : List % -> Record(coef: List %,generator: %) + sizeLess? : (%,%) -> Boolean + ?quo? : (%,%) -> % + ?rem? : (%,%) -> % +\end{verbatim} + +These exports come from \refto{OrderedIntegralDomain}(): +\begin{verbatim} + abs : % -> % + max : (%,%) -> % + min : (%,%) -> % + negative? : % -> Boolean + sign : % -> Integer + ? Boolean + ?<=? : (%,%) -> Boolean + ?>? : (%,%) -> Boolean + ?>=? : (%,%) -> Boolean +\end{verbatim} + +These exports come from \refto{DifferentialRing}(): +\begin{verbatim} + D : % -> % + D : (%,NonNegativeInteger) -> % + differentiate : (%,NonNegativeInteger) -> % +\end{verbatim} + +These exports come from \refto{ConvertibleTo}(Integer): +\begin{verbatim} + convert : % -> Integer +\end{verbatim} + +These exports come from \refto{LinearlyExplicitRingOver}(Integer): +\begin{verbatim} + reducedSystem : Matrix % -> Matrix Integer + reducedSystem : (Matrix %,Vector %) -> + Record(mat: Matrix Integer,vec: Vector Integer) +\end{verbatim} + +<>= +)abbrev category INS IntegerNumberSystem +++ Author: Stephen M. Watt +++ Date Created: +++ January 1988 +++ Change History: +++ Basic Operations: +++ addmod, base, bit?, copy, dec, even?, hash, inc, invmod, length, mask, +++ positiveRemainder, symmetricRemainder, multiplicativeValuation, mulmod, +++ odd?, powmod, random, rational, rational?, rationalIfCan, shift, submod +++ Description: An \spad{IntegerNumberSystem} is a model for the integers. +IntegerNumberSystem(): Category == + Join(UniqueFactorizationDomain, EuclideanDomain, OrderedIntegralDomain, + DifferentialRing, ConvertibleTo Integer, RetractableTo Integer, + LinearlyExplicitRingOver Integer, ConvertibleTo InputForm, + ConvertibleTo Pattern Integer, PatternMatchable Integer, + CombinatorialFunctionCategory, RealConstant, + CharacteristicZero, StepThrough) with + odd? : % -> Boolean + ++ odd?(n) returns true if and only if n is odd. + even? : % -> Boolean + ++ even?(n) returns true if and only if n is even. + multiplicativeValuation + ++ euclideanSize(a*b) returns \spad{euclideanSize(a)*euclideanSize(b)}. + base : () -> % + ++ base() returns the base for the operations of + ++ \spad{IntegerNumberSystem}. + length : % -> % + ++ length(a) length of \spad{a} in digits. + shift : (%, %) -> % + ++ shift(a,i) shift \spad{a} by i digits. + bit? : (%, %) -> Boolean + ++ bit?(n,i) returns true if and only if i-th bit of n is a 1. + positiveRemainder : (%, %) -> % + ++ positiveRemainder(a,b) (where \spad{b > 1}) yields r + ++ where \spad{0 <= r < b} and \spad{r == a rem b}. + symmetricRemainder : (%, %) -> % + ++ symmetricRemainder(a,b) (where \spad{b > 1}) yields r + ++ where \spad{ -b/2 <= r < b/2 }. + rational?: % -> Boolean + ++ rational?(n) tests if n is a rational number + ++ (see \spadtype{Fraction Integer}). + rational : % -> Fraction Integer + ++ rational(n) creates a rational number + ++ (see \spadtype{Fraction Integer}).. + rationalIfCan: % -> Union(Fraction Integer, "failed") + ++ rationalIfCan(n) creates a rational number, or returns "failed" + ++ if this is not possible. + random : () -> % + ++ random() creates a random element. + random : % -> % + ++ random(a) creates a random element from 0 to \spad{n-1}. + hash : % -> % + ++ hash(n) returns the hash code of n. + copy : % -> % + ++ copy(n) gives a copy of n. + inc : % -> % + ++ inc(x) returns \spad{x + 1}. + dec : % -> % + ++ dec(x) returns \spad{x - 1}. + mask : % -> % + ++ mask(n) returns \spad{2**n-1} (an n bit mask). + addmod : (%,%,%) -> % + ++ addmod(a,b,p), \spad{0<=a,b

1}, means \spad{a+b mod p}. + submod : (%,%,%) -> % + ++ submod(a,b,p), \spad{0<=a,b

1}, means \spad{a-b mod p}. + mulmod : (%,%,%) -> % + ++ mulmod(a,b,p), \spad{0<=a,b

1}, means \spad{a*b mod p}. + powmod : (%,%,%) -> % + ++ powmod(a,b,p), \spad{0<=a,b

1}, means \spad{a**b mod p}. + invmod : (%,%) -> % + ++ invmod(a,b), \spad{0<=a1}, \spad{(a,b)=1} means \spad{1/a mod b}. + canonicalUnitNormal +-- commutative("*") -- follows from the above + + add + characteristic() == 0 + + differentiate x == 0 + + even? x == not odd? x + + positive? x == x > 0 + + copy x == x + + bit?(x, i) == odd? shift(x, -i) + + mask n == dec shift(1, n) + + rational? x == true + + euclideanSize(x) == + x=0 => error "euclideanSize called on zero" + x<0 => (-convert(x)@Integer)::NonNegativeInteger + convert(x)@Integer::NonNegativeInteger + + convert(x:%):Float == (convert(x)@Integer)::Float + + convert(x:%):DoubleFloat == (convert(x)@Integer)::DoubleFloat + + convert(x:%):InputForm == convert(convert(x)@Integer) + + retract(x:%):Integer == convert(x)@Integer + + convert(x:%):Pattern(Integer)== convert(x)@Integer ::Pattern(Integer) + + factor x == factor(x)$IntegerFactorizationPackage(%) + + squareFree x == squareFree(x)$IntegerFactorizationPackage(%) + + prime? x == prime?(x)$IntegerPrimesPackage(%) + + factorial x == factorial(x)$IntegerCombinatoricFunctions(%) + + binomial(n, m) == binomial(n, m)$IntegerCombinatoricFunctions(%) + + permutation(n, m) == permutation(n,m)$IntegerCombinatoricFunctions(%) + + retractIfCan(x:%):Union(Integer, "failed") == convert(x)@Integer + + init() == 0 + + -- iterates in order 0,1,-1,2,-2,3,-3,... + nextItem(n) == + zero? n => 1 + n>0 => -n + 1-n + + patternMatch(x, p, l) == + patternMatch(x, p, l)$PatternMatchIntegerNumberSystem(%) + + rational(x:%):Fraction(Integer) == + (convert(x)@Integer)::Fraction(Integer) + + rationalIfCan(x:%):Union(Fraction Integer, "failed") == + (convert(x)@Integer)::Fraction(Integer) + + symmetricRemainder(x, n) == + r := x rem n + r = 0 => r + if n < 0 then n:=-n + r > 0 => + 2 * r > n => r - n + r + 2*r + n <= 0 => r + n + r + + invmod(a, b) == + if negative? a then a := positiveRemainder(a, b) + c := a; c1:% := 1 + d := b; d1:% := 0 + while not zero? d repeat + q := c quo d + r := c-q*d + r1 := c1-q*d1 + c := d; c1 := d1 + d := r; d1 := r1 +-- not one? c => error "inverse does not exist" + not (c = 1) => error "inverse does not exist" + negative? c1 => c1 + b + c1 + + powmod(x, n, p) == + if negative? x then x := positiveRemainder(x, p) + zero? x => 0 + zero? n => 1 + y:% := 1 + z := x + repeat + if odd? n then y := mulmod(y, z, p) + zero?(n := shift(n, -1)) => return y + z := mulmod(z, z, p) + +@ +<>= +"INS" + [color=lightblue,href="bookvol10.2.pdf#nameddest=INS"]; +"INS" -> "UFD" +"INS" -> "EUCDOM" +"INS" -> "OINTDOM" +"INS" -> "DIFRING" +"INS" -> "KONVERT" +"INS" -> "RETRACT" +"INS" -> "LINEXP" +"INS" -> "PATMAB" +"INS" -> "CFCAT" +"INS" -> "REAL" +"INS" -> "CHARZ" +"INS" -> "STEP" + +@ +<>= +"IntegerNumberSystem()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=INS"]; +"IntegerNumberSystem()" -> "UniqueFactorizationDomain()" +"IntegerNumberSystem()" -> "EuclideanDomain()" +"IntegerNumberSystem()" -> "OrderedIntegralDomain()" +"IntegerNumberSystem()" -> "DifferentialRing()" +"IntegerNumberSystem()" -> "ConvertibleTo(Integer)" +"IntegerNumberSystem()" -> "ConvertibleTo(InputForm)" +"IntegerNumberSystem()" -> "ConvertibleTo(Pattern(Integer))" +"IntegerNumberSystem()" -> "RetractableTo(Integer)" +"IntegerNumberSystem()" -> "LinearlyExplicitRingOver(Integer)" +"IntegerNumberSystem()" -> "PatternMatchable(Integer)" +"IntegerNumberSystem()" -> "CombinatorialFunctionCategory()" +"IntegerNumberSystem()" -> "RealConstant()" +"IntegerNumberSystem()" -> "CharacteristicZero()" +"IntegerNumberSystem()" -> "StepThrough()" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"IntegerNumberSystem()" [color=lightblue]; +"IntegerNumberSystem()" -> "UFD..." +"IntegerNumberSystem()" -> "EUCDOM..." +"IntegerNumberSystem()" -> "OINTDOM..." +"IntegerNumberSystem()" -> "DIFRING..." +"IntegerNumberSystem()" -> "KONVERT..." +"IntegerNumberSystem()" -> "RETRACT..." +"IntegerNumberSystem()" -> "LINEXP..." +"IntegerNumberSystem()" -> "PATMAB..." +"IntegerNumberSystem()" -> "CFCAT..." +"IntegerNumberSystem()" -> "REAL..." +"IntegerNumberSystem()" -> "CHARZ..." +"IntegerNumberSystem()" -> "STEP..." + +"UFD..." [color=lightblue]; +"EUCDOM..." [color=lightblue]; +"OINTDOM..." [color=lightblue]; +"DIFRING..." [color=lightblue]; +"KONVERT..." [color=lightblue]; +"RETRACT..." [color=lightblue]; +"LINEXP..." [color=lightblue]; +"PATMAB..." [color=lightblue]; +"CFCAT..." [color=lightblue]; +"REAL..." [color=lightblue]; +"CHARZ..." [color=lightblue]; +"STEP..." [color=lightblue]; + +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{PAdicIntegerCategory}{PADICCT} \pagepic{ps/v102padicintegercategory.ps}{PADICCT}{0.70} @@ -37112,6 +39130,7 @@ digraph pic { \pagepic{ps/v102algebraicallyclosedfield.ps}{ACF}{0.75} {\bf See:}\\ +\pageto{AlgebraicallyClosedFunctionSpace}{ACFS} \pagefrom{Field}{FIELD} \pagefrom{RadicalCategory}{RADCAT} @@ -37192,6 +39211,11 @@ is true if $1 * x = x$ for all x. is true if $x * 1 = x$ for all x. \end{itemize} +These are directly exported but not implemented: +\begin{verbatim} + rootOf : Polynomial % -> % +\end{verbatim} + These are implemented by this category: \begin{verbatim} rootOf : SparseUnivariatePolynomial % -> % @@ -39181,6 +41205,7 @@ digraph pic { \pagefrom{AbelianMonoid}{ABELMON} \pagefrom{AbelianSemiGroup}{ABELSG} \pagefrom{Algebra}{ALGEBRA} +\pagefrom{AlgebraicallyClosedFunctionSpace}{ACFS} \pagefrom{CharacteristicNonZero}{CHARNZ} \pagefrom{CharacteristicZero}{CHARZ} \pagefrom{CommutativeRing}{COMRING} @@ -39327,7 +41352,6 @@ is true if $x * 1 = x$ for all x. \item {\bf nil} \end{itemize} - These are directly exported but not implemented: \begin{verbatim} coerce : SparseMultivariatePolynomial(R,Kernel %) -> % @@ -39486,14 +41510,6 @@ These exports come from \refto{ExpressionSpace}(): ?>=? : (%,%) -> Boolean \end{verbatim} -These exports come from \refto{RetractableTo}(Symbol): -\begin{verbatim} -\end{verbatim} - -These exports come from \refto{Patternable}(OrderedSet): -\begin{verbatim} -\end{verbatim} - These exports come from \refto{FullyPatternMatchable}(OrderedSet): \begin{verbatim} patternMatch : @@ -39517,10 +41533,6 @@ These exports come from \refto{ConvertibleTo}(InputForm): convert : % -> InputForm if R has KONVERT INFORM \end{verbatim} -These exports come from \refto{SemiGroup}(): -\begin{verbatim} -\end{verbatim} - These exports come from \refto{Monoid}(): \begin{verbatim} 1 : () -> % if R has SGROUP @@ -39543,10 +41555,6 @@ These exports come from \refto{Group}(): ?**? : (%,Integer) -> % if R has GROUP or R has INTDOM \end{verbatim} -These exports come from \refto{AbelianSemiGroup}(): -\begin{verbatim} -\end{verbatim} - These exports come from \refto{AbelianMonoid}(): \begin{verbatim} 0 : () -> % if R has ABELSG @@ -39564,15 +41572,6 @@ These exports come from \refto{AbelianGroup}(): -? : % -> % if R has ABELGRP \end{verbatim} -These exports come from \refto{Ring}(): -\begin{verbatim} -\end{verbatim} - -These exports come from \refto{RetractableTo}(R)\\ -where R:Polynomial(OrderedSet): -\begin{verbatim} -\end{verbatim} - These exports come from \refto{PartialDifferentialRing}(Symbol): \begin{verbatim} D : (%,Symbol) -> % if R has RING @@ -39598,23 +41597,11 @@ where R:OrderedSet: if and(has(R,LinearlyExplicitRingOver Integer),has(R,Ring)) \end{verbatim} -These exports come from \refto{CharacteristicZero}(): -\begin{verbatim} -\end{verbatim} - These exports come from \refto{CharacteristicNonZero}(): \begin{verbatim} charthRoot : % -> Union(%,"failed") if R has CHARNZ \end{verbatim} -These exports come from \refto{CommutativeRing}(): -\begin{verbatim} -\end{verbatim} - -These exports come from \refto{Algebra}(OrderedSet): -\begin{verbatim} -\end{verbatim} - These exports come from \refto{IntegralDomain}(): \begin{verbatim} associates? : (%,%) -> Boolean if R has INTDOM @@ -39659,11 +41646,6 @@ These exports come from \refto{Field}(): ?rem? : (%,%) -> % if R has INTDOM \end{verbatim} -These exports come from \refto{RetractableTo}(R)\\ -where R:Fraction(Polynomial(OrderedSet)) -\begin{verbatim} -\end{verbatim} - These exports come from \refto{RetractableTo}(Integer): \begin{verbatim} retract : % -> Integer if R has RETRACT INT @@ -41518,22 +43500,6 @@ These exports come from 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 @@ -41558,18 +43524,6 @@ These exports come from \refto{OrderedIntegralDomain}(): 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") @@ -41578,14 +43532,6 @@ These exports come from \refto{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{PolynomialFactorizationExplicit}(): \begin{verbatim} conditionP : Matrix % -> Union(Vector %,"failed") @@ -43957,6 +45903,7 @@ digraph pic { \pagepic{ps/v102univariatelaurentseriescategory.ps}{ULSCAT}{0.50} {\bf See:}\\ +\pageto{UnivariateLaurentSeriesConstructorCategory}{ULSCCAT} \pagefrom{Field}{FIELD} \pagefrom{RadicalCategory}{RADCAT} \pagefrom{TranscendentalFunctionCategory}{TRANFUN} @@ -45880,6 +47827,581 @@ digraph pic { @ \chapter{Category Layer 18} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{AlgebraicallyClosedFunctionSpace}{ACFS} +\pagepic{ps/v102algebraicallyclosedfunctionspace.ps}{ACFS}{0.45} + +{\bf See:}\\ +\pagefrom{AlgebraicallyClosedField}{ACF} +\pagefrom{FunctionSpace}{FS} + +{\bf Exports:}\\ +\begin{tabular}{llll} +\cross{ACFS}{0} & +\cross{ACFS}{1} & +\cross{ACFS}{applyQuote} & +\cross{ACFS}{associates?} \\ +\cross{ACFS}{belong?} & +\cross{ACFS}{box} & +\cross{ACFS}{characteristic} & +\cross{ACFS}{charthRoot} \\ +\cross{ACFS}{coerce} & +\cross{ACFS}{commutator} & +\cross{ACFS}{conjugate} & +\cross{ACFS}{convert} \\ +\cross{ACFS}{D} & +\cross{ACFS}{definingPolynomial} & +\cross{ACFS}{denom} & +\cross{ACFS}{denominator} \\ +\cross{ACFS}{differentiate} & +\cross{ACFS}{distribute} & +\cross{ACFS}{divide} & +\cross{ACFS}{elt} \\ +\cross{ACFS}{euclideanSize} & +\cross{ACFS}{eval} & +\cross{ACFS}{even?} & +\cross{ACFS}{expressIdealMember} \\ +\cross{ACFS}{exquo} & +\cross{ACFS}{extendedEuclidean} & +\cross{ACFS}{factor} & +\cross{ACFS}{freeOf?} \\ +\cross{ACFS}{gcd} & +\cross{ACFS}{gcdPolynomial} & +\cross{ACFS}{ground} & +\cross{ACFS}{ground?} \\ +\cross{ACFS}{hash} & +\cross{ACFS}{height} & +\cross{ACFS}{inv} & +\cross{ACFS}{is?} \\ +\cross{ACFS}{isExpt} & +\cross{ACFS}{isMult} & +\cross{ACFS}{isPlus} & +\cross{ACFS}{isPower} \\ +\cross{ACFS}{isTimes} & +\cross{ACFS}{kernel} & +\cross{ACFS}{kernels} & +\cross{ACFS}{latex} \\ +\cross{ACFS}{lcm} & +\cross{ACFS}{mainKernel} & +\cross{ACFS}{map} & +\cross{ACFS}{max} \\ +\cross{ACFS}{min} & +\cross{ACFS}{minPoly} & +\cross{ACFS}{multiEuclidean} & +\cross{ACFS}{nthRoot} \\ +\cross{ACFS}{numer} & +\cross{ACFS}{numerator} & +\cross{ACFS}{odd?} & +\cross{ACFS}{one?} \\ +\cross{ACFS}{operator} & +\cross{ACFS}{operators} & +\cross{ACFS}{paren} & +\cross{ACFS}{patternMatch} \\ +\cross{ACFS}{prime?} & +\cross{ACFS}{principalIdeal} & +\cross{ACFS}{recip} & +\cross{ACFS}{reducedSystem} \\ +\cross{ACFS}{retract} & +\cross{ACFS}{retractIfCan} & +\cross{ACFS}{rootOf} & +\cross{ACFS}{rootsOf} \\ +\cross{ACFS}{sample} & +\cross{ACFS}{sizeLess?} & +\cross{ACFS}{sqrt} & +\cross{ACFS}{squareFree} \\ +\cross{ACFS}{squareFreePart} & +\cross{ACFS}{subst} & +\cross{ACFS}{subtractIfCan} & +\cross{ACFS}{tower} \\ +\cross{ACFS}{unit?} & +\cross{ACFS}{unitCanonical} & +\cross{ACFS}{unitNormal} & +\cross{ACFS}{univariate} \\ +\cross{ACFS}{variables} & +\cross{ACFS}{zero?} & +\cross{ACFS}{zeroOf} & +\cross{ACFS}{zerosOf} \\ +\cross{ACFS}{?*?} & +\cross{ACFS}{?**?} & +\cross{ACFS}{?+?} & +\cross{ACFS}{?-?} \\ +\cross{ACFS}{-?} & +\cross{ACFS}{?/?} & +\cross{ACFS}{?$<$?} & +\cross{ACFS}{?$<=$?} \\ +\cross{ACFS}{?=?} & +\cross{ACFS}{?$>$?} & +\cross{ACFS}{?$>=$?} & +\cross{ACFS}{?\^{}?} \\ +\cross{ACFS}{?\~{}=?} & +\cross{ACFS}{?/?} & +\cross{ACFS}{?quo?} & +\cross{ACFS}{?rem?} \\ +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item {\bf \cross{ACFS}{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{ACFS}{leftUnitary}} +is true if $1 * x = x$ for all x. +\item {\bf \cross{ACFS}{rightUnitary}} +is true if $x * 1 = x$ for all x. +\item {\bf \cross{ACFS}{noZeroDivisors}} +is true if $x * y \ne 0$ implies both x and y are non-zero. +\item {\bf \cross{ACFS}{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{ACFS}{canonicalsClosed}} +is true if\\ +{\tt unitCanonical(a)*unitCanonical(b) = unitCanonical(a*b)}. +\item {\bf \cross{ACFS}{commutative(``*'')}} +is true if it has an operation $"*": (D,D) -> D$ +which is commutative. +\item {\bf nil} +\end{itemize} + +These are implemented by this category: +\begin{verbatim} + rootOf : % -> % + rootOf : (%,Symbol) -> % + rootsOf : % -> List % + rootsOf : (%,Symbol) -> List % + rootsOf : (SparseUnivariatePolynomial %,Symbol) -> List % + zeroOf : % -> % + zeroOf : (%,Symbol) -> % + zeroOf : (SparseUnivariatePolynomial %,Symbol) -> % + zerosOf : % -> List % + zerosOf : (%,Symbol) -> List % + zerosOf : (SparseUnivariatePolynomial %,Symbol) -> List % +\end{verbatim} + +These exports come from \refto{AlgebraicallyClosedField}(): +\begin{verbatim} + 0 : () -> % + 1 : () -> % + associates? : (%,%) -> Boolean + characteristic : () -> NonNegativeInteger + coerce : % -> % + coerce : Integer -> % + coerce : % -> OutputForm + coerce : Fraction Integer -> % + divide : (%,%) -> Record(quotient: %,remainder: %) + euclideanSize : % -> NonNegativeInteger + expressIdealMember : (List %,%) -> Union(List %,"failed") + exquo : (%,%) -> Union(%,"failed") + extendedEuclidean : (%,%,%) -> Union(Record(coef1: %,coef2: %),"failed") + extendedEuclidean : (%,%) -> Record(coef1: %,coef2: %,generator: %) + factor : % -> Factored % + gcd : List % -> % + gcd : (%,%) -> % + gcdPolynomial : + (SparseUnivariatePolynomial %, + SparseUnivariatePolynomial %) -> + SparseUnivariatePolynomial % + hash : % -> SingleInteger + inv : % -> % + latex : % -> String + lcm : List % -> % + lcm : (%,%) -> % + multiEuclidean : (List %,%) -> Union(List %,"failed") + nthRoot : (%,Integer) -> % + one? : % -> Boolean + prime? : % -> Boolean + principalIdeal : List % -> Record(coef: List %,generator: %) + recip : % -> Union(%,"failed") + rootOf : SparseUnivariatePolynomial % -> % + rootOf : Polynomial % -> % + rootOf : (SparseUnivariatePolynomial %,Symbol) -> % + rootsOf : SparseUnivariatePolynomial % -> List % + rootsOf : Polynomial % -> List % + sample : () -> % + sizeLess? : (%,%) -> Boolean + sqrt : % -> % + squareFree : % -> Factored % + squareFreePart : % -> % + subtractIfCan : (%,%) -> Union(%,"failed") + unit? : % -> Boolean + unitCanonical : % -> % + unitNormal : % -> Record(unit: %,canonical: %,associate: %) + zero? : % -> Boolean + zeroOf : Polynomial % -> % + zeroOf : SparseUnivariatePolynomial % -> % + zerosOf : Polynomial % -> List % + zerosOf : SparseUnivariatePolynomial % -> List % + ?*? : (Fraction Integer,%) -> % + ?*? : (%,Fraction Integer) -> % + ?**? : (%,Fraction Integer) -> % + ?**? : (%,Integer) -> % + ?^? : (%,Integer) -> % + ?+? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (%,%) -> % + ?*? : (Integer,%) -> % + ?*? : (PositiveInteger,%) -> % + ?*? : (NonNegativeInteger,%) -> % + ?-? : (%,%) -> % + -? : % -> % + ?**? : (%,PositiveInteger) -> % + ?**? : (%,NonNegativeInteger) -> % + ?^? : (%,PositiveInteger) -> % + ?^? : (%,NonNegativeInteger) -> % + ?/? : (%,%) -> % + ?quo? : (%,%) -> % + ?rem? : (%,%) -> % +\end{verbatim} + +These exports come from \refto{FunctionSpace}(R)\\ +where R:Join(OrderedSet, IntegralDomain)): +\begin{verbatim} + applyQuote : (Symbol,%) -> % + applyQuote : (Symbol,%,%) -> % + applyQuote : (Symbol,%,%,%) -> % + applyQuote : (Symbol,%,%,%,%) -> % + applyQuote : (Symbol,List %) -> % + belong? : BasicOperator -> Boolean + box : % -> % + box : List % -> % + charthRoot : % -> Union(%,"failed") if R has CHARNZ + coerce : R -> % + coerce : Symbol -> % + coerce : Kernel % -> % + coerce : Fraction Polynomial R -> % if R has INTDOM + coerce : Fraction Polynomial Fraction R -> % if R has INTDOM + coerce : SparseMultivariatePolynomial(R,Kernel %) -> % + if R has RING + coerce : Fraction R -> % if R has INTDOM + coerce : Polynomial Fraction R -> % if R has INTDOM + coerce : Polynomial R -> % if R has RING + commutator : (%,%) -> % if R has GROUP + conjugate : (%,%) -> % if R has GROUP + convert : % -> InputForm if R has KONVERT INFORM + convert : % -> Pattern Integer if R has KONVERT PATTERN INT + convert : % -> Pattern Float if R has KONVERT PATTERN FLOAT + convert : Factored % -> % if R has INTDOM + D : (%,List Symbol,List NonNegativeInteger) -> % if R has RING + D : (%,Symbol,NonNegativeInteger) -> % if R has RING + D : (%,List Symbol) -> % if R has RING + D : (%,Symbol) -> % if R has RING + definingPolynomial : % -> % if $ has RING + denom : % -> SparseMultivariatePolynomial(R,Kernel %) if R has INTDOM + denominator : % -> % if R has INTDOM + differentiate : (%,List Symbol,List NonNegativeInteger) -> % + if R has RING + differentiate : (%,Symbol,NonNegativeInteger) -> % if R has RING + differentiate : (%,List Symbol) -> % if R has RING + distribute : % -> % + distribute : (%,%) -> % + differentiate : (%,Symbol) -> % if R has RING + elt : (BasicOperator,%,%,%) -> % + elt : (BasicOperator,%,%,%,%) -> % + elt : (BasicOperator,%) -> % + elt : (BasicOperator,%,%) -> % + elt : (BasicOperator,List %) -> % + eval : (%,List BasicOperator,List (% -> %)) -> % + eval : (%,List Equation %) -> % + eval : (%,Symbol,(% -> %)) -> % + eval : (%,Symbol,(List % -> %)) -> % + eval : (%,BasicOperator,%,Symbol) -> % if R has KONVERT INFORM + eval : (%,BasicOperator,(List % -> %)) -> % + eval : (%,BasicOperator,(% -> %)) -> % + eval : (%,List Symbol,List (% -> %)) -> % + eval : (%,List BasicOperator,List (List % -> %)) -> % + eval : (%,List Symbol,List (List % -> %)) -> % + eval : (%,List %,List %) -> % + eval : (%,%,%) -> % + eval : (%,Equation %) -> % + eval : (%,Kernel %,%) -> % + eval : (%,List Symbol) -> % if R has KONVERT INFORM + eval : % -> % if R has KONVERT INFORM + eval : (%,Symbol) -> % if R has KONVERT INFORM + eval : (%,Symbol,NonNegativeInteger,(% -> %)) -> % if R has RING + eval : (%,Symbol,NonNegativeInteger,(List % -> %)) -> % if R has RING + eval : + (%,List Symbol,List NonNegativeInteger,List (List % -> %)) -> % + if R has RING + eval : + (%,List Symbol,List NonNegativeInteger,List (% -> %)) -> % + if R has RING + eval : (%,List Kernel %,List %) -> % + eval : (%,List BasicOperator,List %,Symbol) -> % + if R has KONVERT INFORM + even? : % -> Boolean if $ has RETRACT INT + freeOf? : (%,%) -> Boolean + freeOf? : (%,Symbol) -> Boolean + ground : % -> R + ground? : % -> Boolean + height : % -> NonNegativeInteger + is? : (%,BasicOperator) -> Boolean + is? : (%,Symbol) -> Boolean + isExpt : % -> + Union(Record(var: Kernel %,exponent: Integer),"failed") + if R has SGROUP + isExpt : + (%,BasicOperator) -> + Union(Record(var: Kernel %,exponent: Integer),"failed") + if R has RING + isExpt : + (%,Symbol) -> + Union(Record(var: Kernel %,exponent: Integer),"failed") + if R has RING + isMult : % -> + Union(Record(coef: Integer,var: Kernel %),"failed") + if R has ABELSG + isPlus : % -> Union(List %,"failed") if R has ABELSG + isPower : % -> Union(Record(val: %,exponent: Integer),"failed") + if R has RING + isTimes : % -> Union(List %,"failed") if R has SGROUP + kernel : (BasicOperator,List %) -> % + kernel : (BasicOperator,%) -> % + kernels : % -> List Kernel % + mainKernel : % -> Union(Kernel %,"failed") + map : ((% -> %),Kernel %) -> % + max : (%,%) -> % + min : (%,%) -> % + minPoly : Kernel % -> SparseUnivariatePolynomial % if $ has RING + numer : % -> SparseMultivariatePolynomial(R,Kernel %) if R has RING + numerator : % -> % if R has RING + odd? : % -> Boolean if $ has RETRACT INT + operator : BasicOperator -> BasicOperator + operators : % -> List BasicOperator + paren : % -> % + paren : List % -> % + patternMatch : + (%,Pattern Integer,PatternMatchResult(Integer,%)) -> + PatternMatchResult(Integer,%) + if R has PATMAB INT + patternMatch : + (%,Pattern Float,PatternMatchResult(Float,%)) -> + PatternMatchResult(Float,%) + if R has PATMAB FLOAT + reducedSystem : Matrix % -> Matrix Integer + if and(has(R,Ring),has(R,LinearlyExplicitRingOver Integer)) + or and(has(R,LinearlyExplicitRingOver Integer),has(R,Ring)) + reducedSystem : + (Matrix %,Vector %) -> + Record(mat: Matrix Integer,vec: Vector Integer) + if and(has(R,Ring),has(R,LinearlyExplicitRingOver Integer)) + or and(has(R,LinearlyExplicitRingOver Integer),has(R,Ring)) + reducedSystem : + (Matrix %,Vector %) -> Record(mat: Matrix R,vec: Vector R) + if R has RING + reducedSystem : Matrix % -> Matrix R if R has RING + retract : % -> Kernel % + retract : % -> Fraction Polynomial R if R has INTDOM + retract : % -> Polynomial R if R has RING + retract : % -> R + retract : % -> Symbol + retract : % -> Integer if R has RETRACT INT + retract : % -> Fraction Integer + if R has RETRACT INT + and R has INTDOM + or R has RETRACT FRAC INT + retractIfCan : % -> Union(Integer,"failed") if R has RETRACT INT + retractIfCan : % -> Union(Fraction Integer,"failed") + if R has RETRACT INT + and R has INTDOM + or R has RETRACT FRAC INT + retractIfCan : % -> Union(Kernel %,"failed") + retractIfCan : % -> Union(R,"failed") + retractIfCan : % -> Union(Fraction Polynomial R,"failed") + if R has INTDOM + retractIfCan : % -> Union(Polynomial R,"failed") if R has RING + retractIfCan : % -> Union(Symbol,"failed") + subst : (%,List Kernel %,List %) -> % + subst : (%,List Equation %) -> % + subst : (%,Equation %) -> % + tower : % -> List Kernel % + univariate : (%,Kernel %) -> Fraction SparseUnivariatePolynomial % + if R has INTDOM + variables : % -> List Symbol + ? Boolean + ?<=? : (%,%) -> Boolean + ?>? : (%,%) -> Boolean + ?>=? : (%,%) -> Boolean + ?*? : (R,%) -> % if R has COMRING + ?*? : (%,R) -> % if R has COMRING + ?/? : + (SparseMultivariatePolynomial(R,Kernel %), + SparseMultivariatePolynomial(R,Kernel %)) -> % + if R has INTDOM +\end{verbatim} + +<>= +)abbrev category ACFS AlgebraicallyClosedFunctionSpace +++ Author: Manuel Bronstein +++ Date Created: 31 October 1988 +++ Date Last Updated: 7 October 1991 +++ Description: +++ Model for algebraically closed function spaces. +++ Keywords: algebraic, closure, field. +AlgebraicallyClosedFunctionSpace(R:Join(OrderedSet, IntegralDomain)): + Category == Join(AlgebraicallyClosedField, FunctionSpace R) with + rootOf : $ -> $ + ++ rootOf(p) returns y such that \spad{p(y) = 0}. + ++ Error: if p has more than one variable y. + rootsOf: $ -> List $ + ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}; + ++ Note: the returned symbols y1,...,yn are bound in the interpreter + ++ to respective root values. + ++ Error: if p has more than one variable y. + rootOf : ($, Symbol) -> $ + ++ rootOf(p,y) returns y such that \spad{p(y) = 0}. + ++ The object returned displays as \spad{'y}. + rootsOf: ($, Symbol) -> List $ + ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}; + ++ The returned roots display as \spad{'y1},...,\spad{'yn}. + ++ Note: the returned symbols y1,...,yn are bound in the interpreter + ++ to respective root values. + zeroOf : $ -> $ + ++ zeroOf(p) returns y such that \spad{p(y) = 0}. + ++ The value y is expressed in terms of radicals if possible,and otherwise + ++ as an implicit algebraic quantity. + ++ Error: if p has more than one variable. + zerosOf: $ -> List $ + ++ zerosOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. + ++ The yi's are expressed in radicals if possible. + ++ The returned symbols y1,...,yn are bound in the interpreter + ++ to respective root values. + ++ Error: if p has more than one variable. + zeroOf : ($, Symbol) -> $ + ++ zeroOf(p, y) returns y such that \spad{p(y) = 0}. + ++ The value y is expressed in terms of radicals if possible,and otherwise + ++ as an implicit algebraic quantity + ++ which displays as \spad{'y}. + zerosOf: ($, Symbol) -> List $ + ++ zerosOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. + ++ The yi's are expressed in radicals if possible, and otherwise + ++ as implicit algebraic quantities + ++ which display as \spad{'yi}. + ++ The returned symbols y1,...,yn are bound in the interpreter + ++ to respective root values. + add + rootOf(p:$) == + empty?(l := variables p) => error "rootOf: constant expression" + rootOf(p, first l) + + rootsOf(p:$) == + empty?(l := variables p) => error "rootsOf: constant expression" + rootsOf(p, first l) + + zeroOf(p:$) == + empty?(l := variables p) => error "zeroOf: constant expression" + zeroOf(p, first l) + + zerosOf(p:$) == + empty?(l := variables p) => error "zerosOf: constant expression" + zerosOf(p, first l) + + zeroOf(p:$, x:Symbol) == + n := numer(f := univariate(p, kernel(x)$Kernel($))) + degree denom f > 0 => error "zeroOf: variable appears in denom" + degree n = 0 => error "zeroOf: constant expression" + zeroOf(n, x) + + rootOf(p:$, x:Symbol) == + n := numer(f := univariate(p, kernel(x)$Kernel($))) + degree denom f > 0 => error "roofOf: variable appears in denom" + degree n = 0 => error "rootOf: constant expression" + rootOf(n, x) + + zerosOf(p:$, x:Symbol) == + n := numer(f := univariate(p, kernel(x)$Kernel($))) + degree denom f > 0 => error "zerosOf: variable appears in denom" + degree n = 0 => empty() + zerosOf(n, x) + + rootsOf(p:$, x:Symbol) == + n := numer(f := univariate(p, kernel(x)$Kernel($))) + degree denom f > 0 => error "roofsOf: variable appears in denom" + degree n = 0 => empty() + rootsOf(n, x) + + rootsOf(p:SparseUnivariatePolynomial $, y:Symbol) == + (r := retractIfCan(p)@Union($,"failed")) case $ => rootsOf(r::$,y) + rootsOf(p, y)$AlgebraicallyClosedField_&($) + + zerosOf(p:SparseUnivariatePolynomial $, y:Symbol) == + (r := retractIfCan(p)@Union($,"failed")) case $ => zerosOf(r::$,y) + zerosOf(p, y)$AlgebraicallyClosedField_&($) + + zeroOf(p:SparseUnivariatePolynomial $, y:Symbol) == + (r := retractIfCan(p)@Union($,"failed")) case $ => zeroOf(r::$, y) + zeroOf(p, y)$AlgebraicallyClosedField_&($) + +@ +<>= +"ACFS" + [color=lightblue,href="bookvol10.2.pdf#nameddest=ACFS"]; +"ACFS" -> "ACF" +"ACFS" -> "FS" + +@ +<>= +"AlgebraicallyClosedFunctionSpace(a:Join(OrderedSet,IntegralDomain))" + [color=lightblue,href="bookvol10.2.pdf#nameddest=ACFS"]; +"AlgebraicallyClosedFunctionSpace(a:Join(OrderedSet,IntegralDomain))" + -> "AlgebraicallyClosedField()" +"AlgebraicallyClosedFunctionSpace(a:Join(OrderedSet,IntegralDomain))" + -> "FunctionSpace(a:OrderedSet)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"AlgebraicallyClosedFunctionSpace(a:Join(OrderedSet,IntegralDomain))" + [color=lightblue]; +"AlgebraicallyClosedFunctionSpace(a:Join(OrderedSet,IntegralDomain))" + -> "AlgebraicallyClosedField()" +"AlgebraicallyClosedFunctionSpace(a:Join(OrderedSet,IntegralDomain))" + -> "FunctionSpace(a:OrderedSet)" + +"AlgebraicallyClosedField()" [color=lightblue]; +"AlgebraicallyClosedField()" -> "Field()" +"AlgebraicallyClosedField()" -> "RadicalCategory()" + +"Field()" [color=lightblue]; +"Field()" -> "EUCDOM..." +"Field()" -> "UFD..." +"Field()" -> "DIVRING..." + +"RadicalCategory()" [color=lightblue]; +"RadicalCategory()" -> "Category" + +"Category" [color=lightblue]; +"FunctionSpace(a:OrderedSet)" [color=lightblue]; +"FunctionSpace(a:OrderedSet)" -> "ExpressionSpace()" +"FunctionSpace(a:OrderedSet)" -> "RETRACT..." +"FunctionSpace(a:OrderedSet)" -> "PATAB..." +"FunctionSpace(a:OrderedSet)" -> "FPATMAB..." +"FunctionSpace(a:OrderedSet)" -> "FRETRCT..." + +"ExpressionSpace()" [color=lightblue]; +"ExpressionSpace()" -> "ORDSET..." +"ExpressionSpace()" -> "RETRACT..." +"ExpressionSpace()" -> "IEVALAB..." +"ExpressionSpace()" -> "EVALABLE..." + +"UFD..." [color=lightblue]; +"EUCDOM..." [color=lightblue]; +"DIVRING..." [color=lightblue]; +"EVALABLE..." [color=lightblue]; +"FRETRCT..." [color=lightblue]; +"FPATMAB..." [color=lightblue]; +"IEVALAB..." [color=lightblue]; +"ORDSET..." [color=lightblue]; +"PATAB..." [color=lightblue]; +"RETRACT..." [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{ExtensionField}{XF} \pagepic{ps/v102extensionfield.ps}{XF}{0.75} @@ -47349,6 +49871,657 @@ digraph pic { } @ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{UnivariateLaurentSeriesConstructorCategory}{ULSCCAT} +\pagepic{ps/v102univariatelaurentseriesconstructorcategory.ps}{ULSCCAT}{0.50} + +{\bf See:}\\ +\pagefrom{RetractableTo}{RETRACT} +\pagefrom{UnivariateLaurentSeriesCategory}{ULSCAT} + +{\bf Exports:}\\ +\begin{tabular}{lll} +\cross{ULSCCAT}{0} & +\cross{ULSCCAT}{1} & +\cross{ULSCCAT}{abs} \\ +\cross{ULSCCAT}{acos} & +\cross{ULSCCAT}{acosh} & +\cross{ULSCCAT}{acot} \\ +\cross{ULSCCAT}{acoth} & +\cross{ULSCCAT}{acsc} & +\cross{ULSCCAT}{acsch} \\ +\cross{ULSCCAT}{approximate} & +\cross{ULSCCAT}{asec} & +\cross{ULSCCAT}{asech} \\ +\cross{ULSCCAT}{asin} & +\cross{ULSCCAT}{asinh} & +\cross{ULSCCAT}{associates?} \\ +\cross{ULSCCAT}{atan} & +\cross{ULSCCAT}{atanh} & +\cross{ULSCCAT}{ceiling} \\ +\cross{ULSCCAT}{center} & +\cross{ULSCCAT}{characteristic} & +\cross{ULSCCAT}{charthRoot} \\ +\cross{ULSCCAT}{coefficient} & +\cross{ULSCCAT}{coerce} & +\cross{ULSCCAT}{complete} \\ +\cross{ULSCCAT}{conditionP} & +\cross{ULSCCAT}{convert} & +\cross{ULSCCAT}{cos} \\ +\cross{ULSCCAT}{cosh} & +\cross{ULSCCAT}{cot} & +\cross{ULSCCAT}{coth} \\ +\cross{ULSCCAT}{csc} & +\cross{ULSCCAT}{csch} & +\cross{ULSCCAT}{D} \\ +\cross{ULSCCAT}{degree} & +\cross{ULSCCAT}{denom} & +\cross{ULSCCAT}{denominator} \\ +\cross{ULSCCAT}{differentiate} & +\cross{ULSCCAT}{divide} & +\cross{ULSCCAT}{euclideanSize} \\ +\cross{ULSCCAT}{eval} & +\cross{ULSCCAT}{exp} & +\cross{ULSCCAT}{expressIdealMember} \\ +\cross{ULSCCAT}{exquo} & +\cross{ULSCCAT}{extend} & +\cross{ULSCCAT}{extendedEuclidean} \\ +\cross{ULSCCAT}{factor} & +\cross{ULSCCAT}{factorPolynomial} & +\cross{ULSCCAT}{factorSquareFreePolynomial} \\ +\cross{ULSCCAT}{floor} & +\cross{ULSCCAT}{fractionPart} & +\cross{ULSCCAT}{gcd} \\ +\cross{ULSCCAT}{gcdPolynomial} & +\cross{ULSCCAT}{hash} & +\cross{ULSCCAT}{init} \\ +\cross{ULSCCAT}{integrate} & +\cross{ULSCCAT}{inv} & +\cross{ULSCCAT}{latex} \\ +\cross{ULSCCAT}{laurent} & +\cross{ULSCCAT}{lcm} & +\cross{ULSCCAT}{leadingCoefficient} \\ +\cross{ULSCCAT}{leadingMonomial} & +\cross{ULSCCAT}{log} & +\cross{ULSCCAT}{map} \\ +\cross{ULSCCAT}{max} & +\cross{ULSCCAT}{min} & +\cross{ULSCCAT}{monomial} \\ +\cross{ULSCCAT}{monomial?} & +\cross{ULSCCAT}{multiEuclidean} & +\cross{ULSCCAT}{multiplyCoefficients} \\ +\cross{ULSCCAT}{multiplyExponents} & +\cross{ULSCCAT}{negative?} & +\cross{ULSCCAT}{nextItem} \\ +\cross{ULSCCAT}{nthRoot} & +\cross{ULSCCAT}{numer} & +\cross{ULSCCAT}{numerator} \\ +\cross{ULSCCAT}{one?} & +\cross{ULSCCAT}{order} & +\cross{ULSCCAT}{patternMatch} \\ +\cross{ULSCCAT}{pi} & +\cross{ULSCCAT}{pole?} & +\cross{ULSCCAT}{positive?} \\ +\cross{ULSCCAT}{prime?} & +\cross{ULSCCAT}{principalIdeal} & +\cross{ULSCCAT}{random} \\ +\cross{ULSCCAT}{rationalFunction} & +\cross{ULSCCAT}{recip} & +\cross{ULSCCAT}{reducedSystem} \\ +\cross{ULSCCAT}{reductum} & +\cross{ULSCCAT}{removeZeroes} & +\cross{ULSCCAT}{retract} \\ +\cross{ULSCCAT}{retractIfCan} & +\cross{ULSCCAT}{sample} & +\cross{ULSCCAT}{sec} \\ +\cross{ULSCCAT}{sech} & +\cross{ULSCCAT}{series} & +\cross{ULSCCAT}{sign} \\ +\cross{ULSCCAT}{sin} & +\cross{ULSCCAT}{sinh} & +\cross{ULSCCAT}{sizeLess?} \\ +\cross{ULSCCAT}{solveLinearPolynomialEquation} & +\cross{ULSCCAT}{sqrt} & +\cross{ULSCCAT}{squareFree} \\ +\cross{ULSCCAT}{squareFreePart} & +\cross{ULSCCAT}{squareFreePolynomial} & +\cross{ULSCCAT}{subtractIfCan} \\ +\cross{ULSCCAT}{tan} & +\cross{ULSCCAT}{tanh} & +\cross{ULSCCAT}{taylor} \\ +\cross{ULSCCAT}{taylorIfCan} & +\cross{ULSCCAT}{taylorRep} & +\cross{ULSCCAT}{terms} \\ +\cross{ULSCCAT}{truncate} & +\cross{ULSCCAT}{unit?} & +\cross{ULSCCAT}{unitCanonical} \\ +\cross{ULSCCAT}{unitNormal} & +\cross{ULSCCAT}{variable} & +\cross{ULSCCAT}{variables} \\ +\cross{ULSCCAT}{wholePart} & +\cross{ULSCCAT}{zero?} & +\cross{ULSCCAT}{?*?} \\ +\cross{ULSCCAT}{?**?} & +\cross{ULSCCAT}{?+?} & +\cross{ULSCCAT}{?-?} \\ +\cross{ULSCCAT}{-?} & +\cross{ULSCCAT}{?=?} & +\cross{ULSCCAT}{?\^{}?} \\ +\cross{ULSCCAT}{?\~{}=?} & +\cross{ULSCCAT}{?/?} & +\cross{ULSCCAT}{?$<$?} \\ +\cross{ULSCCAT}{?$<=$?} & +\cross{ULSCCAT}{?$>$?} & +\cross{ULSCCAT}{?$>=$?} \\ +\cross{ULSCCAT}{?.?} & +\cross{ULSCCAT}{?quo?} & +\cross{ULSCCAT}{?rem?} \\ +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item {\bf \cross{ULSCCAT}{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{ULSCCAT}{leftUnitary}} +is true if $1 * x = x$ for all x. +\item {\bf \cross{ULSCCAT}{rightUnitary}} +is true if $x * 1 = x$ for all x. +\item if \#1 has Field then canonicalClosed where +{\bf \cross{ULSCCAT}{canonicalsClosed}} +is true if\\ +{\tt unitCanonical(a)*unitCanonical(b) = unitCanonical(a*b)}. +\item if \#1 has Field then canonicalUnitNormal where +{\bf \cross{ULSCCAT}{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 \#1 has CommutativeRing then commutative(``*'') where +{\bf \cross{ULSCCAT}{commutative(``*'')}} +is true if it has an operation $"*": (D,D) -> D$ +which is commutative. +\item if \#1 has IntegralDomain then noZeroDivisors where +{\bf \cross{ULSCCAT}{noZeroDivisors}} +is true if $x * y \ne 0$ implies both x and y are non-zero. +\item if \#1 has Field then nil +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + coerce : UTS -> % + degree : % -> Integer + laurent : (Integer,UTS) -> % + removeZeroes : % -> % + removeZeroes : (Integer,%) -> % + taylor : % -> UTS + taylorIfCan : % -> Union(UTS,"failed") + taylorRep : % -> UTS +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + retract : % -> UTS + retractIfCan : % -> Union(UTS,"failed") + zero? : % -> Boolean +\end{verbatim} + +These exports come from \refto{UnivariateLaurentSeriesCategory}(Coef:Ring) +\begin{verbatim} + 0 : () -> % + 1 : () -> % + acos : % -> % if Coef has ALGEBRA FRAC INT + acosh : % -> % if Coef has ALGEBRA FRAC INT + acot : % -> % if Coef has ALGEBRA FRAC INT + acoth : % -> % if Coef has ALGEBRA FRAC INT + acsc : % -> % if Coef has ALGEBRA FRAC INT + acsch : % -> % if Coef has ALGEBRA FRAC INT + approximate : (%,Integer) -> Coef + if Coef has **: (Coef,Integer) -> Coef + and Coef has coerce: Symbol -> Coef + asec : % -> % if Coef has ALGEBRA FRAC INT + asech : % -> % if Coef has ALGEBRA FRAC INT + asin : % -> % if Coef has ALGEBRA FRAC INT + asinh : % -> % if Coef has ALGEBRA FRAC INT + associates? : (%,%) -> Boolean if Coef has INTDOM + atan : % -> % if Coef has ALGEBRA FRAC INT + atanh : % -> % if Coef has ALGEBRA FRAC INT + center : % -> Coef + characteristic : () -> NonNegativeInteger + charthRoot : % -> Union(%,"failed") + if and(OR(has(UTS,CharacteristicNonZero), + and(has($,CharacteristicNonZero), + has(UTS,PolynomialFactorizationExplicit))), + has(Coef,Field)) + or Coef has CHARNZ + coefficient : (%,Integer) -> Coef + coerce : % -> % if Coef has INTDOM + coerce : Fraction Integer -> % if Coef has ALGEBRA FRAC INT + coerce : Coef -> % if Coef has COMRING + coerce : Integer -> % + coerce : % -> OutputForm + complete : % -> % + cos : % -> % if Coef has ALGEBRA FRAC INT + cosh : % -> % if Coef has ALGEBRA FRAC INT + cot : % -> % if Coef has ALGEBRA FRAC INT + coth : % -> % if Coef has ALGEBRA FRAC INT + csc : % -> % if Coef has ALGEBRA FRAC INT + csch : % -> % if Coef has ALGEBRA FRAC INT + D : % -> % + if and(has(UTS,DifferentialRing),has(Coef,Field)) + or Coef has *: (Integer,Coef) -> Coef + D : (%,NonNegativeInteger) -> % + if and(has(UTS,DifferentialRing),has(Coef,Field)) + or Coef has *: (Integer,Coef) -> Coef + D : (%,Symbol) -> % + if and(has(UTS,PartialDifferentialRing Symbol),has(Coef,Field)) + or Coef has PDRING SYMBOL + and Coef has *: (Integer,Coef) -> Coef + D : (%,List Symbol) -> % + if and(has(UTS,PartialDifferentialRing Symbol),has(Coef,Field)) + or Coef has PDRING SYMBOL + and Coef has *: (Integer,Coef) -> Coef + D : (%,Symbol,NonNegativeInteger) -> % + if and(has(UTS,PartialDifferentialRing Symbol),has(Coef,Field)) + or Coef has PDRING SYMBOL + and Coef has *: (Integer,Coef) -> Coef + D : (%,List Symbol,List NonNegativeInteger) -> % + if and(has(UTS,PartialDifferentialRing Symbol),has(Coef,Field)) + or Coef has PDRING SYMBOL + and Coef has *: (Integer,Coef) -> Coef + differentiate : (%,Symbol) -> % + if and(has(UTS,PartialDifferentialRing Symbol),has(Coef,Field)) + or Coef has PDRING SYMBOL + and Coef has *: (Integer,Coef) -> Coef + differentiate : (%,List Symbol) -> % + if and(has(UTS,PartialDifferentialRing Symbol),has(Coef,Field)) + or Coef has PDRING SYMBOL + and Coef has *: (Integer,Coef) -> Coef + differentiate : (%,Symbol,NonNegativeInteger) -> % + if and(has(UTS,PartialDifferentialRing Symbol),has(Coef,Field)) + or Coef has PDRING SYMBOL + and Coef has *: (Integer,Coef) -> Coef + differentiate : (%,List Symbol,List NonNegativeInteger) -> % + if and(has(UTS,PartialDifferentialRing Symbol),has(Coef,Field)) + or Coef has PDRING SYMBOL + and Coef has *: (Integer,Coef) -> Coef + differentiate : % -> % + if and(has(UTS,DifferentialRing),has(Coef,Field)) + or Coef has *: (Integer,Coef) -> Coef + differentiate : (%,NonNegativeInteger) -> % + if and(has(UTS,DifferentialRing),has(Coef,Field)) + or Coef has *: (Integer,Coef) -> Coef + divide : (%,%) -> Record(quotient: %,remainder: %) + if Coef has FIELD + euclideanSize : % -> NonNegativeInteger if Coef has FIELD + eval : (%,Coef) -> Stream Coef + if Coef has **: (Coef,Integer) -> Coef + exp : % -> % if Coef has ALGEBRA FRAC INT + expressIdealMember : (List %,%) -> Union(List %,"failed") + if Coef has FIELD + exquo : (%,%) -> Union(%,"failed") if Coef has INTDOM + extend : (%,Integer) -> % + extendedEuclidean : (%,%) -> Record(coef1: %,coef2: %,generator: %) + if Coef has FIELD + extendedEuclidean : (%,%,%) -> Union(Record(coef1: %,coef2: %),"failed") + if Coef has FIELD + factor : % -> Factored % if Coef has FIELD + gcd : (%,%) -> % if Coef has FIELD + gcd : List % -> % if Coef has FIELD + gcdPolynomial : + (SparseUnivariatePolynomial %, + SparseUnivariatePolynomial %) -> + SparseUnivariatePolynomial % + if Coef has FIELD + hash : % -> SingleInteger + integrate : (%,Symbol) -> % + if Coef has ACFS INT + and Coef has PRIMCAT + and Coef has TRANFUN + and Coef has ALGEBRA FRAC INT + or Coef has variables: Coef -> List Symbol + and Coef has integrate: (Coef,Symbol) -> Coef + and Coef has ALGEBRA FRAC INT + integrate : % -> % if Coef has ALGEBRA FRAC INT + inv : % -> % if Coef has FIELD + latex : % -> String + lcm : (%,%) -> % if Coef has FIELD + lcm : List % -> % if Coef has FIELD + leadingCoefficient : % -> Coef + leadingMonomial : % -> % + log : % -> % if Coef has ALGEBRA FRAC INT + map : ((Coef -> Coef),%) -> % + monomial : (%,List SingletonAsOrderedSet,List Integer) -> % + monomial : (%,SingletonAsOrderedSet,Integer) -> % + monomial : (Coef,Integer) -> % + monomial? : % -> Boolean + multiEuclidean : (List %,%) -> Union(List %,"failed") + if Coef has FIELD + multiplyCoefficients : ((Integer -> Coef),%) -> % + multiplyExponents : (%,PositiveInteger) -> % + nthRoot : (%,Integer) -> % if Coef has ALGEBRA FRAC INT + one? : % -> Boolean + order : (%,Integer) -> Integer + order : % -> Integer + pi : () -> % if Coef has ALGEBRA FRAC INT + pole? : % -> Boolean + prime? : % -> Boolean if Coef has FIELD + principalIdeal : List % -> Record(coef: List %,generator: %) + if Coef has FIELD + rationalFunction : (%,Integer) -> Fraction Polynomial Coef + if Coef has INTDOM + rationalFunction : (%,Integer,Integer) -> Fraction Polynomial Coef + if Coef has INTDOM + recip : % -> Union(%,"failed") + reductum : % -> % + sample : () -> % + sec : % -> % if Coef has ALGEBRA FRAC INT + sech : % -> % if Coef has ALGEBRA FRAC INT + series : Stream Record(k: Integer,c: Coef) -> % + sin : % -> % if Coef has ALGEBRA FRAC INT + sinh : % -> % if Coef has ALGEBRA FRAC INT + sizeLess? : (%,%) -> Boolean if Coef has FIELD + squareFree : % -> Factored % if Coef has FIELD + squareFreePart : % -> % if Coef has FIELD + sqrt : % -> % if Coef has ALGEBRA FRAC INT + subtractIfCan : (%,%) -> Union(%,"failed") + tan : % -> % if Coef has ALGEBRA FRAC INT + tanh : % -> % if Coef has ALGEBRA FRAC INT + terms : % -> Stream Record(k: Integer,c: Coef) + truncate : (%,Integer,Integer) -> % + truncate : (%,Integer) -> % + unit? : % -> Boolean if Coef has INTDOM + unitCanonical : % -> % if Coef has INTDOM + unitNormal : % -> Record(unit: %,canonical: %,associate: %) + if Coef has INTDOM + variable : % -> Symbol + variables : % -> List SingletonAsOrderedSet + ?.? : (%,Integer) -> Coef + ?**? : (%,Integer) -> % if Coef has FIELD + ?**? : (%,Fraction Integer) -> % if Coef has ALGEBRA FRAC INT + ?**? : (%,NonNegativeInteger) -> % + ?^? : (%,Integer) -> % if Coef has FIELD + ?^? : (%,NonNegativeInteger) -> % + ?/? : (%,%) -> % if Coef has FIELD + ?+? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (NonNegativeInteger,%) -> % + ?*? : (PositiveInteger,%) -> % + ?*? : (%,%) -> % + ?-? : (%,%) -> % + -? : % -> % + ?**? : (%,PositiveInteger) -> % + ?**? : (%,%) -> % if Coef has ALGEBRA FRAC INT + ?^? : (%,PositiveInteger) -> % + ?*? : (Integer,%) -> % + ?*? : (Coef,%) -> % + ?*? : (%,Coef) -> % + ?*? : (%,Fraction Integer) -> % if Coef has ALGEBRA FRAC INT + ?*? : (Fraction Integer,%) -> % if Coef has ALGEBRA FRAC INT + ?/? : (%,Coef) -> % if Coef has FIELD + ?.? : (%,%) -> % if Integer has SGROUP + ?quo? : (%,%) -> % if Coef has FIELD + ?rem? : (%,%) -> % if Coef has FIELD +\end{verbatim} + +These exports come from \refto{QuotientFieldCategory}(UTS)\\ +where UTS:UnivariateLaurentSeriesCategory(Coef:Ring) +\begin{verbatim} + abs : % -> % + if and(has(UTS,OrderedIntegralDomain),has(Coef,Field)) + ceiling : % -> UTS + if and(has(UTS,IntegerNumberSystem),has(Coef,Field)) + conditionP : Matrix % -> Union(Vector %,"failed") + if and(and(has($,CharacteristicNonZero), + has(UTS,PolynomialFactorizationExplicit)), + has(Coef,Field)) + coerce : Symbol -> % + if and(has(UTS,RetractableTo Symbol),has(Coef,Field)) + convert : % -> Pattern Integer + if and(has(UTS,ConvertibleTo Pattern Integer),has(Coef,Field)) + convert : % -> Pattern Float + if and(has(UTS,ConvertibleTo Pattern Float),has(Coef,Field)\\ + convert : % -> InputForm + if and(has(UTS,ConvertibleTo InputForm),has(Coef,Field)) + convert : % -> Float + if and(has(UTS,RealConstant),has(Coef,Field)) + convert : % -> DoubleFloat + if and(has(UTS,RealConstant),has(Coef,Field)) + D : (%,(UTS -> UTS),NonNegativeInteger) -> % + if Coef has FIELD + D : (%,(UTS -> UTS)) -> % if Coef has FIELD + denom : % -> UTS if Coef has FIELD + denominator : % -> % if Coef has FIELD + differentiate : (%,(UTS -> UTS)) -> % if Coef has FIELD + differentiate : (%,(UTS -> UTS),NonNegativeInteger) -> % + if Coef has FIELD + eval : (%,Equation UTS) -> % + if and(has(UTS,Evalable UTS),has(Coef,Field)) + eval : (%,List Symbol,List UTS) -> % + if and(has(UTS,InnerEvalable(Symbol,UTS)),has(Coef,Field)) + eval : (%,List Equation UTS) -> % + if and(has(UTS,Evalable UTS),has(Coef,Field)) + eval : (%,UTS,UTS) -> % + if and(has(UTS,Evalable UTS),has(Coef,Field)) + eval : (%,List UTS,List UTS) -> % + if and(has(UTS,Evalable UTS),has(Coef,Field)) + eval : (%,Symbol,UTS) -> % + if and(has(UTS,InnerEvalable(Symbol,UTS)),has(Coef,Field)) + factorPolynomial : + SparseUnivariatePolynomial % -> + Factored SparseUnivariatePolynomial % + if and(has(UTS,PolynomialFactorizationExplicit),has(Coef,Field)) + factorSquareFreePolynomial : + SparseUnivariatePolynomial % -> + Factored SparseUnivariatePolynomial % + if and(has(UTS,PolynomialFactorizationExplicit),has(Coef,Field)) + floor : % -> UTS + if and(has(UTS,IntegerNumberSystem),has(Coef,Field)) + fractionPart : % -> % + if and(has(UTS,EuclideanDomain),has(Coef,Field)) + init : () -> % if and(has(UTS,StepThrough),has(Coef,Field)) + map : ((UTS -> UTS),%) -> % if Coef has FIELD + max : (%,%) -> % if and(has(UTS,OrderedSet),has(Coef,Field)) + min : (%,%) -> % if and(has(UTS,OrderedSet),has(Coef,Field)) + negative? : % -> Boolean + if and(has(UTS,OrderedIntegralDomain),has(Coef,Field)) + nextItem : % -> Union(%,"failed") + if and(has(UTS,StepThrough),has(Coef,Field)) + numer : % -> UTS if Coef has FIELD + numerator : % -> % if Coef has FIELD + patternMatch : + (%,Pattern Integer,PatternMatchResult(Integer,%)) -> + PatternMatchResult(Integer,%) + if and(has(UTS,PatternMatchable Integer),has(Coef,Field)) + patternMatch : + (%,Pattern Float,PatternMatchResult(Float,%)) -> + PatternMatchResult(Float,%) + if and(has(UTS,PatternMatchable Float),has(Coef,Field)) + positive? : % -> Boolean + if and(has(UTS,OrderedIntegralDomain),has(Coef,Field)) + random : () -> % + if and(has(UTS,IntegerNumberSystem),has(Coef,Field)) + reducedSystem : + (Matrix %,Vector %) -> Record(mat: Matrix Integer,vec: Vector Integer) + if and(has(UTS,LinearlyExplicitRingOver Integer),has(Coef,Field)) + reducedSystem : Matrix % -> Matrix Integer + if and(has(UTS,LinearlyExplicitRingOver Integer),has(Coef,Field)) + reducedSystem : + (Matrix %,Vector %) -> Record(mat: Matrix UTS,vec: Vector UTS) + if Coef has FIELD + reducedSystem : Matrix % -> Matrix UTS if Coef has FIELD + retract : % -> Symbol + if and(has(UTS,RetractableTo Symbol),has(Coef,Field)) + retract : % -> Integer + if and(has(UTS,RetractableTo Integer),has(Coef,Field)) + retract : % -> Fraction Integer + if and(has(UTS,RetractableTo Integer),has(Coef,Field)) + retractIfCan : % -> Union(Fraction Integer,"failed") + if and(has(UTS,RetractableTo Integer),has(Coef,Field)) + retractIfCan : % -> Union(Symbol,"failed") + if and(has(UTS,RetractableTo Symbol),has(Coef,Field)) + retractIfCan : % -> Union(Integer,"failed") + if and(has(UTS,RetractableTo Integer),has(Coef,Field)) + sign : % -> Integer + if and(has(UTS,OrderedIntegralDomain),has(Coef,Field)) + solveLinearPolynomialEquation : + (List SparseUnivariatePolynomial %, + SparseUnivariatePolynomial %) -> + Union(List SparseUnivariatePolynomial %,"failed") + if and(has(UTS,PolynomialFactorizationExplicit),has(Coef,Field)) + squareFreePolynomial : + SparseUnivariatePolynomial % -> + Factored SparseUnivariatePolynomial % + if and(has(UTS,PolynomialFactorizationExplicit),has(Coef,Field)) + wholePart : % -> UTS + if and(has(UTS,EuclideanDomain),has(Coef,Field)) + ?*? : (UTS,%) -> % if Coef has FIELD + ?*? : (%,UTS) -> % if Coef has FIELD + ? Boolean if and(has(UTS,OrderedSet),has(Coef,Field)) + ?/? : (UTS,UTS) -> % if Coef has FIELD + ?.? : (%,UTS) -> % if and(has(UTS,Eltable(UTS,UTS)),has(Coef,Field)) + ?<=? : (%,%) -> Boolean if and(has(UTS,OrderedSet),has(Coef,Field)) + ?>? : (%,%) -> Boolean if and(has(UTS,OrderedSet),has(Coef,Field)) + ?>=? : (%,%) -> Boolean if and(has(UTS,OrderedSet),has(Coef,Field)) +\end{verbatim} + +<>= +)abbrev category ULSCCAT UnivariateLaurentSeriesConstructorCategory +++ Author: Clifton J. Williamson +++ Date Created: 6 February 1990 +++ Date Last Updated: 10 May 1990 +++ Basic Operations: +++ Related Domains: +++ Also See: +++ AMS Classifications: +++ Keywords: series, Laurent, Taylor +++ Examples: +++ References: +++ Description: +++ This is a category of univariate Laurent series constructed from +++ univariate Taylor series. A Laurent series is represented by a pair +++ \spad{[n,f(x)]}, where n is an arbitrary integer and \spad{f(x)} +++ is a Taylor series. This pair represents the Laurent series +++ \spad{x**n * f(x)}. +UnivariateLaurentSeriesConstructorCategory(Coef,UTS):_ + Category == Definition where + Coef: Ring + UTS : UnivariateTaylorSeriesCategory Coef + I ==> Integer + + Definition ==> Join(UnivariateLaurentSeriesCategory(Coef),_ + RetractableTo UTS) with + laurent: (I,UTS) -> % + ++ \spad{laurent(n,f(x))} returns \spad{x**n * f(x)}. + degree: % -> I + ++ \spad{degree(f(x))} returns the degree of the lowest order term of + ++ \spad{f(x)}, which may have zero as a coefficient. + taylorRep: % -> UTS + ++ \spad{taylorRep(f(x))} returns \spad{g(x)}, where + ++ \spad{f = x**n * g(x)} is represented by \spad{[n,g(x)]}. + removeZeroes: % -> % + ++ \spad{removeZeroes(f(x))} removes leading zeroes from the + ++ representation of the Laurent series \spad{f(x)}. + ++ A Laurent series is represented by (1) an exponent and + ++ (2) a Taylor series which may have leading zero coefficients. + ++ When the Taylor series has a leading zero coefficient, the + ++ 'leading zero' is removed from the Laurent series as follows: + ++ the series is rewritten by increasing the exponent by 1 and + ++ dividing the Taylor series by its variable. + ++ Note: \spad{removeZeroes(f)} removes all leading zeroes from f + removeZeroes: (I,%) -> % + ++ \spad{removeZeroes(n,f(x))} removes up to n leading zeroes from + ++ the Laurent series \spad{f(x)}. + ++ A Laurent series is represented by (1) an exponent and + ++ (2) a Taylor series which may have leading zero coefficients. + ++ When the Taylor series has a leading zero coefficient, the + ++ 'leading zero' is removed from the Laurent series as follows: + ++ the series is rewritten by increasing the exponent by 1 and + ++ dividing the Taylor series by its variable. + coerce: UTS -> % + ++ \spad{coerce(f(x))} converts the Taylor series \spad{f(x)} to a + ++ Laurent series. + taylor: % -> UTS + ++ taylor(f(x)) converts the Laurent series f(x) to a Taylor series, + ++ if possible. Error: if this is not possible. + taylorIfCan: % -> Union(UTS,"failed") + ++ \spad{taylorIfCan(f(x))} converts the Laurent series \spad{f(x)} + ++ to a Taylor series, if possible. If this is not possible, + ++ "failed" is returned. + if Coef has Field then QuotientFieldCategory(UTS) + --++ the quotient field of univariate Taylor series over a field is + --++ the field of Laurent series + + add + + zero? x == zero? taylorRep x + + retract(x:%):UTS == taylor x + + retractIfCan(x:%):Union(UTS,"failed") == taylorIfCan x + +@ +<>= +"ULSCCAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=ULSCCAT"]; +"ULSCCAT" -> "ULSCAT" + +@ +<>= +"UnivariateLaurentSeriesConstructorCategory(a:Ring,b:UnivariateTaylorSeriesCategory(Ring))" + [color=lightblue,href="bookvol10.2.pdf#nameddest=ULSCCAT"]; +"UnivariateLaurentSeriesConstructorCategory(a:Ring,b:UnivariateTaylorSeriesCategory(Ring))" + -> "UnivariateLaurentSeriesCategory(a:Ring)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"UnivariateLaurentSeriesConstructorCategory(a:Ring,b:UnivariateTaylorSeriesCategory(Ring))" + [color=lightblue]; +"UnivariateLaurentSeriesConstructorCategory(a:Ring,b:UnivariateTaylorSeriesCategory(Ring))" + -> "UnivariateLaurentSeriesCategory(a:Ring)" + +"UnivariateLaurentSeriesCategory(a:Ring)" [color=lightblue]; +"UnivariateLaurentSeriesCategory(a:Ring)" -> + "UnivariatePowerSeriesCategory(a:Ring,Integer)" +"UnivariateLaurentSeriesCategory(a:Ring)" -> + "FIELD..." +"UnivariateLaurentSeriesCategory(a:Ring)" -> + "RADCAT..." +"UnivariateLaurentSeriesCategory(a:Ring)" -> + "TRANFUN..." + +"UnivariatePowerSeriesCategory(a:Ring,Integer)" [color=seagreen]; +"UnivariatePowerSeriesCategory(a:Ring,Integer)" -> + "UnivariatePowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid)" + +"UnivariatePowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid)" + [color=lightblue]; +"UnivariatePowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid)" -> + "PowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid,c:SingletonAsOrderedSet)" + +"PowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid,c:SingletonAsOrderedSet)" + [color=seagreen]; +"PowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid,c:SingletonAsOrderedSet)" + -> "PowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid,c:OrderedSet)" + +"PowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid,c:OrderedSet)" + [color=lightblue]; +"PowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid,c:OrderedSet)" -> + "AMR..." + +"AMR..." [color=lightblue]; +"FIELD..." [color=lightblue]; +"TRANFUN..." [color=lightblue]; +"RADCAT..." [color=lightblue]; +} + +@ \chapter{Category Layer 19} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{FiniteAlgebraicExtensionField}{FAXF} @@ -53692,6 +56865,491 @@ Note that this code is not included in the generated catdef.spad file. 0 17 0 0 30 1 0 15 0 16)))))) (QUOTE |lookupComplete|))) @ +\section{INS.lsp BOOTSTRAP} +{\bf INS} depends on itself. We need to break this cycle to build +the algebra. So we keep a cached copy of the translated {\bf INS} +category which we can write into the {\bf MID} directory. We compile +the lisp code and copy the {\bf INS.o} file to the {\bf OUT} directory. +This is eventually forcibly replaced by a recompiled version. +<>= + +(/VERSIONCHECK 2) + +(SETQ |IntegerNumberSystem;AL| (QUOTE NIL)) + +(DEFUN |IntegerNumberSystem| NIL + (LET (#:G1068) + (COND + (|IntegerNumberSystem;AL|) + (T (SETQ |IntegerNumberSystem;AL| (|IntegerNumberSystem;|)))))) + +(DEFUN |IntegerNumberSystem;| NIL (PROG (#0=#:G1066) + (RETURN + (PROG1 + (LETT #0# + (|sublisV| + (PAIR + (QUOTE (#1=#:G1060 #2=#:G1061 #3=#:G1062 + #4=#:G1063 #5=#:G1064 #6=#:G1065)) + (LIST + (QUOTE (|Integer|)) + (QUOTE (|Integer|)) + (QUOTE (|Integer|)) + (QUOTE (|InputForm|)) + (QUOTE (|Pattern| (|Integer|))) + (QUOTE (|Integer|)))) + (|Join| + (|UniqueFactorizationDomain|) + (|EuclideanDomain|) + (|OrderedIntegralDomain|) + (|DifferentialRing|) + (|ConvertibleTo| (QUOTE #1#)) + (|RetractableTo| (QUOTE #2#)) + (|LinearlyExplicitRingOver| (QUOTE #3#)) + (|ConvertibleTo| (QUOTE #4#)) + (|ConvertibleTo| (QUOTE #5#)) + (|PatternMatchable| (QUOTE #6#)) + (|CombinatorialFunctionCategory|) + (|RealConstant|) + (|CharacteristicZero|) + (|StepThrough|) + (|mkCategory| + (QUOTE |domain|) + (QUOTE ( + ((|odd?| ((|Boolean|) $)) T) + ((|even?| ((|Boolean|) $)) T) + ((|base| ($)) T) + ((|length| ($ $)) T) + ((|shift| ($ $ $)) T) + ((|bit?| ((|Boolean|) $ $)) T) + ((|positiveRemainder| ($ $ $)) T) + ((|symmetricRemainder| ($ $ $)) T) + ((|rational?| ((|Boolean|) $)) T) + ((|rational| ((|Fraction| (|Integer|)) $)) T) + ((|rationalIfCan| + ((|Union| (|Fraction| (|Integer|)) "failed") $)) T) + ((|random| ($)) T) + ((|random| ($ $)) T) + ((|hash| ($ $)) T) + ((|copy| ($ $)) T) + ((|inc| ($ $)) T) + ((|dec| ($ $)) T) + ((|mask| ($ $)) T) + ((|addmod| ($ $ $ $)) T) + ((|submod| ($ $ $ $)) T) + ((|mulmod| ($ $ $ $)) T) + ((|powmod| ($ $ $ $)) T) + ((|invmod| ($ $ $)) T))) + (QUOTE ((|multiplicativeValuation| T) (|canonicalUnitNormal| T))) + (QUOTE ((|Fraction| (|Integer|)) (|Boolean|))) NIL))) + |IntegerNumberSystem|) + (SETELT #0# 0 (QUOTE (|IntegerNumberSystem|))))))) + +(MAKEPROP (QUOTE |IntegerNumberSystem|) (QUOTE NILADIC) T) + +@ +\section{INS-.lsp BOOTSTRAP} +{\bf INS-} depends on {\bf INS}. We need to break this cycle to build +the algebra. So we keep a cached copy of the translated {\bf INS-} +category which we can write into the {\bf MID} directory. We compile +the lisp code and copy the {\bf INS-.o} file to the {\bf OUT} directory. +This is eventually forcibly replaced by a recompiled version. +<>= + +(/VERSIONCHECK 2) + +(PUT + (QUOTE |INS-;characteristic;Nni;1|) + (QUOTE |SPADreplace|) + (QUOTE (XLAM NIL 0))) + +(DEFUN |INS-;characteristic;Nni;1| ($) 0) + +(DEFUN |INS-;differentiate;2S;2| (|x| $) + (|spadConstant| $ 9)) + +(DEFUN |INS-;even?;SB;3| (|x| $) + (COND + ((SPADCALL |x| (QREFELT $ 12)) (QUOTE NIL)) + ((QUOTE T) (QUOTE T)))) + +(DEFUN |INS-;positive?;SB;4| (|x| $) + (SPADCALL (|spadConstant| $ 9) |x| (QREFELT $ 14))) + +(PUT + (QUOTE |INS-;copy;2S;5|) + (QUOTE |SPADreplace|) + (QUOTE (XLAM (|x|) |x|))) + +(DEFUN |INS-;copy;2S;5| (|x| $) |x|) + +(DEFUN |INS-;bit?;2SB;6| (|x| |i| $) + (SPADCALL + (SPADCALL |x| + (SPADCALL |i| (QREFELT $ 17)) + (QREFELT $ 18)) + (QREFELT $ 12))) + +(DEFUN |INS-;mask;2S;7| (|n| $) + (SPADCALL + (SPADCALL (|spadConstant| $ 20) |n| (QREFELT $ 18)) + (QREFELT $ 21))) + +(PUT + (QUOTE |INS-;rational?;SB;8|) + (QUOTE |SPADreplace|) + (QUOTE (XLAM (|x|) (QUOTE T)))) + +(DEFUN |INS-;rational?;SB;8| (|x| $) + (QUOTE T)) + +(DEFUN |INS-;euclideanSize;SNni;9| (|x| $) + (PROG (#0=#:G1078 #1=#:G1079) + (RETURN + (COND + ((SPADCALL |x| (|spadConstant| $ 9) (QREFELT $ 24)) + (|error| "euclideanSize called on zero")) + ((SPADCALL |x| (|spadConstant| $ 9) (QREFELT $ 14)) + (PROG1 + (LETT #0# + (- (SPADCALL |x| (QREFELT $ 26))) + |INS-;euclideanSize;SNni;9|) + (|check-subtype| + (>= #0# 0) + (QUOTE (|NonNegativeInteger|)) + #0#))) + ((QUOTE T) + (PROG1 + (LETT #1# + (SPADCALL |x| (QREFELT $ 26)) + |INS-;euclideanSize;SNni;9|) + (|check-subtype| + (>= #1# 0) + (QUOTE (|NonNegativeInteger|)) + #1#))))))) + +(DEFUN |INS-;convert;SF;10| (|x| $) + (SPADCALL (SPADCALL |x| (QREFELT $ 26)) (QREFELT $ 29))) + +(DEFUN |INS-;convert;SDf;11| (|x| $) + (FLOAT (SPADCALL |x| (QREFELT $ 26)) MOST-POSITIVE-LONG-FLOAT)) + +(DEFUN |INS-;convert;SIf;12| (|x| $) + (SPADCALL (SPADCALL |x| (QREFELT $ 26)) (QREFELT $ 34))) + +(DEFUN |INS-;retract;SI;13| (|x| $) + (SPADCALL |x| (QREFELT $ 26))) + +(DEFUN |INS-;convert;SP;14| (|x| $) + (SPADCALL (SPADCALL |x| (QREFELT $ 26)) (QREFELT $ 38))) + +(DEFUN |INS-;factor;SF;15| (|x| $) + (SPADCALL |x| (QREFELT $ 42))) + +(DEFUN |INS-;squareFree;SF;16| (|x| $) + (SPADCALL |x| (QREFELT $ 45))) + +(DEFUN |INS-;prime?;SB;17| (|x| $) + (SPADCALL |x| (QREFELT $ 48))) + +(DEFUN |INS-;factorial;2S;18| (|x| $) + (SPADCALL |x| (QREFELT $ 51))) + +(DEFUN |INS-;binomial;3S;19| (|n| |m| $) + (SPADCALL |n| |m| (QREFELT $ 53))) + +(DEFUN |INS-;permutation;3S;20| (|n| |m| $) + (SPADCALL |n| |m| (QREFELT $ 55))) + +(DEFUN |INS-;retractIfCan;SU;21| (|x| $) + (CONS 0 (SPADCALL |x| (QREFELT $ 26)))) + +(DEFUN |INS-;init;S;22| ($) + (|spadConstant| $ 9)) + +(DEFUN |INS-;nextItem;SU;23| (|n| $) + (COND + ((SPADCALL |n| (QREFELT $ 60)) + (CONS 0 (|spadConstant| $ 20))) + ((SPADCALL (|spadConstant| $ 9) |n| (QREFELT $ 14)) + (CONS 0 (SPADCALL |n| (QREFELT $ 17)))) + ((QUOTE T) + (CONS 0 (SPADCALL (|spadConstant| $ 20) |n| (QREFELT $ 61)))))) + +(DEFUN |INS-;patternMatch;SP2Pmr;24| (|x| |p| |l| $) + (SPADCALL |x| |p| |l| (QREFELT $ 66))) + +(DEFUN |INS-;rational;SF;25| (|x| $) + (SPADCALL (SPADCALL |x| (QREFELT $ 26)) (QREFELT $ 70))) + +(DEFUN |INS-;rationalIfCan;SU;26| (|x| $) + (CONS 0 (SPADCALL (SPADCALL |x| (QREFELT $ 26)) (QREFELT $ 70)))) + +(DEFUN |INS-;symmetricRemainder;3S;27| (|x| |n| $) + (PROG (|r|) + (RETURN + (SEQ + (LETT |r| + (SPADCALL |x| |n| (QREFELT $ 74)) + |INS-;symmetricRemainder;3S;27|) + (EXIT + (COND + ((SPADCALL |r| (|spadConstant| $ 9) (QREFELT $ 24)) |r|) + ((QUOTE T) + (SEQ + (COND + ((SPADCALL |n| (|spadConstant| $ 9) (QREFELT $ 14)) + (LETT |n| + (SPADCALL |n| (QREFELT $ 17)) + |INS-;symmetricRemainder;3S;27|))) + (EXIT + (COND + ((SPADCALL (|spadConstant| $ 9) |r| (QREFELT $ 14)) + (COND + ((SPADCALL |n| + (SPADCALL 2 |r| (QREFELT $ 76)) + (QREFELT $ 14)) + (SPADCALL |r| |n| (QREFELT $ 61))) + ((QUOTE T) |r|))) + ((NULL + (SPADCALL + (|spadConstant| $ 9) + (SPADCALL + (SPADCALL 2 |r| (QREFELT $ 76)) + |n| + (QREFELT $ 77)) + (QREFELT $ 14))) + (SPADCALL |r| |n| (QREFELT $ 77))) + ((QUOTE T) |r|))))))))))) + +(DEFUN |INS-;invmod;3S;28| (|a| |b| $) + (PROG (|q| |r| |r1| |c| |c1| |d| |d1|) + (RETURN + (SEQ + (COND + ((SPADCALL |a| (QREFELT $ 79)) + (LETT |a| (SPADCALL |a| |b| (QREFELT $ 80)) |INS-;invmod;3S;28|))) + (LETT |c| |a| |INS-;invmod;3S;28|) + (LETT |c1| (|spadConstant| $ 20) |INS-;invmod;3S;28|) + (LETT |d| |b| |INS-;invmod;3S;28|) + (LETT |d1| (|spadConstant| $ 9) |INS-;invmod;3S;28|) + (SEQ G190 + (COND + ((NULL + (COND + ((SPADCALL |d| (QREFELT $ 60)) (QUOTE NIL)) + ((QUOTE T) (QUOTE T)))) + (GO G191))) + (SEQ + (LETT |q| (SPADCALL |c| |d| (QREFELT $ 81)) |INS-;invmod;3S;28|) + (LETT |r| + (SPADCALL |c| (SPADCALL |q| |d| (QREFELT $ 82)) (QREFELT $ 61)) + |INS-;invmod;3S;28|) + (LETT |r1| + (SPADCALL |c1| (SPADCALL |q| |d1| (QREFELT $ 82)) (QREFELT $ 61)) + |INS-;invmod;3S;28|) + (LETT |c| |d| |INS-;invmod;3S;28|) + (LETT |c1| |d1| |INS-;invmod;3S;28|) + (LETT |d| |r| |INS-;invmod;3S;28|) + (EXIT (LETT |d1| |r1| |INS-;invmod;3S;28|))) + NIL + (GO G190) + G191 + (EXIT NIL)) + (COND + ((NULL (SPADCALL |c| (QREFELT $ 83))) + (EXIT (|error| "inverse does not exist")))) + (EXIT + (COND + ((SPADCALL |c1| (QREFELT $ 79)) (SPADCALL |c1| |b| (QREFELT $ 77))) + ((QUOTE T) |c1|))))))) + +(DEFUN |INS-;powmod;4S;29| (|x| |n| |p| $) + (PROG (|y| #0=#:G1137 |z|) + (RETURN + (SEQ + (EXIT + (SEQ + (COND + ((SPADCALL |x| (QREFELT $ 79)) + (LETT |x| + (SPADCALL |x| |p| (QREFELT $ 80)) + |INS-;powmod;4S;29|))) + (EXIT + (COND + ((SPADCALL |x| (QREFELT $ 60)) (|spadConstant| $ 9)) + ((SPADCALL |n| (QREFELT $ 60)) (|spadConstant| $ 20)) + ((QUOTE T) + (SEQ + (LETT |y| (|spadConstant| $ 20) |INS-;powmod;4S;29|) + (LETT |z| |x| |INS-;powmod;4S;29|) + (EXIT + (SEQ G190 + NIL + (SEQ + (COND + ((SPADCALL |n| (QREFELT $ 12)) + (LETT |y| + (SPADCALL |y| |z| |p| (QREFELT $ 85)) + |INS-;powmod;4S;29|))) + (EXIT + (COND + ((SPADCALL + (LETT |n| + (SPADCALL |n| + (SPADCALL + (|spadConstant| $ 20) + (QREFELT $ 17)) + (QREFELT $ 18)) + |INS-;powmod;4S;29|) + (QREFELT $ 60)) + (PROGN + (LETT #0# |y| |INS-;powmod;4S;29|) + (GO #0#))) + ((QUOTE T) + (LETT |z| + (SPADCALL |z| |z| |p| (QREFELT $ 85)) + |INS-;powmod;4S;29|))))) + NIL + (GO G190) + G191 + (EXIT NIL))))))))) + #0# + (EXIT #0#))))) + +(DEFUN |IntegerNumberSystem&| (|#1|) + (PROG (DV$1 |dv$| $ |pv$|) + (RETURN + (PROGN + (LETT DV$1 (|devaluate| |#1|) . #0=(|IntegerNumberSystem&|)) + (LETT |dv$| (LIST (QUOTE |IntegerNumberSystem&|) DV$1) . #0#) + (LETT $ (GETREFV 87) . #0#) + (QSETREFV $ 0 |dv$|) + (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#)) + (|stuffDomainSlots| $) + (QSETREFV $ 6 |#1|) + $)))) + +(MAKEPROP + (QUOTE |IntegerNumberSystem&|) + (QUOTE |infovec|) + (LIST + (QUOTE + #(NIL NIL NIL NIL NIL NIL + (|local| |#1|) + (|NonNegativeInteger|) + |INS-;characteristic;Nni;1| + (0 . |Zero|) + |INS-;differentiate;2S;2| + (|Boolean|) + (4 . |odd?|) + |INS-;even?;SB;3| + (9 . <) + |INS-;positive?;SB;4| + |INS-;copy;2S;5| + (15 . -) + (20 . |shift|) + |INS-;bit?;2SB;6| + (26 . |One|) + (30 . |dec|) + |INS-;mask;2S;7| + |INS-;rational?;SB;8| + (35 . =) + (|Integer|) + (41 . |convert|) + |INS-;euclideanSize;SNni;9| + (|Float|) + (46 . |coerce|) + |INS-;convert;SF;10| + (|DoubleFloat|) + |INS-;convert;SDf;11| + (|InputForm|) + (51 . |convert|) + |INS-;convert;SIf;12| + |INS-;retract;SI;13| + (|Pattern| 25) + (56 . |coerce|) + |INS-;convert;SP;14| + (|Factored| 6) + (|IntegerFactorizationPackage| 6) + (61 . |factor|) + (|Factored| $) + |INS-;factor;SF;15| + (66 . |squareFree|) + |INS-;squareFree;SF;16| + (|IntegerPrimesPackage| 6) + (71 . |prime?|) + |INS-;prime?;SB;17| + (|IntegerCombinatoricFunctions| 6) + (76 . |factorial|) + |INS-;factorial;2S;18| + (81 . |binomial|) + |INS-;binomial;3S;19| + (87 . |permutation|) + |INS-;permutation;3S;20| + (|Union| 25 (QUOTE "failed")) + |INS-;retractIfCan;SU;21| + |INS-;init;S;22| + (93 . |zero?|) + (98 . -) + (|Union| $ (QUOTE "failed")) + |INS-;nextItem;SU;23| + (|PatternMatchResult| 25 6) + (|PatternMatchIntegerNumberSystem| 6) + (104 . |patternMatch|) + (|PatternMatchResult| 25 $) + |INS-;patternMatch;SP2Pmr;24| + (|Fraction| 25) + (111 . |coerce|) + |INS-;rational;SF;25| + (|Union| 69 (QUOTE "failed")) + |INS-;rationalIfCan;SU;26| + (116 . |rem|) + (|PositiveInteger|) + (122 . *) + (128 . +) + |INS-;symmetricRemainder;3S;27| + (134 . |negative?|) + (139 . |positiveRemainder|) + (145 . |quo|) + (151 . *) + (157 . |one?|) + |INS-;invmod;3S;28| + (162 . |mulmod|) + |INS-;powmod;4S;29|)) + (QUOTE + #(|symmetricRemainder| 169 |squareFree| 175 |retractIfCan| 180 + |retract| 185 |rationalIfCan| 190 |rational?| 195 |rational| 200 + |prime?| 205 |powmod| 210 |positive?| 217 |permutation| 222 + |patternMatch| 228 |nextItem| 235 |mask| 240 |invmod| 245 |init| 251 + |factorial| 255 |factor| 260 |even?| 265 |euclideanSize| 270 + |differentiate| 275 |copy| 280 |convert| 285 |characteristic| 305 + |bit?| 309 |binomial| 315)) + (QUOTE NIL) + (CONS + (|makeByteWordVec2| 1 (QUOTE NIL)) + (CONS + (QUOTE #()) + (CONS + (QUOTE #()) + (|makeByteWordVec2| 86 + (QUOTE + (0 6 0 9 1 6 11 0 12 2 6 11 0 0 14 1 6 0 0 17 2 6 0 0 0 18 0 6 + 0 20 1 6 0 0 21 2 6 11 0 0 24 1 6 25 0 26 1 28 0 25 29 1 33 0 + 25 34 1 37 0 25 38 1 41 40 6 42 1 41 40 6 45 1 47 11 6 48 1 50 + 6 6 51 2 50 6 6 6 53 2 50 6 6 6 55 1 6 11 0 60 2 6 0 0 0 61 3 + 65 64 6 37 64 66 1 69 0 25 70 2 6 0 0 0 74 2 6 0 75 0 76 2 6 0 + 0 0 77 1 6 11 0 79 2 6 0 0 0 80 2 6 0 0 0 81 2 6 0 0 0 82 1 6 + 11 0 83 3 6 0 0 0 0 85 2 0 0 0 0 78 1 0 43 0 46 1 0 57 0 58 1 + 0 25 0 36 1 0 72 0 73 1 0 11 0 23 1 0 69 0 71 1 0 11 0 49 3 0 + 0 0 0 0 86 1 0 11 0 15 2 0 0 0 0 56 3 0 67 0 37 67 68 1 0 62 + 0 63 1 0 0 0 22 2 0 0 0 0 84 0 0 0 59 1 0 0 0 52 1 0 43 0 44 + 1 0 11 0 13 1 0 7 0 27 1 0 0 0 10 1 0 0 0 16 1 0 31 0 32 1 0 + 28 0 30 1 0 37 0 39 1 0 33 0 35 0 0 7 8 2 0 11 0 0 19 2 0 0 + 0 0 54)))))) + (QUOTE |lookupComplete|))) + +@ \section{INTDOM.lsp BOOTSTRAP} {\bf INTDOM} depends on itself. We need to break this cycle to build the algebra. So we keep a cached copy of the translated {\bf INTDOM} @@ -62349,6 +66007,7 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> @@ -62430,6 +66089,7 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> @@ -62479,6 +66139,7 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> @@ -62486,6 +66147,7 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> @@ -62498,11 +66160,13 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> <> <> +<> <> <> <> @@ -62518,6 +66182,7 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> @@ -62541,6 +66206,7 @@ digraph dotabb { <> <> <> +<> <> <> <> @@ -62620,6 +66286,7 @@ digraph dotabb { <> <> <> +<> <> <> <> @@ -62669,6 +66336,7 @@ digraph dotabb { <> <> <> +<> <> <> <> @@ -62676,6 +66344,7 @@ digraph dotabb { <> <> <> +<> <> <> <> @@ -62688,11 +66357,13 @@ digraph dotabb { <> <> <> +<> <> <> <> <> <> +<> <> <> <> @@ -62708,6 +66379,7 @@ digraph dotabb { <> <> <> +<> <> <> <> @@ -62734,6 +66406,7 @@ digraph dotfull { <> <> <> +<> <> <> <> @@ -62813,6 +66486,7 @@ digraph dotfull { <> <> <> +<> <> <> <> @@ -62862,6 +66536,7 @@ digraph dotfull { <> <> <> +<> <> <> <> @@ -62869,6 +66544,7 @@ digraph dotfull { <> <> <> +<> <> <> <> @@ -62881,11 +66557,13 @@ digraph dotfull { <> <> <> +<> <> <> <> <> <> +<> <> <> <> @@ -62901,6 +66579,7 @@ digraph dotfull { <> <> <> +<> <> <> <> diff --git a/books/ps/v102algebraicallyclosedfunctionspace.ps b/books/ps/v102algebraicallyclosedfunctionspace.ps new file mode 100644 index 0000000..5158a78 --- /dev/null +++ b/books/ps/v102algebraicallyclosedfunctionspace.ps @@ -0,0 +1,1000 @@ +%!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 921 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 921 296 +%%PageOrientation: Portrait +gsave +36 36 885 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 +883 258 lineto +883 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 258 lineto +883 258 lineto +883 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% AlgebraicallyClosedFunctionSpace(a:Join(OrderedSet,IntegralDomain)) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 627 252 moveto +205 252 lineto +205 216 lineto +627 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 627 252 moveto +205 252 lineto +205 216 lineto +627 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +213 229 moveto +(AlgebraicallyClosedFunctionSpace\(a:Join\(OrderedSet,IntegralDomain\)\)) +[10.08 3.84 6.72 6.24 6.96 4.8 6.24 3.84 6.24 6.24 3.84 3.6 6.96 9.36 3.84 6.96 5.52 6.24 6.96 7.44 6.96 6.96 6.24 3.84 3.84 6.96 6.96 7.68 6.96 6.24 6.24 6.24 4.56 6.24 3.84 5.52 6.96 3.84 6.96 4.56 10.08 4.56 6.96 6.24 4.8 6.24 6.96 7.68 6 3.84 3.6 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 4.56] +xshow +end grestore +end grestore +% AlgebraicallyClosedField() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 403 180 moveto +233 180 lineto +233 144 lineto +403 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 403 180 moveto +233 180 lineto +233 144 lineto +403 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +241 157 moveto +(AlgebraicallyClosedField\(\)) +[10.08 3.84 6.72 6.24 6.96 4.8 6.24 3.84 6.24 6.24 3.84 3.6 6.96 9.36 3.84 6.96 5.52 6.24 6.96 7.44 3.84 6.24 3.84 6.96 4.56 4.56] +xshow +end grestore +end grestore +% AlgebraicallyClosedFunctionSpace(a:Join(OrderedSet,IntegralDomain))->AlgebraicallyClosedField() +newpath 391 216 moveto +379 207 364 196 350 186 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 352 183 moveto +342 180 lineto +348 189 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 352 183 moveto +342 180 lineto +348 189 lineto +closepath +stroke +end grestore +% FunctionSpace(a:OrderedSet) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 606 180 moveto +424 180 lineto +424 144 lineto +606 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 606 180 moveto +424 180 lineto +424 144 lineto +606 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +432 157 moveto +(FunctionSpace\(a:OrderedSet\)) +[7.44 6.96 6.96 6.24 3.84 3.84 6.96 6.96 7.68 6.96 6.24 6.24 6.24 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 +% AlgebraicallyClosedFunctionSpace(a:Join(OrderedSet,IntegralDomain))->FunctionSpace(a:OrderedSet) +newpath 441 216 moveto +453 207 468 196 482 186 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 484 189 moveto +490 180 lineto +480 183 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 484 189 moveto +490 180 lineto +480 183 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 200 108 moveto +146 108 lineto +146 72 lineto +200 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 200 108 moveto +146 108 lineto +146 72 lineto +200 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +154 85 moveto +(Field\(\)) +[7.44 3.84 6.24 3.84 6.96 4.56 4.56] +xshow +end grestore +end grestore +% AlgebraicallyClosedField()->Field() +newpath 281 144 moveto +259 134 231 119 209 108 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 211 105 moveto +200 104 lineto +208 111 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 211 105 moveto +200 104 lineto +208 111 lineto +closepath +stroke +end grestore +% RadicalCategory() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 378 108 moveto +258 108 lineto +258 72 lineto +378 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 378 108 moveto +258 108 lineto +258 72 lineto +378 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +266 85 moveto +(RadicalCategory\(\)) +[9.36 6.24 6.96 3.84 6.24 6.24 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 +% AlgebraicallyClosedField()->RadicalCategory() +newpath 318 144 moveto +318 136 318 127 318 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 322 118 moveto +318 108 lineto +315 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 322 118 moveto +318 108 lineto +315 118 lineto +closepath +stroke +end grestore +% ExpressionSpace() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 573 108 moveto +451 108 lineto +451 72 lineto +573 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 573 108 moveto +451 108 lineto +451 72 lineto +573 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +459 85 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 +% FunctionSpace(a:OrderedSet)->ExpressionSpace() +newpath 514 144 moveto +513 136 513 127 513 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 517 118 moveto +513 108 lineto +510 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 517 118 moveto +513 108 lineto +510 118 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 460 36 moveto +370 36 lineto +370 0 lineto +460 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 460 36 moveto +370 36 lineto +370 0 lineto +460 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +378 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 +% FunctionSpace(a:OrderedSet)->RETRACT... +newpath 482 144 moveto +468 135 452 123 442 108 curveto +429 90 421 65 418 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 421 46 moveto +417 36 lineto +415 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 421 46 moveto +417 36 lineto +415 46 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 663 108 moveto +591 108 lineto +591 72 lineto +663 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 663 108 moveto +591 108 lineto +591 72 lineto +663 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +599 85 moveto +(PATAB...) +[6.48 9.36 7.92 10.08 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% FunctionSpace(a:OrderedSet)->PATAB... +newpath 543 144 moveto +557 135 575 124 590 114 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 593 116 moveto +599 108 lineto +589 111 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 593 116 moveto +599 108 lineto +589 111 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 773 108 moveto +681 108 lineto +681 72 lineto +773 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 773 108 moveto +681 108 lineto +681 72 lineto +773 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +689 85 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 +% FunctionSpace(a:OrderedSet)->FPATMAB... +newpath 568 144 moveto +600 133 640 120 671 109 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 672 112 moveto +681 106 lineto +670 106 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 672 112 moveto +681 106 lineto +670 106 lineto +closepath +stroke +end grestore +% FRETRCT... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 877 108 moveto +791 108 lineto +791 72 lineto +877 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 877 108 moveto +791 108 lineto +791 72 lineto +877 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +798 85 moveto +(FRETRCT...) +[7.68 9.36 8.64 8.64 8.88 9.36 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% FunctionSpace(a:OrderedSet)->FRETRCT... +newpath 606 146 moveto +655 137 718 124 781 108 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 782 111 moveto +791 105 lineto +780 105 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 782 111 moveto +791 105 lineto +780 105 lineto +closepath +stroke +end grestore +% EUCDOM... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 88 36 moveto +0 36 lineto +0 0 lineto +88 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 88 36 moveto +0 36 lineto +0 0 lineto +88 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 13 moveto +(EUCDOM...) +[8.64 10.08 9.36 10.08 10.08 12.48 3.6 3.6 3.6] +xshow +end grestore +end grestore +% Field()->EUCDOM... +newpath 146 75 moveto +129 65 105 52 85 41 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 86 38 moveto +76 36 lineto +83 44 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 86 38 moveto +76 36 lineto +83 44 lineto +closepath +stroke +end grestore +% UFD... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 162 36 moveto +106 36 lineto +106 0 lineto +162 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 162 36 moveto +106 36 lineto +106 0 lineto +162 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +114 13 moveto +(UFD...) +[10.08 7.68 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% Field()->UFD... +newpath 163 72 moveto +159 64 154 54 149 45 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 152 43 moveto +144 36 lineto +146 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 152 43 moveto +144 36 lineto +146 46 lineto +closepath +stroke +end grestore +% DIVRING... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 266 36 moveto +180 36 lineto +180 0 lineto +266 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 266 36 moveto +180 36 lineto +180 0 lineto +266 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +187 13 moveto +(DIVRING...) +[10.08 4.56 10.08 9.36 4.56 9.84 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% Field()->DIVRING... +newpath 186 72 moveto +191 64 198 54 204 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 207 46 moveto +210 36 lineto +201 42 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 207 46 moveto +210 36 lineto +201 42 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 352 36 moveto +284 36 lineto +284 0 lineto +352 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 352 36 moveto +284 36 lineto +284 0 lineto +352 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +292 13 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% RadicalCategory()->Category +newpath 318 72 moveto +318 64 318 55 318 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 322 46 moveto +318 36 lineto +315 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 322 46 moveto +318 36 lineto +315 46 lineto +closepath +stroke +end grestore +% ExpressionSpace()->RETRACT... +newpath 488 72 moveto +476 63 461 52 447 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 449 39 moveto +439 36 lineto +445 45 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 449 39 moveto +439 36 lineto +445 45 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 558 36 moveto +478 36 lineto +478 0 lineto +558 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 558 36 moveto +478 36 lineto +478 0 lineto +558 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +485 13 moveto +(ORDSET...) +[10.08 9.36 10.08 7.68 8.64 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% ExpressionSpace()->ORDSET... +newpath 514 72 moveto +515 64 515 55 516 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 520 46 moveto +516 36 lineto +513 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 520 46 moveto +516 36 lineto +513 46 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 664 36 moveto +576 36 lineto +576 0 lineto +664 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 664 36 moveto +576 36 lineto +576 0 lineto +664 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +584 13 moveto +(IEVALAB...) +[4.56 8.64 8.4 10.08 8.64 10.08 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% ExpressionSpace()->IEVALAB... +newpath 539 72 moveto +553 63 570 52 584 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 587 44 moveto +593 36 lineto +583 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 587 44 moveto +593 36 lineto +583 39 lineto +closepath +stroke +end grestore +% EVALABLE... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 782 36 moveto +682 36 lineto +682 0 lineto +782 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 782 36 moveto +682 36 lineto +682 0 lineto +782 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +690 13 moveto +(EVALABLE...) +[8.64 8.4 10.08 8.64 10.08 9.36 8.64 8.64 3.6 3.6 3.6] +xshow +end grestore +end grestore +% ExpressionSpace()->EVALABLE... +newpath 567 72 moveto +599 62 639 49 672 38 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 673 41 moveto +682 35 lineto +671 35 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 673 41 moveto +682 35 lineto +671 35 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102pointcategory.ps b/books/ps/v102pointcategory.ps new file mode 100644 index 0000000..7f56f56 --- /dev/null +++ b/books/ps/v102pointcategory.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 359 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 359 584 +%%PageOrientation: Portrait +gsave +36 36 323 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 +321 546 lineto +321 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 546 lineto +321 546 lineto +321 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% PointCategory(a:Ring) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 263 540 moveto +119 540 lineto +119 504 lineto +263 504 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 263 540 moveto +119 540 lineto +119 504 lineto +263 504 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +126 517 moveto +(PointCategory\(a:Ring\)) +[7.44 6.96 3.84 6.96 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 4.56] +xshow +end grestore +end grestore +% VectorCategory(a:Ring) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 267 468 moveto +115 468 lineto +115 432 lineto +267 432 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 267 468 moveto +115 468 lineto +115 432 lineto +267 432 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +122 445 moveto +(VectorCategory\(a:Ring\)) +[8.88 6.24 6.24 3.84 6.96 4.8 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 4.56] +xshow +end grestore +end grestore +% PointCategory(a:Ring)->VectorCategory(a:Ring) +newpath 191 504 moveto +191 496 191 487 191 478 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 195 478 moveto +191 468 lineto +188 478 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 195 478 moveto +191 468 lineto +188 478 lineto +closepath +stroke +end grestore +% VectorCategory(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 267 396 moveto +115 396 lineto +115 360 lineto +267 360 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 267 396 moveto +115 396 lineto +115 360 lineto +267 360 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +122 373 moveto +(VectorCategory\(a:Type\)) +[8.88 6.24 6.24 3.84 6.96 4.8 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% VectorCategory(a:Ring)->VectorCategory(a:Type) +newpath 191 432 moveto +191 424 191 415 191 406 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 195 406 moveto +191 396 lineto +188 406 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 195 406 moveto +191 396 lineto +188 406 lineto +closepath +stroke +end grestore +% OneDimensionalArrayAggregate(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 315 324 moveto +67 324 lineto +67 288 lineto +315 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 315 324 moveto +67 324 lineto +67 288 lineto +315 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +74 301 moveto +(OneDimensionalArrayAggregate\(a:Type\)) +[10.08 6.96 6.24 10.08 3.84 10.8 6.24 6.96 5.52 3.84 6.96 6.96 6.24 3.84 10.08 5.28 4.8 5.76 6.96 9.84 6.96 7.2 4.8 6.24 6.72 6.24 3.84 6.24 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% VectorCategory(a:Type)->OneDimensionalArrayAggregate(a:Type) +newpath 191 360 moveto +191 352 191 343 191 334 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 195 334 moveto +191 324 lineto +188 334 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 195 334 moveto +191 324 lineto +188 334 lineto +closepath +stroke +end grestore +% FiniteLinearAggregate(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 286 252 moveto +96 252 lineto +96 216 lineto +286 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 286 252 moveto +96 252 lineto +96 216 lineto +286 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +104 229 moveto +(FiniteLinearAggregate\(a:Type\)) +[7.44 3.84 6.96 3.84 3.84 6.24 8.64 3.84 6.96 6.24 6.24 4.8 9.84 6.96 7.2 4.8 6.24 6.72 6.24 3.84 6.24 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% OneDimensionalArrayAggregate(a:Type)->FiniteLinearAggregate(a:Type) +newpath 191 288 moveto +191 280 191 271 191 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 195 262 moveto +191 252 lineto +188 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 195 262 moveto +191 252 lineto +188 262 lineto +closepath +stroke +end grestore +% LinearAggregate(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 270 180 moveto +112 180 lineto +112 144 lineto +270 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 270 180 moveto +112 180 lineto +112 144 lineto +270 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +120 157 moveto +(LinearAggregate\(a:Type\)) +[8.64 3.84 6.96 6.24 6.24 4.8 9.84 6.96 7.2 4.8 6.24 6.72 6.24 3.84 6.24 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% FiniteLinearAggregate(a:Type)->LinearAggregate(a:Type) +newpath 191 216 moveto +191 208 191 199 191 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 195 190 moveto +191 180 lineto +188 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 195 190 moveto +191 180 lineto +188 190 lineto +closepath +stroke +end grestore +% IndexedAggregate(b:Integer,a:Type) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 218 108 moveto +0 108 lineto +0 72 lineto +218 72 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 218 108 moveto +0 108 lineto +0 72 lineto +218 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 85 moveto +(IndexedAggregate\(b:Integer,a:Type\)) +[4.56 6.96 6.96 5.76 6.48 6.24 6.96 9.84 6.96 7.2 4.8 6.24 6.72 6.24 3.84 6.24 4.56 6.96 3.84 4.56 6.96 3.84 6.24 6.72 6.24 4.32 3.6 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% LinearAggregate(a:Type)->IndexedAggregate(b:Integer,a:Type) +newpath 170 144 moveto +160 135 148 124 137 115 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 139 112 moveto +129 108 lineto +134 117 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 139 112 moveto +129 108 lineto +134 117 lineto +closepath +stroke +end grestore +% CLAGG... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 310 108 moveto +236 108 lineto +236 72 lineto +310 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 310 108 moveto +236 108 lineto +236 72 lineto +310 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +243 85 moveto +(CLAGG...) +[9.36 8.64 9.36 10.08 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% LinearAggregate(a:Type)->CLAGG... +newpath 212 144 moveto +222 135 234 124 245 115 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 248 117 moveto +253 108 lineto +243 112 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 248 117 moveto +253 108 lineto +243 112 lineto +closepath +stroke +end grestore +% IXAGG... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 145 36 moveto +73 36 lineto +73 0 lineto +145 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 145 36 moveto +73 36 lineto +73 0 lineto +145 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +80 13 moveto +(IXAGG...) +[4.56 10.08 9.36 10.08 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% IndexedAggregate(b:Integer,a:Type)->IXAGG... +newpath 109 72 moveto +109 64 109 55 109 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 113 46 moveto +109 36 lineto +106 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 113 46 moveto +109 36 lineto +106 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102regulartriangularsetcategory.ps b/books/ps/v102regulartriangularsetcategory.ps new file mode 100644 index 0000000..2e960b8 --- /dev/null +++ b/books/ps/v102regulartriangularsetcategory.ps @@ -0,0 +1,565 @@ +%!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 788 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 788 440 +%%PageOrientation: Portrait +gsave +36 36 752 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 +750 402 lineto +750 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 402 lineto +750 402 lineto +750 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% RegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 744 396 moveto +0 396 lineto +0 360 lineto +744 360 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 744 396 moveto +0 396 lineto +0 360 lineto +744 360 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 373 moveto +(RegularTriangularSetCategory\(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory\(a,b,c\)\)) +[9.12 6.24 6.96 6.96 3.84 6.24 4.8 7.92 5.04 3.84 6.24 6.96 6.96 6.96 3.84 6.24 4.8 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 6.24 3.84 10.08 6.24 6.96 10.08 6.96 10.8 6.24 3.84 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 3.6 6.96 3.84 9.12 6.24 6.24 6.96 4.8 5.52 3.84 6.48 6.24 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.6 6.96 3.6 6.24 4.56 4.56] +xshow +end grestore +end grestore +% TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 722 324 moveto +22 324 lineto +22 288 lineto +722 288 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 722 324 moveto +22 324 lineto +22 288 lineto +722 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +30 301 moveto +(TriangularSetCategory\(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory\(a,b,c\)\)) +[7.92 5.04 3.84 6.24 6.96 6.96 6.96 3.84 6.24 4.8 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 6.24 3.84 10.08 6.24 6.96 10.08 6.96 10.8 6.24 3.84 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 3.6 6.96 3.84 9.12 6.24 6.24 6.96 4.8 5.52 3.84 6.48 6.24 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.6 6.96 3.6 6.24 4.56 4.56] +xshow +end grestore +end grestore +% RegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +newpath 372 360 moveto +372 352 372 343 372 334 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 376 334 moveto +372 324 lineto +369 334 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 376 334 moveto +372 324 lineto +369 334 lineto +closepath +stroke +end grestore +% TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 732 252 moveto +12 252 lineto +12 216 lineto +732 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 732 252 moveto +12 252 lineto +12 216 lineto +732 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +20 229 moveto +(TriangularSetCategory\(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory\(a,b,c\)\)) +[7.92 5.04 3.84 6.24 6.96 6.96 6.96 3.84 6.24 4.8 7.68 6 3.84 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 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 3.6 6.96 3.84 9.12 6.24 6.24 6.96 4.8 5.52 3.84 6.48 6.24 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.6 6.96 3.6 6.24 4.56 4.56] +xshow +end grestore +end grestore +% TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +newpath 372 288 moveto +372 280 372 271 372 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 376 262 moveto +372 252 lineto +369 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 376 262 moveto +372 252 lineto +369 262 lineto +closepath +stroke +end grestore +% PolynomialSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 735 180 moveto +9 180 lineto +9 144 lineto +735 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 735 180 moveto +9 180 lineto +9 144 lineto +735 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +17 157 moveto +(PolynomialSetCategory\(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory\(a,b,c\)\)) +[7.44 6.96 3.6 6.96 6.96 6.96 10.8 3.84 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 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 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 3.6 6.96 3.84 9.12 6.24 6.24 6.96 4.8 5.52 3.84 6.48 6.24 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.6 6.96 3.6 6.24 4.56 4.56] +xshow +end grestore +end grestore +% TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->PolynomialSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +newpath 372 216 moveto +372 208 372 199 372 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 376 190 moveto +372 180 lineto +369 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 376 190 moveto +372 180 lineto +369 190 lineto +closepath +stroke +end grestore +% PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 704 108 moveto +40 108 lineto +40 72 lineto +704 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 704 108 moveto +40 108 lineto +40 72 lineto +704 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +48 85 moveto +(PolynomialSetCategory\(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory\(a,b,c\)\)) +[7.44 6.96 3.6 6.96 6.96 6.96 10.8 3.84 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 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 3.6 6.96 3.84 9.12 6.24 6.24 6.96 4.8 5.52 3.84 6.48 6.24 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.6 6.96 3.6 6.24 4.56 4.56] +xshow +end grestore +end grestore +% PolynomialSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +newpath 372 144 moveto +372 136 372 127 372 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 376 118 moveto +372 108 lineto +369 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 376 118 moveto +372 108 lineto +369 118 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 317 36 moveto +239 36 lineto +239 0 lineto +317 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 317 36 moveto +239 36 lineto +239 0 lineto +317 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +247 13 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 +% PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->SETCAT... +newpath 348 72 moveto +337 63 322 52 309 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 311 39 moveto +301 36 lineto +307 45 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 311 39 moveto +301 36 lineto +307 45 lineto +closepath +stroke +end grestore +% CLAGG... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 409 36 moveto +335 36 lineto +335 0 lineto +409 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 409 36 moveto +335 36 lineto +335 0 lineto +409 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +342 13 moveto +(CLAGG...) +[9.36 8.64 9.36 10.08 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->CLAGG... +newpath 372 72 moveto +372 64 372 55 372 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 376 46 moveto +372 36 lineto +369 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 376 46 moveto +372 36 lineto +369 46 lineto +closepath +stroke +end grestore +% KOERCE... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 509 36 moveto +427 36 lineto +427 0 lineto +509 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 509 36 moveto +427 36 lineto +427 0 lineto +509 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +434 13 moveto +(KOERCE...) +[9.12 10.08 8.64 8.88 9.36 8.64 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->KOERCE... +newpath 396 72 moveto +408 63 423 52 436 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 438 45 moveto +444 36 lineto +434 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 438 45 moveto +444 36 lineto +434 39 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102squarefreeregulartriangularsetcategory.ps b/books/ps/v102squarefreeregulartriangularsetcategory.ps new file mode 100644 index 0000000..27496c2 --- /dev/null +++ b/books/ps/v102squarefreeregulartriangularsetcategory.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 850 512 +%%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 850 512 +%%PageOrientation: Portrait +gsave +36 36 814 476 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 474 lineto +812 474 lineto +812 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 474 lineto +812 474 lineto +812 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% SquareFreeRegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 806 468 moveto +0 468 lineto +0 432 lineto +806 432 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 806 468 moveto +0 468 lineto +0 432 lineto +806 432 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 445 moveto +(SquareFreeRegularTriangularSetCategory\(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory\(a,b,c\)\)) +[7.68 6.72 6.96 6.24 4.8 6.24 7.44 4.8 6.24 6.24 9.12 6.24 6.96 6.96 3.84 6.24 4.8 7.92 5.04 3.84 6.24 6.96 6.96 6.96 3.84 6.24 4.8 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 6.24 3.84 10.08 6.24 6.96 10.08 6.96 10.8 6.24 3.84 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 3.6 6.96 3.84 9.12 6.24 6.24 6.96 4.8 5.52 3.84 6.48 6.24 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.6 6.96 3.6 6.24 4.56 4.56] +xshow +end grestore +end grestore +% RegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 775 396 moveto +31 396 lineto +31 360 lineto +775 360 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 775 396 moveto +31 396 lineto +31 360 lineto +775 360 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +39 373 moveto +(RegularTriangularSetCategory\(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory\(a,b,c\)\)) +[9.12 6.24 6.96 6.96 3.84 6.24 4.8 7.92 5.04 3.84 6.24 6.96 6.96 6.96 3.84 6.24 4.8 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 6.24 3.84 10.08 6.24 6.96 10.08 6.96 10.8 6.24 3.84 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 3.6 6.96 3.84 9.12 6.24 6.24 6.96 4.8 5.52 3.84 6.48 6.24 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.6 6.96 3.6 6.24 4.56 4.56] +xshow +end grestore +end grestore +% SquareFreeRegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->RegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +newpath 403 432 moveto +403 424 403 415 403 406 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 407 406 moveto +403 396 lineto +400 406 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 407 406 moveto +403 396 lineto +400 406 lineto +closepath +stroke +end grestore +% TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 753 324 moveto +53 324 lineto +53 288 lineto +753 288 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 753 324 moveto +53 324 lineto +53 288 lineto +753 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +61 301 moveto +(TriangularSetCategory\(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory\(a,b,c\)\)) +[7.92 5.04 3.84 6.24 6.96 6.96 6.96 3.84 6.24 4.8 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 6.24 3.84 10.08 6.24 6.96 10.08 6.96 10.8 6.24 3.84 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 3.6 6.96 3.84 9.12 6.24 6.24 6.96 4.8 5.52 3.84 6.48 6.24 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.6 6.96 3.6 6.24 4.56 4.56] +xshow +end grestore +end grestore +% RegularTriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +newpath 403 360 moveto +403 352 403 343 403 334 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 407 334 moveto +403 324 lineto +400 334 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 407 334 moveto +403 324 lineto +400 334 lineto +closepath +stroke +end grestore +% TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 763 252 moveto +43 252 lineto +43 216 lineto +763 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 763 252 moveto +43 252 lineto +43 216 lineto +763 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +51 229 moveto +(TriangularSetCategory\(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory\(a,b,c\)\)) +[7.92 5.04 3.84 6.24 6.96 6.96 6.96 3.84 6.24 4.8 7.68 6 3.84 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 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 3.6 6.96 3.84 9.12 6.24 6.24 6.96 4.8 5.52 3.84 6.48 6.24 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.6 6.96 3.6 6.24 4.56 4.56] +xshow +end grestore +end grestore +% TriangularSetCategory(a:GcdDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +newpath 403 288 moveto +403 280 403 271 403 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 407 262 moveto +403 252 lineto +400 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 407 262 moveto +403 252 lineto +400 262 lineto +closepath +stroke +end grestore +% PolynomialSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 766 180 moveto +40 180 lineto +40 144 lineto +766 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 766 180 moveto +40 180 lineto +40 144 lineto +766 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +48 157 moveto +(PolynomialSetCategory\(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory\(a,b,c\)\)) +[7.44 6.96 3.6 6.96 6.96 6.96 10.8 3.84 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 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 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 3.6 6.96 3.84 9.12 6.24 6.24 6.96 4.8 5.52 3.84 6.48 6.24 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.6 6.96 3.6 6.24 4.56 4.56] +xshow +end grestore +end grestore +% TriangularSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->PolynomialSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +newpath 403 216 moveto +403 208 403 199 403 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 407 190 moveto +403 180 lineto +400 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 407 190 moveto +403 180 lineto +400 190 lineto +closepath +stroke +end grestore +% PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 735 108 moveto +71 108 lineto +71 72 lineto +735 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 735 108 moveto +71 108 lineto +71 72 lineto +735 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +79 85 moveto +(PolynomialSetCategory\(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory\(a,b,c\)\)) +[7.44 6.96 3.6 6.96 6.96 6.96 10.8 3.84 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 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 3.6 6.96 3.84 9.12 6.24 6.24 6.96 4.8 5.52 3.84 6.48 6.24 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.6 6.96 3.6 6.24 4.56 4.56] +xshow +end grestore +end grestore +% PolynomialSetCategory(a:IntegralDomain,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c)) +newpath 403 144 moveto +403 136 403 127 403 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 407 118 moveto +403 108 lineto +400 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 407 118 moveto +403 108 lineto +400 118 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 348 36 moveto +270 36 lineto +270 0 lineto +348 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 348 36 moveto +270 36 lineto +270 0 lineto +348 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +278 13 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 +% PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->SETCAT... +newpath 379 72 moveto +368 63 353 52 340 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 342 39 moveto +332 36 lineto +338 45 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 342 39 moveto +332 36 lineto +338 45 lineto +closepath +stroke +end grestore +% CLAGG... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 440 36 moveto +366 36 lineto +366 0 lineto +440 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 440 36 moveto +366 36 lineto +366 0 lineto +440 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +373 13 moveto +(CLAGG...) +[9.36 8.64 9.36 10.08 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->CLAGG... +newpath 403 72 moveto +403 64 403 55 403 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 407 46 moveto +403 36 lineto +400 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 407 46 moveto +403 36 lineto +400 46 lineto +closepath +stroke +end grestore +% KOERCE... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 540 36 moveto +458 36 lineto +458 0 lineto +540 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 540 36 moveto +458 36 lineto +458 0 lineto +540 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +465 13 moveto +(KOERCE...) +[9.12 10.08 8.64 8.88 9.36 8.64 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PolynomialSetCategory(a:Ring,b:OrderedAbelianMonoidSup,c:OrderedSet,d:RecursivePolynomialCategory(a,b,c))->KOERCE... +newpath 427 72 moveto +439 63 454 52 467 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 469 45 moveto +475 36 lineto +465 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 469 45 moveto +475 36 lineto +465 39 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102univariatelaurentseriesconstructorcategory.ps b/books/ps/v102univariatelaurentseriesconstructorcategory.ps new file mode 100644 index 0000000..6172da1 --- /dev/null +++ b/books/ps/v102univariatelaurentseriesconstructorcategory.ps @@ -0,0 +1,657 @@ +%!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 797 512 +%%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 797 512 +%%PageOrientation: Portrait +gsave +36 36 761 476 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 474 lineto +759 474 lineto +759 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 474 lineto +759 474 lineto +759 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% UnivariateLaurentSeriesConstructorCategory(a:Ring,b:UnivariateTaylorSeriesCategory(Ring)) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 753 468 moveto +205 468 lineto +205 432 lineto +753 432 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 753 468 moveto +205 468 lineto +205 432 lineto +753 432 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +212 445 moveto +(UnivariateLaurentSeriesConstructorCategory\(a:Ring,b:UnivariateTaylorSeriesCategory\(Ring\)\)) +[9.6 6.96 3.84 6.72 6.24 5.04 3.84 6.24 3.84 6.24 8.64 6.24 6.96 4.8 6.24 6.96 3.84 7.68 6.24 5.04 3.84 6.24 5.52 9.36 6.96 6.96 5.28 3.84 5.04 6.96 6.24 3.84 6.96 4.8 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 9.6 6.96 3.84 6.72 6.24 5.04 3.84 6.24 3.84 6.24 7.68 5.76 6.48 3.84 6.96 4.8 7.68 6.24 5.04 3.84 6.24 5.52 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 9.36 3.84 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% UnivariateLaurentSeriesCategory(a:Ring) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 605 396 moveto +353 396 lineto +353 360 lineto +605 360 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 605 396 moveto +353 396 lineto +353 360 lineto +605 360 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +361 373 moveto +(UnivariateLaurentSeriesCategory\(a:Ring\)) +[9.6 6.96 3.84 6.72 6.24 5.04 3.84 6.24 3.84 6.24 8.64 6.24 6.96 4.8 6.24 6.96 3.84 7.68 6.24 5.04 3.84 6.24 5.52 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 4.56] +xshow +end grestore +end grestore +% UnivariateLaurentSeriesConstructorCategory(a:Ring,b:UnivariateTaylorSeriesCategory(Ring))->UnivariateLaurentSeriesCategory(a:Ring) +newpath 479 432 moveto +479 424 479 415 479 406 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 483 406 moveto +479 396 lineto +476 406 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 483 406 moveto +479 396 lineto +476 406 lineto +closepath +stroke +end grestore +% UnivariatePowerSeriesCategory(a:Ring,Integer) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 382 324 moveto +96 324 lineto +96 288 lineto +382 288 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 382 324 moveto +96 324 lineto +96 288 lineto +382 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +104 301 moveto +(UnivariatePowerSeriesCategory\(a:Ring,Integer\)) +[9.6 6.96 3.84 6.72 6.24 5.04 3.84 6.24 3.84 6.24 7.44 6.48 9.6 6.24 4.8 7.68 6.24 5.04 3.84 6.24 5.52 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 4.56 6.96 3.84 6.24 6.72 6.24 4.8 4.56] +xshow +end grestore +end grestore +% UnivariateLaurentSeriesCategory(a:Ring)->UnivariatePowerSeriesCategory(a:Ring,Integer) +newpath 419 360 moveto +385 350 344 337 309 327 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 310 324 moveto +299 324 lineto +308 330 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 310 324 moveto +299 324 lineto +308 330 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 466 324 moveto +400 324 lineto +400 288 lineto +466 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 466 324 moveto +400 324 lineto +400 288 lineto +466 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +407 301 moveto +(FIELD...) +[7.68 4.56 8.64 8.64 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% UnivariateLaurentSeriesCategory(a:Ring)->FIELD... +newpath 467 360 moveto +462 352 455 342 449 332 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 452 331 moveto +444 324 lineto +446 334 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 452 331 moveto +444 324 lineto +446 334 lineto +closepath +stroke +end grestore +% RADCAT... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 566 324 moveto +484 324 lineto +484 288 lineto +566 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 566 324 moveto +484 324 lineto +484 288 lineto +566 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +491 301 moveto +(RADCAT...) +[9.36 10.08 10.08 9.12 9.36 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% UnivariateLaurentSeriesCategory(a:Ring)->RADCAT... +newpath 491 360 moveto +496 352 503 342 509 332 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 512 334 moveto +514 324 lineto +506 331 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 512 334 moveto +514 324 lineto +506 331 lineto +closepath +stroke +end grestore +% TRANFUN... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 676 324 moveto +584 324 lineto +584 288 lineto +676 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 676 324 moveto +584 324 lineto +584 288 lineto +676 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +591 301 moveto +(TRANFUN...) +[8.64 9.36 10.08 10.08 7.68 10.08 9.84 3.6 3.6 3.6] +xshow +end grestore +end grestore +% UnivariateLaurentSeriesCategory(a:Ring)->TRANFUN... +newpath 517 360 moveto +537 350 562 339 583 329 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 585 332 moveto +592 324 lineto +582 326 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 585 332 moveto +592 324 lineto +582 326 lineto +closepath +stroke +end grestore +% UnivariatePowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 435 252 moveto +43 252 lineto +43 216 lineto +435 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 435 252 moveto +43 252 lineto +43 216 lineto +435 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +51 229 moveto +(UnivariatePowerSeriesCategory\(a:Ring,b:OrderedAbelianMonoid\)) +[9.6 6.96 3.84 6.72 6.24 5.04 3.84 6.24 3.84 6.24 7.44 6.48 9.6 6.24 4.8 7.68 6.24 5.04 3.84 6.24 5.52 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 4.56] +xshow +end grestore +end grestore +% UnivariatePowerSeriesCategory(a:Ring,Integer)->UnivariatePowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid) +newpath 239 288 moveto +239 280 239 271 239 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 243 262 moveto +239 252 lineto +236 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 243 262 moveto +239 252 lineto +236 262 lineto +closepath +stroke +end grestore +% PowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid,c:SingletonAsOrderedSet) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 478 180 moveto +0 180 lineto +0 144 lineto +478 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 478 180 moveto +0 180 lineto +0 144 lineto +478 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 157 moveto +(PowerSeriesCategory\(a:Ring,b:OrderedAbelianMonoid,c:SingletonAsOrderedSet\)) +[7.44 6.48 9.6 6.24 4.8 7.68 6.24 5.04 3.84 6.24 5.52 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 3.6 6.24 3.84 7.68 3.84 6.96 6.96 3.84 6 3.84 6.96 6.96 10.08 5.52 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 +% UnivariatePowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid)->PowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid,c:SingletonAsOrderedSet) +newpath 239 216 moveto +239 208 239 199 239 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 243 190 moveto +239 180 lineto +236 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 243 190 moveto +239 180 lineto +236 190 lineto +closepath +stroke +end grestore +% PowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid,c:OrderedSet) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 444 108 moveto +34 108 lineto +34 72 lineto +444 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 444 108 moveto +34 108 lineto +34 72 lineto +444 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +42 85 moveto +(PowerSeriesCategory\(a:Ring,b:OrderedAbelianMonoid,c:OrderedSet\)) +[7.44 6.48 9.6 6.24 4.8 7.68 6.24 5.04 3.84 6.24 5.52 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 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 +% PowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid,c:SingletonAsOrderedSet)->PowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid,c:OrderedSet) +newpath 239 144 moveto +239 136 239 127 239 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 243 118 moveto +239 108 lineto +236 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 243 118 moveto +239 108 lineto +236 118 lineto +closepath +stroke +end grestore +% AMR... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 269 36 moveto +209 36 lineto +209 0 lineto +269 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 269 36 moveto +209 36 lineto +209 0 lineto +269 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +217 13 moveto +(AMR...) +[10.08 12.48 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% PowerSeriesCategory(a:Ring,b:OrderedAbelianMonoid,c:OrderedSet)->AMR... +newpath 239 72 moveto +239 64 239 55 239 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 243 46 moveto +239 36 lineto +236 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 243 46 moveto +239 36 lineto +236 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/changelog b/changelog index b27501e..d95f312 100644 --- a/changelog +++ b/changelog @@ -1,3 +1,12 @@ +20081109 tpd books/bookvol10.2 add categories +20081109 tpd books/ps/v102squarefreeregulartriangularsetcategory.ps added +20081109 tpd src/algebra/sregset.spad.pamphlet move SFRTCAT to bookvol10.2 +20081109 tpd books/ps/v102regulartriangularsetcategory.ps added +20081109 tpd src/algebra/regset.spad add RSETCAT to bookvol10.2 +20081109 tpd books/ps/v102univariatelaurentseriesconstructorcategory.ps added +20081109 tpd src/algebra/laurent.spad move ULSCCAT to bookvol10.2 +20081109 tpd books/ps/v102algebraicallyclosedfunctionspace.ps added +20081109 tpd src/algebra/algfunc.spad move ACFS to bookvol10.2 20081108 tpd books/ps/v102integernumbersystem.ps added 20081108 tpd src/algebra/si.spad move INS to bookvol10.2 20081108 tpd books/ps/v102permutationcategory.ps added diff --git a/src/algebra/algfunc.spad.pamphlet b/src/algebra/algfunc.spad.pamphlet index 75dcfa0..22f5e49 100644 --- a/src/algebra/algfunc.spad.pamphlet +++ b/src/algebra/algfunc.spad.pamphlet @@ -9,110 +9,6 @@ \eject \tableofcontents \eject -\section{category ACFS AlgebraicallyClosedFunctionSpace} -<>= -)abbrev category ACFS AlgebraicallyClosedFunctionSpace -++ Author: Manuel Bronstein -++ Date Created: 31 October 1988 -++ Date Last Updated: 7 October 1991 -++ Description: -++ Model for algebraically closed function spaces. -++ Keywords: algebraic, closure, field. -AlgebraicallyClosedFunctionSpace(R:Join(OrderedSet, IntegralDomain)): - Category == Join(AlgebraicallyClosedField, FunctionSpace R) with - rootOf : $ -> $ - ++ rootOf(p) returns y such that \spad{p(y) = 0}. - ++ Error: if p has more than one variable y. - rootsOf: $ -> List $ - ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}; - ++ Note: the returned symbols y1,...,yn are bound in the interpreter - ++ to respective root values. - ++ Error: if p has more than one variable y. - rootOf : ($, Symbol) -> $ - ++ rootOf(p,y) returns y such that \spad{p(y) = 0}. - ++ The object returned displays as \spad{'y}. - rootsOf: ($, Symbol) -> List $ - ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}; - ++ The returned roots display as \spad{'y1},...,\spad{'yn}. - ++ Note: the returned symbols y1,...,yn are bound in the interpreter - ++ to respective root values. - zeroOf : $ -> $ - ++ zeroOf(p) returns y such that \spad{p(y) = 0}. - ++ The value y is expressed in terms of radicals if possible,and otherwise - ++ as an implicit algebraic quantity. - ++ Error: if p has more than one variable. - zerosOf: $ -> List $ - ++ zerosOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. - ++ The yi's are expressed in radicals if possible. - ++ The returned symbols y1,...,yn are bound in the interpreter - ++ to respective root values. - ++ Error: if p has more than one variable. - zeroOf : ($, Symbol) -> $ - ++ zeroOf(p, y) returns y such that \spad{p(y) = 0}. - ++ The value y is expressed in terms of radicals if possible,and otherwise - ++ as an implicit algebraic quantity - ++ which displays as \spad{'y}. - zerosOf: ($, Symbol) -> List $ - ++ zerosOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. - ++ The yi's are expressed in radicals if possible, and otherwise - ++ as implicit algebraic quantities - ++ which display as \spad{'yi}. - ++ The returned symbols y1,...,yn are bound in the interpreter - ++ to respective root values. - add - rootOf(p:$) == - empty?(l := variables p) => error "rootOf: constant expression" - rootOf(p, first l) - - rootsOf(p:$) == - empty?(l := variables p) => error "rootsOf: constant expression" - rootsOf(p, first l) - - zeroOf(p:$) == - empty?(l := variables p) => error "zeroOf: constant expression" - zeroOf(p, first l) - - zerosOf(p:$) == - empty?(l := variables p) => error "zerosOf: constant expression" - zerosOf(p, first l) - - zeroOf(p:$, x:Symbol) == - n := numer(f := univariate(p, kernel(x)$Kernel($))) - degree denom f > 0 => error "zeroOf: variable appears in denom" - degree n = 0 => error "zeroOf: constant expression" - zeroOf(n, x) - - rootOf(p:$, x:Symbol) == - n := numer(f := univariate(p, kernel(x)$Kernel($))) - degree denom f > 0 => error "roofOf: variable appears in denom" - degree n = 0 => error "rootOf: constant expression" - rootOf(n, x) - - zerosOf(p:$, x:Symbol) == - n := numer(f := univariate(p, kernel(x)$Kernel($))) - degree denom f > 0 => error "zerosOf: variable appears in denom" - degree n = 0 => empty() - zerosOf(n, x) - - rootsOf(p:$, x:Symbol) == - n := numer(f := univariate(p, kernel(x)$Kernel($))) - degree denom f > 0 => error "roofsOf: variable appears in denom" - degree n = 0 => empty() - rootsOf(n, x) - - rootsOf(p:SparseUnivariatePolynomial $, y:Symbol) == - (r := retractIfCan(p)@Union($,"failed")) case $ => rootsOf(r::$,y) - rootsOf(p, y)$AlgebraicallyClosedField_&($) - - zerosOf(p:SparseUnivariatePolynomial $, y:Symbol) == - (r := retractIfCan(p)@Union($,"failed")) case $ => zerosOf(r::$,y) - zerosOf(p, y)$AlgebraicallyClosedField_&($) - - zeroOf(p:SparseUnivariatePolynomial $, y:Symbol) == - (r := retractIfCan(p)@Union($,"failed")) case $ => zeroOf(r::$, y) - zeroOf(p, y)$AlgebraicallyClosedField_&($) - -@ \section{package AF AlgebraicFunction} \subsection{hackroot(x, n)} This used to read: @@ -427,7 +323,6 @@ AlgebraicFunction(R, F): Exports == Implementation where -- -- op kl fspace ALGFUNC expr -<> <> @ \eject diff --git a/src/algebra/laurent.spad.pamphlet b/src/algebra/laurent.spad.pamphlet index ab0417c..392407d 100644 --- a/src/algebra/laurent.spad.pamphlet +++ b/src/algebra/laurent.spad.pamphlet @@ -9,81 +9,6 @@ \eject \tableofcontents \eject -\section{category ULSCCAT UnivariateLaurentSeriesConstructorCategory} -<>= -)abbrev category ULSCCAT UnivariateLaurentSeriesConstructorCategory -++ Author: Clifton J. Williamson -++ Date Created: 6 February 1990 -++ Date Last Updated: 10 May 1990 -++ Basic Operations: -++ Related Domains: -++ Also See: -++ AMS Classifications: -++ Keywords: series, Laurent, Taylor -++ Examples: -++ References: -++ Description: -++ This is a category of univariate Laurent series constructed from -++ univariate Taylor series. A Laurent series is represented by a pair -++ \spad{[n,f(x)]}, where n is an arbitrary integer and \spad{f(x)} -++ is a Taylor series. This pair represents the Laurent series -++ \spad{x**n * f(x)}. -UnivariateLaurentSeriesConstructorCategory(Coef,UTS):_ - Category == Definition where - Coef: Ring - UTS : UnivariateTaylorSeriesCategory Coef - I ==> Integer - - Definition ==> Join(UnivariateLaurentSeriesCategory(Coef),_ - RetractableTo UTS) with - laurent: (I,UTS) -> % - ++ \spad{laurent(n,f(x))} returns \spad{x**n * f(x)}. - degree: % -> I - ++ \spad{degree(f(x))} returns the degree of the lowest order term of - ++ \spad{f(x)}, which may have zero as a coefficient. - taylorRep: % -> UTS - ++ \spad{taylorRep(f(x))} returns \spad{g(x)}, where - ++ \spad{f = x**n * g(x)} is represented by \spad{[n,g(x)]}. - removeZeroes: % -> % - ++ \spad{removeZeroes(f(x))} removes leading zeroes from the - ++ representation of the Laurent series \spad{f(x)}. - ++ A Laurent series is represented by (1) an exponent and - ++ (2) a Taylor series which may have leading zero coefficients. - ++ When the Taylor series has a leading zero coefficient, the - ++ 'leading zero' is removed from the Laurent series as follows: - ++ the series is rewritten by increasing the exponent by 1 and - ++ dividing the Taylor series by its variable. - ++ Note: \spad{removeZeroes(f)} removes all leading zeroes from f - removeZeroes: (I,%) -> % - ++ \spad{removeZeroes(n,f(x))} removes up to n leading zeroes from - ++ the Laurent series \spad{f(x)}. - ++ A Laurent series is represented by (1) an exponent and - ++ (2) a Taylor series which may have leading zero coefficients. - ++ When the Taylor series has a leading zero coefficient, the - ++ 'leading zero' is removed from the Laurent series as follows: - ++ the series is rewritten by increasing the exponent by 1 and - ++ dividing the Taylor series by its variable. - coerce: UTS -> % - ++ \spad{coerce(f(x))} converts the Taylor series \spad{f(x)} to a - ++ Laurent series. - taylor: % -> UTS - ++ taylor(f(x)) converts the Laurent series f(x) to a Taylor series, - ++ if possible. Error: if this is not possible. - taylorIfCan: % -> Union(UTS,"failed") - ++ \spad{taylorIfCan(f(x))} converts the Laurent series \spad{f(x)} - ++ to a Taylor series, if possible. If this is not possible, - ++ "failed" is returned. - if Coef has Field then QuotientFieldCategory(UTS) - --++ the quotient field of univariate Taylor series over a field is - --++ the field of Laurent series - - add - - zero? x == zero? taylorRep x - retract(x:%):UTS == taylor x - retractIfCan(x:%):Union(UTS,"failed") == taylorIfCan x - -@ \section{domain ULSCONS UnivariateLaurentSeriesConstructor} <>= )abbrev domain ULSCONS UnivariateLaurentSeriesConstructor @@ -666,7 +591,6 @@ UnivariateLaurentSeriesFunctions2(Coef1,Coef2,var1,var2,cen1,cen2):_ <<*>>= <> -<> <> <> <> diff --git a/src/algebra/polset.spad.pamphlet b/src/algebra/polset.spad.pamphlet index 4e21255..d6aac5b 100644 --- a/src/algebra/polset.spad.pamphlet +++ b/src/algebra/polset.spad.pamphlet @@ -9,452 +9,6 @@ \eject \tableofcontents \eject -\section{category PSETCAT PolynomialSetCategory} -<>= -)abbrev category PSETCAT PolynomialSetCategory -++ Author: Marc Moreno Maza -++ Date Created: 04/26/1994 -++ Date Last Updated: 12/15/1998 -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: polynomial, multivariate, ordered variables set -++ References: -++ Description: A category for finite subsets of a polynomial ring. -++ Such a set is only regarded as a set of polynomials and not -++ identified to the ideal it generates. So two distinct sets may -++ generate the same the ideal. Furthermore, for \spad{R} being an -++ integral domain, a set of polynomials may be viewed as a representation -++ of the ideal it generates in the polynomial ring \spad{(R)^(-1) P}, -++ or the set of its zeros (described for instance by the radical of the -++ previous ideal, or a split of the associated affine variety) and so on. -++ So this category provides operations about those different notions. -++ Version: 2 - -PolynomialSetCategory(R:Ring, E:OrderedAbelianMonoidSup,_ - VarSet:OrderedSet, P:RecursivePolynomialCategory(R,E,VarSet)): Category == - Join(SetCategory,Collection(P),CoercibleTo(List(P))) with - finiteAggregate - retractIfCan : List(P) -> Union($,"failed") - ++ \axiom{retractIfCan(lp)} returns an element of the domain whose elements - ++ are the members of \axiom{lp} if such an element exists, otherwise - ++ \axiom{"failed"} is returned. - retract : List(P) -> $ - ++ \axiom{retract(lp)} returns an element of the domain whose elements - ++ are the members of \axiom{lp} if such an element exists, otherwise - ++ an error is produced. - mvar : $ -> VarSet - ++ \axiom{mvar(ps)} returns the main variable of the non constant polynomial - ++ with the greatest main variable, if any, else an error is returned. - variables : $ -> List VarSet - ++ \axiom{variables(ps)} returns the decreasingly sorted list of the - ++ variables which are variables of some polynomial in \axiom{ps}. - mainVariables : $ -> List VarSet - ++ \axiom{mainVariables(ps)} returns the decreasingly sorted list of the - ++ variables which are main variables of some polynomial in \axiom{ps}. - mainVariable? : (VarSet,$) -> Boolean - ++ \axiom{mainVariable?(v,ps)} returns true iff \axiom{v} is the main variable - ++ of some polynomial in \axiom{ps}. - collectUnder : ($,VarSet) -> $ - ++ \axiom{collectUnder(ps,v)} returns the set consisting of the - ++ polynomials of \axiom{ps} with main variable less than \axiom{v}. - collect : ($,VarSet) -> $ - ++ \axiom{collect(ps,v)} returns the set consisting of the - ++ polynomials of \axiom{ps} with \axiom{v} as main variable. - collectUpper : ($,VarSet) -> $ - ++ \axiom{collectUpper(ps,v)} returns the set consisting of the - ++ polynomials of \axiom{ps} with main variable greater than \axiom{v}. - sort : ($,VarSet) -> Record(under:$,floor:$,upper:$) - ++ \axiom{sort(v,ps)} returns \axiom{us,vs,ws} such that \axiom{us} - ++ is \axiom{collectUnder(ps,v)}, \axiom{vs} is \axiom{collect(ps,v)} - ++ and \axiom{ws} is \axiom{collectUpper(ps,v)}. - trivialIdeal?: $ -> Boolean - ++ \axiom{trivialIdeal?(ps)} returns true iff \axiom{ps} does - ++ not contain non-zero elements. - if R has IntegralDomain - then - roughBase? : $ -> Boolean - ++ \axiom{roughBase?(ps)} returns true iff for every pair \axiom{{p,q}} - ++ of polynomials in \axiom{ps} their leading monomials are - ++ relatively prime. - roughSubIdeal? : ($,$) -> Boolean - ++ \axiom{roughSubIdeal?(ps1,ps2)} returns true iff it can proved - ++ that all polynomials in \axiom{ps1} lie in the ideal generated by - ++ \axiom{ps2} in \axiom{\axiom{(R)^(-1) P}} without computing Groebner bases. - roughEqualIdeals? : ($,$) -> Boolean - ++ \axiom{roughEqualIdeals?(ps1,ps2)} returns true iff it can - ++ proved that \axiom{ps1} and \axiom{ps2} generate the same ideal - ++ in \axiom{(R)^(-1) P} without computing Groebner bases. - roughUnitIdeal? : $ -> Boolean - ++ \axiom{roughUnitIdeal?(ps)} returns true iff \axiom{ps} contains some - ++ non null element lying in the base ring \axiom{R}. - headRemainder : (P,$) -> Record(num:P,den:R) - ++ \axiom{headRemainder(a,ps)} returns \axiom{[b,r]} such that the leading - ++ monomial of \axiom{b} is reduced in the sense of Groebner bases w.r.t. - ++ \axiom{ps} and \axiom{r*a - b} lies in the ideal generated by \axiom{ps}. - remainder : (P,$) -> Record(rnum:R,polnum:P,den:R) - ++ \axiom{remainder(a,ps)} returns \axiom{[c,b,r]} such that \axiom{b} is fully - ++ reduced in the sense of Groebner bases w.r.t. \axiom{ps}, - ++ \axiom{r*a - c*b} lies in the ideal generated by \axiom{ps}. - ++ Furthermore, if \axiom{R} is a gcd-domain, \axiom{b} is primitive. - rewriteIdealWithHeadRemainder : (List(P),$) -> List(P) - ++ \axiom{rewriteIdealWithHeadRemainder(lp,cs)} returns \axiom{lr} such that - ++ the leading monomial of every polynomial in \axiom{lr} is reduced - ++ in the sense of Groebner bases w.r.t. \axiom{cs} and \axiom{(lp,cs)} - ++ and \axiom{(lr,cs)} generate the same ideal in \axiom{(R)^(-1) P}. - rewriteIdealWithRemainder : (List(P),$) -> List(P) - ++ \axiom{rewriteIdealWithRemainder(lp,cs)} returns \axiom{lr} such that - ++ every polynomial in \axiom{lr} is fully reduced in the sense - ++ of Groebner bases w.r.t. \axiom{cs} and \axiom{(lp,cs)} and - ++ \axiom{(lr,cs)} generate the same ideal in \axiom{(R)^(-1) P}. - triangular? : $ -> Boolean - ++ \axiom{triangular?(ps)} returns true iff \axiom{ps} is a triangular set, - ++ i.e. two distinct polynomials have distinct main variables - ++ and no constant lies in \axiom{ps}. - - add - - NNI ==> NonNegativeInteger - B ==> Boolean - - elements: $ -> List(P) - - elements(ps:$):List(P) == - lp : List(P) := members(ps)$$ - - variables1(lp:List(P)):(List VarSet) == - lvars : List(List(VarSet)) := [variables(p)$P for p in lp] - sort(#1 > #2, removeDuplicates(concat(lvars)$List(VarSet))) - - variables2(lp:List(P)):(List VarSet) == - lvars : List(VarSet) := [mvar(p)$P for p in lp] - sort(#1 > #2, removeDuplicates(lvars)$List(VarSet)) - - variables (ps:$) == - variables1(elements(ps)) - - mainVariables (ps:$) == - variables2(remove(ground?,elements(ps))) - - mainVariable? (v,ps) == - lp : List(P) := remove(ground?,elements(ps)) - while (not empty? lp) and (not (mvar(first(lp)) = v)) repeat - lp := rest lp - (not empty? lp) - - collectUnder (ps,v) == - lp : List P := elements(ps) - lq : List P := [] - while (not empty? lp) repeat - p := first lp - lp := rest lp - if (ground?(p)) or (mvar(p) < v) - then - lq := cons(p,lq) - construct(lq)$$ - - collectUpper (ps,v) == - lp : List P := elements(ps) - lq : List P := [] - while (not empty? lp) repeat - p := first lp - lp := rest lp - if (not ground?(p)) and (mvar(p) > v) - then - lq := cons(p,lq) - construct(lq)$$ - - collect (ps,v) == - lp : List P := elements(ps) - lq : List P := [] - while (not empty? lp) repeat - p := first lp - lp := rest lp - if (not ground?(p)) and (mvar(p) = v) - then - lq := cons(p,lq) - construct(lq)$$ - - sort (ps,v) == - lp : List P := elements(ps) - us : List P := [] - vs : List P := [] - ws : List P := [] - while (not empty? lp) repeat - p := first lp - lp := rest lp - if (ground?(p)) or (mvar(p) < v) - then - us := cons(p,us) - else - if (mvar(p) = v) - then - vs := cons(p,vs) - else - ws := cons(p,ws) - [construct(us)$$,construct(vs)$$,construct(ws)$$]$Record(under:$,floor:$,upper:$) - - ps1 = ps2 == - {p for p in elements(ps1)} =$(Set P) {p for p in elements(ps2)} - - exactQuo : (R,R) -> R - - localInf? (p:P,q:P):B == - degree(p) <$E degree(q) - - localTriangular? (lp:List(P)):B == - lp := remove(zero?, lp) - empty? lp => true - any? (ground?, lp) => false - lp := sort(mvar(#1)$P > mvar(#2)$P, lp) - p,q : P - p := first lp - lp := rest lp - while (not empty? lp) and (mvar(p) > mvar((q := first(lp)))) repeat - p := q - lp := rest lp - empty? lp - - triangular? ps == - localTriangular? elements ps - - trivialIdeal? ps == - empty?(remove(zero?,elements(ps))$(List(P)))$(List(P)) - - if R has IntegralDomain - then - - roughUnitIdeal? ps == - any?(ground?,remove(zero?,elements(ps))$(List(P)))$(List P) - - relativelyPrimeLeadingMonomials? (p:P,q:P):B == - dp : E := degree(p) - dq : E := degree(q) - (sup(dp,dq)$E =$E dp +$E dq)@B - - roughBase? ps == - lp := remove(zero?,elements(ps))$(List(P)) - empty? lp => true - rB? : B := true - while (not empty? lp) and rB? repeat - p := first lp - lp := rest lp - copylp := lp - while (not empty? copylp) and rB? repeat - rB? := relativelyPrimeLeadingMonomials?(p,first(copylp)) - copylp := rest copylp - rB? - - roughSubIdeal?(ps1,ps2) == - lp: List(P) := rewriteIdealWithRemainder(elements(ps1),ps2) - empty? (remove(zero?,lp)) - - roughEqualIdeals? (ps1,ps2) == - ps1 =$$ ps2 => true - roughSubIdeal?(ps1,ps2) and roughSubIdeal?(ps2,ps1) - - if (R has GcdDomain) and (VarSet has ConvertibleTo (Symbol)) - then - - LPR ==> List Polynomial R - LS ==> List Symbol - - if R has EuclideanDomain - then - exactQuo(r:R,s:R):R == - r quo$R s - else - exactQuo(r:R,s:R):R == - (r exquo$R s)::R - - headRemainder (a,ps) == - lp1 : List(P) := remove(zero?, elements(ps))$(List(P)) - empty? lp1 => [a,1$R] - any?(ground?,lp1) => [reductum(a),1$R] - r : R := 1$R - lp1 := sort(localInf?, reverse elements(ps)) - lp2 := lp1 - e : Union(E, "failed") - while (not zero? a) and (not empty? lp2) repeat - p := first lp2 - if ((e:= subtractIfCan(degree(a),degree(p))) case E) - then - g := gcd((lca := leadingCoefficient(a)),(lcp := leadingCoefficient(p)))$R - (lca,lcp) := (exactQuo(lca,g),exactQuo(lcp,g)) - a := lcp * reductum(a) - monomial(lca, e::E)$P * reductum(p) - r := r * lcp - lp2 := lp1 - else - lp2 := rest lp2 - [a,r] - - makeIrreducible! (frac:Record(num:P,den:R)):Record(num:P,den:R) == - g := gcd(frac.den,frac.num)$P --- one? g => frac - (g = 1) => frac - frac.num := exactQuotient!(frac.num,g) - frac.den := exactQuo(frac.den,g) - frac - - remainder (a,ps) == - hRa := makeIrreducible! headRemainder (a,ps) - a := hRa.num - r : R := hRa.den - zero? a => [1$R,a,r] - b : P := monomial(1$R,degree(a))$P - c : R := leadingCoefficient(a) - while not zero?(a := reductum a) repeat - hRa := makeIrreducible! headRemainder (a,ps) - a := hRa.num - r := r * hRa.den - g := gcd(c,(lca := leadingCoefficient(a)))$R - b := ((hRa.den) * exactQuo(c,g)) * b + monomial(exactQuo(lca,g),degree(a))$P - c := g - [c,b,r] - - rewriteIdealWithHeadRemainder(ps,cs) == - trivialIdeal? cs => ps - roughUnitIdeal? cs => [0$P] - ps := remove(zero?,ps) - empty? ps => ps - any?(ground?,ps) => [1$P] - rs : List P := [] - while not empty? ps repeat - p := first ps - ps := rest ps - p := (headRemainder(p,cs)).num - if not zero? p - then - if ground? p - then - ps := [] - rs := [1$P] - else - primitivePart! p - rs := cons(p,rs) - removeDuplicates rs - - rewriteIdealWithRemainder(ps,cs) == - trivialIdeal? cs => ps - roughUnitIdeal? cs => [0$P] - ps := remove(zero?,ps) - empty? ps => ps - any?(ground?,ps) => [1$P] - rs : List P := [] - while not empty? ps repeat - p := first ps - ps := rest ps - p := (remainder(p,cs)).polnum - if not zero? p - then - if ground? p - then - ps := [] - rs := [1$P] - else - rs := cons(unitCanonical(p),rs) - removeDuplicates rs - -@ -\section{PSETCAT.lsp BOOTSTRAP} -{\bf PSETCAT} 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 PSETCAT} -category which we can write into the {\bf MID} directory. We compile -the lisp code and copy the {\bf PSETCAT.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 |PolynomialSetCategory;CAT| (QUOTE NIL)) - -(SETQ |PolynomialSetCategory;AL| (QUOTE NIL)) - -(DEFUN |PolynomialSetCategory| (|&REST| #1=#:G82375 |&AUX| #2=#:G82373) (DSETQ #2# #1#) (LET (#3=#:G82374) (COND ((SETQ #3# (|assoc| (|devaluateList| #2#) |PolynomialSetCategory;AL|)) (CDR #3#)) (T (SETQ |PolynomialSetCategory;AL| (|cons5| (CONS (|devaluateList| #2#) (SETQ #3# (APPLY (FUNCTION |PolynomialSetCategory;|) #2#))) |PolynomialSetCategory;AL|)) #3#)))) - -(DEFUN |PolynomialSetCategory;| (|t#1| |t#2| |t#3| |t#4|) (PROG (#1=#:G82372) (RETURN (PROG1 (LETT #1# (|sublisV| (PAIR (QUOTE (|t#1| |t#2| |t#3| |t#4|)) (LIST (|devaluate| |t#1|) (|devaluate| |t#2|) (|devaluate| |t#3|) (|devaluate| |t#4|))) (|sublisV| (PAIR (QUOTE (#2=#:G82371)) (LIST (QUOTE (|List| |t#4|)))) (COND (|PolynomialSetCategory;CAT|) ((QUOTE T) (LETT |PolynomialSetCategory;CAT| (|Join| (|SetCategory|) (|Collection| (QUOTE |t#4|)) (|CoercibleTo| (QUOTE #2#)) (|mkCategory| (QUOTE |domain|) (QUOTE (((|retractIfCan| ((|Union| |$| "failed") (|List| |t#4|))) T) ((|retract| (|$| (|List| |t#4|))) T) ((|mvar| (|t#3| |$|)) T) ((|variables| ((|List| |t#3|) |$|)) T) ((|mainVariables| ((|List| |t#3|) |$|)) T) ((|mainVariable?| ((|Boolean|) |t#3| |$|)) T) ((|collectUnder| (|$| |$| |t#3|)) T) ((|collect| (|$| |$| |t#3|)) T) ((|collectUpper| (|$| |$| |t#3|)) T) ((|sort| ((|Record| (|:| |under| |$|) (|:| |floor| |$|) (|:| |upper| |$|)) |$| |t#3|)) T) ((|trivialIdeal?| ((|Boolean|) |$|)) T) ((|roughBase?| ((|Boolean|) |$|)) (|has| |t#1| (|IntegralDomain|))) ((|roughSubIdeal?| ((|Boolean|) |$| |$|)) (|has| |t#1| (|IntegralDomain|))) ((|roughEqualIdeals?| ((|Boolean|) |$| |$|)) (|has| |t#1| (|IntegralDomain|))) ((|roughUnitIdeal?| ((|Boolean|) |$|)) (|has| |t#1| (|IntegralDomain|))) ((|headRemainder| ((|Record| (|:| |num| |t#4|) (|:| |den| |t#1|)) |t#4| |$|)) (|has| |t#1| (|IntegralDomain|))) ((|remainder| ((|Record| (|:| |rnum| |t#1|) (|:| |polnum| |t#4|) (|:| |den| |t#1|)) |t#4| |$|)) (|has| |t#1| (|IntegralDomain|))) ((|rewriteIdealWithHeadRemainder| ((|List| |t#4|) (|List| |t#4|) |$|)) (|has| |t#1| (|IntegralDomain|))) ((|rewriteIdealWithRemainder| ((|List| |t#4|) (|List| |t#4|) |$|)) (|has| |t#1| (|IntegralDomain|))) ((|triangular?| ((|Boolean|) |$|)) (|has| |t#1| (|IntegralDomain|))))) (QUOTE ((|finiteAggregate| T))) (QUOTE ((|Boolean|) (|List| |t#4|) (|List| |t#3|))) NIL)) . #3=(|PolynomialSetCategory|)))))) . #3#) (SETELT #1# 0 (LIST (QUOTE |PolynomialSetCategory|) (|devaluate| |t#1|) (|devaluate| |t#2|) (|devaluate| |t#3|) (|devaluate| |t#4|))))))) -@ -\section{PSETCAT-.lsp BOOTSTRAP} -{\bf PSETCAT-} depends on {\bf PSETCAT}. We need to break this cycle to build -the algebra. So we keep a cached copy of the translated {\bf PSETCAT-} -category which we can write into the {\bf MID} directory. We compile -the lisp code and copy the {\bf PSETCAT-.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 |PSETCAT-;elements| (|ps| |$|) (PROG (|lp|) (RETURN (LETT |lp| (SPADCALL |ps| (QREFELT |$| 12)) |PSETCAT-;elements|)))) - -(DEFUN |PSETCAT-;variables1| (|lp| |$|) (PROG (#1=#:G82392 |p| #2=#:G82393 |lvars|) (RETURN (SEQ (LETT |lvars| (PROGN (LETT #1# NIL |PSETCAT-;variables1|) (SEQ (LETT |p| NIL |PSETCAT-;variables1|) (LETT #2# |lp| |PSETCAT-;variables1|) G190 (COND ((OR (ATOM #2#) (PROGN (LETT |p| (CAR #2#) |PSETCAT-;variables1|) NIL)) (GO G191))) (SEQ (EXIT (LETT #1# (CONS (SPADCALL |p| (QREFELT |$| 14)) #1#) |PSETCAT-;variables1|))) (LETT #2# (CDR #2#) |PSETCAT-;variables1|) (GO G190) G191 (EXIT (NREVERSE0 #1#)))) |PSETCAT-;variables1|) (EXIT (SPADCALL (CONS (FUNCTION |PSETCAT-;variables1!0|) |$|) (SPADCALL (SPADCALL |lvars| (QREFELT |$| 18)) (QREFELT |$| 19)) (QREFELT |$| 21))))))) - -(DEFUN |PSETCAT-;variables1!0| (|#1| |#2| |$|) (SPADCALL |#2| |#1| (QREFELT |$| 16))) - -(DEFUN |PSETCAT-;variables2| (|lp| |$|) (PROG (#1=#:G82397 |p| #2=#:G82398 |lvars|) (RETURN (SEQ (LETT |lvars| (PROGN (LETT #1# NIL |PSETCAT-;variables2|) (SEQ (LETT |p| NIL |PSETCAT-;variables2|) (LETT #2# |lp| |PSETCAT-;variables2|) G190 (COND ((OR (ATOM #2#) (PROGN (LETT |p| (CAR #2#) |PSETCAT-;variables2|) NIL)) (GO G191))) (SEQ (EXIT (LETT #1# (CONS (SPADCALL |p| (QREFELT |$| 22)) #1#) |PSETCAT-;variables2|))) (LETT #2# (CDR #2#) |PSETCAT-;variables2|) (GO G190) G191 (EXIT (NREVERSE0 #1#)))) |PSETCAT-;variables2|) (EXIT (SPADCALL (CONS (FUNCTION |PSETCAT-;variables2!0|) |$|) (SPADCALL |lvars| (QREFELT |$| 19)) (QREFELT |$| 21))))))) - -(DEFUN |PSETCAT-;variables2!0| (|#1| |#2| |$|) (SPADCALL |#2| |#1| (QREFELT |$| 16))) - -(DEFUN |PSETCAT-;variables;SL;4| (|ps| |$|) (|PSETCAT-;variables1| (|PSETCAT-;elements| |ps| |$|) |$|)) - -(DEFUN |PSETCAT-;mainVariables;SL;5| (|ps| |$|) (|PSETCAT-;variables2| (SPADCALL (ELT |$| 24) (|PSETCAT-;elements| |ps| |$|) (QREFELT |$| 26)) |$|)) - -(DEFUN |PSETCAT-;mainVariable?;VarSetSB;6| (|v| |ps| |$|) (PROG (|lp|) (RETURN (SEQ (LETT |lp| (SPADCALL (ELT |$| 24) (|PSETCAT-;elements| |ps| |$|) (QREFELT |$| 26)) |PSETCAT-;mainVariable?;VarSetSB;6|) (SEQ G190 (COND ((NULL (COND ((OR (NULL |lp|) (SPADCALL (SPADCALL (|SPADfirst| |lp|) (QREFELT |$| 22)) |v| (QREFELT |$| 28))) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (EXIT (LETT |lp| (CDR |lp|) |PSETCAT-;mainVariable?;VarSetSB;6|))) NIL (GO G190) G191 (EXIT NIL)) (EXIT (COND ((NULL |lp|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))))))) - -(DEFUN |PSETCAT-;collectUnder;SVarSetS;7| (|ps| |v| |$|) (PROG (|p| |lp| |lq|) (RETURN (SEQ (LETT |lp| (|PSETCAT-;elements| |ps| |$|) |PSETCAT-;collectUnder;SVarSetS;7|) (LETT |lq| NIL |PSETCAT-;collectUnder;SVarSetS;7|) (SEQ G190 (COND ((NULL (COND ((NULL |lp|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |p| (|SPADfirst| |lp|) |PSETCAT-;collectUnder;SVarSetS;7|) (LETT |lp| (CDR |lp|) |PSETCAT-;collectUnder;SVarSetS;7|) (EXIT (COND ((OR (SPADCALL |p| (QREFELT |$| 24)) (SPADCALL (SPADCALL |p| (QREFELT |$| 22)) |v| (QREFELT |$| 16))) (LETT |lq| (CONS |p| |lq|) |PSETCAT-;collectUnder;SVarSetS;7|))))) NIL (GO G190) G191 (EXIT NIL)) (EXIT (SPADCALL |lq| (QREFELT |$| 30))))))) - -(DEFUN |PSETCAT-;collectUpper;SVarSetS;8| (|ps| |v| |$|) (PROG (|p| |lp| |lq|) (RETURN (SEQ (LETT |lp| (|PSETCAT-;elements| |ps| |$|) |PSETCAT-;collectUpper;SVarSetS;8|) (LETT |lq| NIL |PSETCAT-;collectUpper;SVarSetS;8|) (SEQ G190 (COND ((NULL (COND ((NULL |lp|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |p| (|SPADfirst| |lp|) |PSETCAT-;collectUpper;SVarSetS;8|) (LETT |lp| (CDR |lp|) |PSETCAT-;collectUpper;SVarSetS;8|) (EXIT (COND ((NULL (SPADCALL |p| (QREFELT |$| 24))) (COND ((SPADCALL |v| (SPADCALL |p| (QREFELT |$| 22)) (QREFELT |$| 16)) (LETT |lq| (CONS |p| |lq|) |PSETCAT-;collectUpper;SVarSetS;8|))))))) NIL (GO G190) G191 (EXIT NIL)) (EXIT (SPADCALL |lq| (QREFELT |$| 30))))))) - -(DEFUN |PSETCAT-;collect;SVarSetS;9| (|ps| |v| |$|) (PROG (|p| |lp| |lq|) (RETURN (SEQ (LETT |lp| (|PSETCAT-;elements| |ps| |$|) |PSETCAT-;collect;SVarSetS;9|) (LETT |lq| NIL |PSETCAT-;collect;SVarSetS;9|) (SEQ G190 (COND ((NULL (COND ((NULL |lp|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |p| (|SPADfirst| |lp|) |PSETCAT-;collect;SVarSetS;9|) (LETT |lp| (CDR |lp|) |PSETCAT-;collect;SVarSetS;9|) (EXIT (COND ((NULL (SPADCALL |p| (QREFELT |$| 24))) (COND ((SPADCALL (SPADCALL |p| (QREFELT |$| 22)) |v| (QREFELT |$| 28)) (LETT |lq| (CONS |p| |lq|) |PSETCAT-;collect;SVarSetS;9|))))))) NIL (GO G190) G191 (EXIT NIL)) (EXIT (SPADCALL |lq| (QREFELT |$| 30))))))) - -(DEFUN |PSETCAT-;sort;SVarSetR;10| (|ps| |v| |$|) (PROG (|p| |lp| |us| |vs| |ws|) (RETURN (SEQ (LETT |lp| (|PSETCAT-;elements| |ps| |$|) |PSETCAT-;sort;SVarSetR;10|) (LETT |us| NIL |PSETCAT-;sort;SVarSetR;10|) (LETT |vs| NIL |PSETCAT-;sort;SVarSetR;10|) (LETT |ws| NIL |PSETCAT-;sort;SVarSetR;10|) (SEQ G190 (COND ((NULL (COND ((NULL |lp|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |p| (|SPADfirst| |lp|) |PSETCAT-;sort;SVarSetR;10|) (LETT |lp| (CDR |lp|) |PSETCAT-;sort;SVarSetR;10|) (EXIT (COND ((OR (SPADCALL |p| (QREFELT |$| 24)) (SPADCALL (SPADCALL |p| (QREFELT |$| 22)) |v| (QREFELT |$| 16))) (LETT |us| (CONS |p| |us|) |PSETCAT-;sort;SVarSetR;10|)) ((SPADCALL (SPADCALL |p| (QREFELT |$| 22)) |v| (QREFELT |$| 28)) (LETT |vs| (CONS |p| |vs|) |PSETCAT-;sort;SVarSetR;10|)) ((QUOTE T) (LETT |ws| (CONS |p| |ws|) |PSETCAT-;sort;SVarSetR;10|))))) NIL (GO G190) G191 (EXIT NIL)) (EXIT (VECTOR (SPADCALL |us| (QREFELT |$| 30)) (SPADCALL |vs| (QREFELT |$| 30)) (SPADCALL |ws| (QREFELT |$| 30)))))))) - -(DEFUN |PSETCAT-;=;2SB;11| (|ps1| |ps2| |$|) (PROG (#1=#:G82439 #2=#:G82440 #3=#:G82437 |p| #4=#:G82438) (RETURN (SEQ (SPADCALL (SPADCALL (PROGN (LETT #1# NIL |PSETCAT-;=;2SB;11|) (SEQ (LETT |p| NIL |PSETCAT-;=;2SB;11|) (LETT #2# (|PSETCAT-;elements| |ps1| |$|) |PSETCAT-;=;2SB;11|) G190 (COND ((OR (ATOM #2#) (PROGN (LETT |p| (CAR #2#) |PSETCAT-;=;2SB;11|) NIL)) (GO G191))) (SEQ (EXIT (LETT #1# (CONS |p| #1#) |PSETCAT-;=;2SB;11|))) (LETT #2# (CDR #2#) |PSETCAT-;=;2SB;11|) (GO G190) G191 (EXIT (NREVERSE0 #1#)))) (QREFELT |$| 37)) (SPADCALL (PROGN (LETT #3# NIL |PSETCAT-;=;2SB;11|) (SEQ (LETT |p| NIL |PSETCAT-;=;2SB;11|) (LETT #4# (|PSETCAT-;elements| |ps2| |$|) |PSETCAT-;=;2SB;11|) G190 (COND ((OR (ATOM #4#) (PROGN (LETT |p| (CAR #4#) |PSETCAT-;=;2SB;11|) NIL)) (GO G191))) (SEQ (EXIT (LETT #3# (CONS |p| #3#) |PSETCAT-;=;2SB;11|))) (LETT #4# (CDR #4#) |PSETCAT-;=;2SB;11|) (GO G190) G191 (EXIT (NREVERSE0 #3#)))) (QREFELT |$| 37)) (QREFELT |$| 38)))))) - -(DEFUN |PSETCAT-;localInf?| (|p| |q| |$|) (SPADCALL (SPADCALL |p| (QREFELT |$| 40)) (SPADCALL |q| (QREFELT |$| 40)) (QREFELT |$| 41))) - -(DEFUN |PSETCAT-;localTriangular?| (|lp| |$|) (PROG (|q| |p|) (RETURN (SEQ (LETT |lp| (SPADCALL (ELT |$| 42) |lp| (QREFELT |$| 26)) |PSETCAT-;localTriangular?|) (EXIT (COND ((NULL |lp|) (QUOTE T)) ((SPADCALL (ELT |$| 24) |lp| (QREFELT |$| 43)) (QUOTE NIL)) ((QUOTE T) (SEQ (LETT |lp| (SPADCALL (CONS (FUNCTION |PSETCAT-;localTriangular?!0|) |$|) |lp| (QREFELT |$| 45)) |PSETCAT-;localTriangular?|) (LETT |p| (|SPADfirst| |lp|) |PSETCAT-;localTriangular?|) (LETT |lp| (CDR |lp|) |PSETCAT-;localTriangular?|) (SEQ G190 (COND ((NULL (COND ((NULL |lp|) (QUOTE NIL)) ((QUOTE T) (SPADCALL (SPADCALL (LETT |q| (|SPADfirst| |lp|) |PSETCAT-;localTriangular?|) (QREFELT |$| 22)) (SPADCALL |p| (QREFELT |$| 22)) (QREFELT |$| 16))))) (GO G191))) (SEQ (LETT |p| |q| |PSETCAT-;localTriangular?|) (EXIT (LETT |lp| (CDR |lp|) |PSETCAT-;localTriangular?|))) NIL (GO G190) G191 (EXIT NIL)) (EXIT (NULL |lp|)))))))))) - -(DEFUN |PSETCAT-;localTriangular?!0| (|#1| |#2| |$|) (SPADCALL (SPADCALL |#2| (QREFELT |$| 22)) (SPADCALL |#1| (QREFELT |$| 22)) (QREFELT |$| 16))) - -(DEFUN |PSETCAT-;triangular?;SB;14| (|ps| |$|) (|PSETCAT-;localTriangular?| (|PSETCAT-;elements| |ps| |$|) |$|)) - -(DEFUN |PSETCAT-;trivialIdeal?;SB;15| (|ps| |$|) (NULL (SPADCALL (ELT |$| 42) (|PSETCAT-;elements| |ps| |$|) (QREFELT |$| 26)))) - -(DEFUN |PSETCAT-;roughUnitIdeal?;SB;16| (|ps| |$|) (SPADCALL (ELT |$| 24) (SPADCALL (ELT |$| 42) (|PSETCAT-;elements| |ps| |$|) (QREFELT |$| 26)) (QREFELT |$| 43))) - -(DEFUN |PSETCAT-;relativelyPrimeLeadingMonomials?| (|p| |q| |$|) (PROG (|dp| |dq|) (RETURN (SEQ (LETT |dp| (SPADCALL |p| (QREFELT |$| 40)) |PSETCAT-;relativelyPrimeLeadingMonomials?|) (LETT |dq| (SPADCALL |q| (QREFELT |$| 40)) |PSETCAT-;relativelyPrimeLeadingMonomials?|) (EXIT (SPADCALL (SPADCALL |dp| |dq| (QREFELT |$| 49)) (SPADCALL |dp| |dq| (QREFELT |$| 50)) (QREFELT |$| 51))))))) - -(DEFUN |PSETCAT-;roughBase?;SB;18| (|ps| |$|) (PROG (|p| |lp| |rB?| |copylp|) (RETURN (SEQ (LETT |lp| (SPADCALL (ELT |$| 42) (|PSETCAT-;elements| |ps| |$|) (QREFELT |$| 26)) |PSETCAT-;roughBase?;SB;18|) (EXIT (COND ((NULL |lp|) (QUOTE T)) ((QUOTE T) (SEQ (LETT |rB?| (QUOTE T) |PSETCAT-;roughBase?;SB;18|) (SEQ G190 (COND ((NULL (COND ((NULL |lp|) (QUOTE NIL)) ((QUOTE T) |rB?|))) (GO G191))) (SEQ (LETT |p| (|SPADfirst| |lp|) |PSETCAT-;roughBase?;SB;18|) (LETT |lp| (CDR |lp|) |PSETCAT-;roughBase?;SB;18|) (LETT |copylp| |lp| |PSETCAT-;roughBase?;SB;18|) (EXIT (SEQ G190 (COND ((NULL (COND ((NULL |copylp|) (QUOTE NIL)) ((QUOTE T) |rB?|))) (GO G191))) (SEQ (LETT |rB?| (|PSETCAT-;relativelyPrimeLeadingMonomials?| |p| (|SPADfirst| |copylp|) |$|) |PSETCAT-;roughBase?;SB;18|) (EXIT (LETT |copylp| (CDR |copylp|) |PSETCAT-;roughBase?;SB;18|))) NIL (GO G190) G191 (EXIT NIL)))) NIL (GO G190) G191 (EXIT NIL)) (EXIT |rB?|))))))))) - -(DEFUN |PSETCAT-;roughSubIdeal?;2SB;19| (|ps1| |ps2| |$|) (PROG (|lp|) (RETURN (SEQ (LETT |lp| (SPADCALL (|PSETCAT-;elements| |ps1| |$|) |ps2| (QREFELT |$| 53)) |PSETCAT-;roughSubIdeal?;2SB;19|) (EXIT (NULL (SPADCALL (ELT |$| 42) |lp| (QREFELT |$| 26)))))))) - -(DEFUN |PSETCAT-;roughEqualIdeals?;2SB;20| (|ps1| |ps2| |$|) (COND ((SPADCALL |ps1| |ps2| (QREFELT |$| 55)) (QUOTE T)) ((SPADCALL |ps1| |ps2| (QREFELT |$| 56)) (SPADCALL |ps2| |ps1| (QREFELT |$| 56))) ((QUOTE T) (QUOTE NIL)))) - -(DEFUN |PSETCAT-;exactQuo| (|r| |s| |$|) (SPADCALL |r| |s| (QREFELT |$| 58))) - -(DEFUN |PSETCAT-;exactQuo| (|r| |s| |$|) (PROG (#1=#:G82473) (RETURN (PROG2 (LETT #1# (SPADCALL |r| |s| (QREFELT |$| 60)) |PSETCAT-;exactQuo|) (QCDR #1#) (|check-union| (QEQCAR #1# 0) (QREFELT |$| 7) #1#))))) - -(DEFUN |PSETCAT-;headRemainder;PSR;23| (|a| |ps| |$|) (PROG (|lp1| |p| |e| |g| |#G47| |#G48| |lca| |lcp| |r| |lp2|) (RETURN (SEQ (LETT |lp1| (SPADCALL (ELT |$| 42) (|PSETCAT-;elements| |ps| |$|) (QREFELT |$| 26)) |PSETCAT-;headRemainder;PSR;23|) (EXIT (COND ((NULL |lp1|) (CONS |a| (|spadConstant| |$| 61))) ((SPADCALL (ELT |$| 24) |lp1| (QREFELT |$| 43)) (CONS (SPADCALL |a| (QREFELT |$| 62)) (|spadConstant| |$| 61))) ((QUOTE T) (SEQ (LETT |r| (|spadConstant| |$| 61) |PSETCAT-;headRemainder;PSR;23|) (LETT |lp1| (SPADCALL (CONS (|function| |PSETCAT-;localInf?|) |$|) (REVERSE (|PSETCAT-;elements| |ps| |$|)) (QREFELT |$| 45)) |PSETCAT-;headRemainder;PSR;23|) (LETT |lp2| |lp1| |PSETCAT-;headRemainder;PSR;23|) (SEQ G190 (COND ((NULL (COND ((OR (SPADCALL |a| (QREFELT |$| 42)) (NULL |lp2|)) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |p| (|SPADfirst| |lp2|) |PSETCAT-;headRemainder;PSR;23|) (LETT |e| (SPADCALL (SPADCALL |a| (QREFELT |$| 40)) (SPADCALL |p| (QREFELT |$| 40)) (QREFELT |$| 63)) |PSETCAT-;headRemainder;PSR;23|) (EXIT (COND ((QEQCAR |e| 0) (SEQ (LETT |g| (SPADCALL (LETT |lca| (SPADCALL |a| (QREFELT |$| 64)) |PSETCAT-;headRemainder;PSR;23|) (LETT |lcp| (SPADCALL |p| (QREFELT |$| 64)) |PSETCAT-;headRemainder;PSR;23|) (QREFELT |$| 65)) |PSETCAT-;headRemainder;PSR;23|) (PROGN (LETT |#G47| (|PSETCAT-;exactQuo| |lca| |g| |$|) |PSETCAT-;headRemainder;PSR;23|) (LETT |#G48| (|PSETCAT-;exactQuo| |lcp| |g| |$|) |PSETCAT-;headRemainder;PSR;23|) (LETT |lca| |#G47| |PSETCAT-;headRemainder;PSR;23|) (LETT |lcp| |#G48| |PSETCAT-;headRemainder;PSR;23|)) (LETT |a| (SPADCALL (SPADCALL |lcp| (SPADCALL |a| (QREFELT |$| 62)) (QREFELT |$| 66)) (SPADCALL (SPADCALL |lca| (QCDR |e|) (QREFELT |$| 67)) (SPADCALL |p| (QREFELT |$| 62)) (QREFELT |$| 68)) (QREFELT |$| 69)) |PSETCAT-;headRemainder;PSR;23|) (LETT |r| (SPADCALL |r| |lcp| (QREFELT |$| 70)) |PSETCAT-;headRemainder;PSR;23|) (EXIT (LETT |lp2| |lp1| |PSETCAT-;headRemainder;PSR;23|)))) ((QUOTE T) (LETT |lp2| (CDR |lp2|) |PSETCAT-;headRemainder;PSR;23|))))) NIL (GO G190) G191 (EXIT NIL)) (EXIT (CONS |a| |r|)))))))))) - -(DEFUN |PSETCAT-;makeIrreducible!| (|frac| |$|) (PROG (|g|) (RETURN (SEQ (LETT |g| (SPADCALL (QCDR |frac|) (QCAR |frac|) (QREFELT |$| 73)) |PSETCAT-;makeIrreducible!|) (EXIT (COND ((SPADCALL |g| (QREFELT |$| 74)) |frac|) ((QUOTE T) (SEQ (PROGN (RPLACA |frac| (SPADCALL (QCAR |frac|) |g| (QREFELT |$| 75))) (QCAR |frac|)) (PROGN (RPLACD |frac| (|PSETCAT-;exactQuo| (QCDR |frac|) |g| |$|)) (QCDR |frac|)) (EXIT |frac|))))))))) - -(DEFUN |PSETCAT-;remainder;PSR;25| (|a| |ps| |$|) (PROG (|hRa| |r| |lca| |g| |b| |c|) (RETURN (SEQ (LETT |hRa| (|PSETCAT-;makeIrreducible!| (SPADCALL |a| |ps| (QREFELT |$| 76)) |$|) |PSETCAT-;remainder;PSR;25|) (LETT |a| (QCAR |hRa|) |PSETCAT-;remainder;PSR;25|) (LETT |r| (QCDR |hRa|) |PSETCAT-;remainder;PSR;25|) (EXIT (COND ((SPADCALL |a| (QREFELT |$| 42)) (VECTOR (|spadConstant| |$| 61) |a| |r|)) ((QUOTE T) (SEQ (LETT |b| (SPADCALL (|spadConstant| |$| 61) (SPADCALL |a| (QREFELT |$| 40)) (QREFELT |$| 67)) |PSETCAT-;remainder;PSR;25|) (LETT |c| (SPADCALL |a| (QREFELT |$| 64)) |PSETCAT-;remainder;PSR;25|) (SEQ G190 (COND ((NULL (COND ((SPADCALL (LETT |a| (SPADCALL |a| (QREFELT |$| 62)) |PSETCAT-;remainder;PSR;25|) (QREFELT |$| 42)) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |hRa| (|PSETCAT-;makeIrreducible!| (SPADCALL |a| |ps| (QREFELT |$| 76)) |$|) |PSETCAT-;remainder;PSR;25|) (LETT |a| (QCAR |hRa|) |PSETCAT-;remainder;PSR;25|) (LETT |r| (SPADCALL |r| (QCDR |hRa|) (QREFELT |$| 70)) |PSETCAT-;remainder;PSR;25|) (LETT |g| (SPADCALL |c| (LETT |lca| (SPADCALL |a| (QREFELT |$| 64)) |PSETCAT-;remainder;PSR;25|) (QREFELT |$| 65)) |PSETCAT-;remainder;PSR;25|) (LETT |b| (SPADCALL (SPADCALL (SPADCALL (QCDR |hRa|) (|PSETCAT-;exactQuo| |c| |g| |$|) (QREFELT |$| 70)) |b| (QREFELT |$| 66)) (SPADCALL (|PSETCAT-;exactQuo| |lca| |g| |$|) (SPADCALL |a| (QREFELT |$| 40)) (QREFELT |$| 67)) (QREFELT |$| 77)) |PSETCAT-;remainder;PSR;25|) (EXIT (LETT |c| |g| |PSETCAT-;remainder;PSR;25|))) NIL (GO G190) G191 (EXIT NIL)) (EXIT (VECTOR |c| |b| |r|)))))))))) - -(DEFUN |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;26| (|ps| |cs| |$|) (PROG (|p| |rs|) (RETURN (SEQ (COND ((SPADCALL |cs| (QREFELT |$| 80)) |ps|) ((SPADCALL |cs| (QREFELT |$| 81)) (LIST (|spadConstant| |$| 82))) ((QUOTE T) (SEQ (LETT |ps| (SPADCALL (ELT |$| 42) |ps| (QREFELT |$| 26)) |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;26|) (EXIT (COND ((NULL |ps|) |ps|) ((SPADCALL (ELT |$| 24) |ps| (QREFELT |$| 43)) (LIST (|spadConstant| |$| 83))) ((QUOTE T) (SEQ (LETT |rs| NIL |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;26|) (SEQ G190 (COND ((NULL (COND ((NULL |ps|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |p| (|SPADfirst| |ps|) |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;26|) (LETT |ps| (CDR |ps|) |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;26|) (LETT |p| (QCAR (SPADCALL |p| |cs| (QREFELT |$| 76))) |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;26|) (EXIT (COND ((NULL (SPADCALL |p| (QREFELT |$| 42))) (COND ((SPADCALL |p| (QREFELT |$| 24)) (SEQ (LETT |ps| NIL |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;26|) (EXIT (LETT |rs| (LIST (|spadConstant| |$| 83)) |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;26|)))) ((QUOTE T) (SEQ (SPADCALL |p| (QREFELT |$| 84)) (EXIT (LETT |rs| (CONS |p| |rs|) |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;26|))))))))) NIL (GO G190) G191 (EXIT NIL)) (EXIT (SPADCALL |rs| (QREFELT |$| 85)))))))))))))) - -(DEFUN |PSETCAT-;rewriteIdealWithRemainder;LSL;27| (|ps| |cs| |$|) (PROG (|p| |rs|) (RETURN (SEQ (COND ((SPADCALL |cs| (QREFELT |$| 80)) |ps|) ((SPADCALL |cs| (QREFELT |$| 81)) (LIST (|spadConstant| |$| 82))) ((QUOTE T) (SEQ (LETT |ps| (SPADCALL (ELT |$| 42) |ps| (QREFELT |$| 26)) |PSETCAT-;rewriteIdealWithRemainder;LSL;27|) (EXIT (COND ((NULL |ps|) |ps|) ((SPADCALL (ELT |$| 24) |ps| (QREFELT |$| 43)) (LIST (|spadConstant| |$| 83))) ((QUOTE T) (SEQ (LETT |rs| NIL |PSETCAT-;rewriteIdealWithRemainder;LSL;27|) (SEQ G190 (COND ((NULL (COND ((NULL |ps|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |p| (|SPADfirst| |ps|) |PSETCAT-;rewriteIdealWithRemainder;LSL;27|) (LETT |ps| (CDR |ps|) |PSETCAT-;rewriteIdealWithRemainder;LSL;27|) (LETT |p| (QVELT (SPADCALL |p| |cs| (QREFELT |$| 87)) 1) |PSETCAT-;rewriteIdealWithRemainder;LSL;27|) (EXIT (COND ((NULL (SPADCALL |p| (QREFELT |$| 42))) (COND ((SPADCALL |p| (QREFELT |$| 24)) (SEQ (LETT |ps| NIL |PSETCAT-;rewriteIdealWithRemainder;LSL;27|) (EXIT (LETT |rs| (LIST (|spadConstant| |$| 83)) |PSETCAT-;rewriteIdealWithRemainder;LSL;27|)))) ((QUOTE T) (LETT |rs| (CONS (SPADCALL |p| (QREFELT |$| 88)) |rs|) |PSETCAT-;rewriteIdealWithRemainder;LSL;27|))))))) NIL (GO G190) G191 (EXIT NIL)) (EXIT (SPADCALL |rs| (QREFELT |$| 85)))))))))))))) - -(DEFUN |PolynomialSetCategory&| (|#1| |#2| |#3| |#4| |#5|) (PROG (|DV$1| |DV$2| |DV$3| |DV$4| |DV$5| |dv$| |$| |pv$|) (RETURN (PROGN (LETT |DV$1| (|devaluate| |#1|) . #1=(|PolynomialSetCategory&|)) (LETT |DV$2| (|devaluate| |#2|) . #1#) (LETT |DV$3| (|devaluate| |#3|) . #1#) (LETT |DV$4| (|devaluate| |#4|) . #1#) (LETT |DV$5| (|devaluate| |#5|) . #1#) (LETT |dv$| (LIST (QUOTE |PolynomialSetCategory&|) |DV$1| |DV$2| |DV$3| |DV$4| |DV$5|) . #1#) (LETT |$| (GETREFV 90) . #1#) (QSETREFV |$| 0 |dv$|) (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 (LIST (|HasCategory| |#2| (QUOTE (|IntegralDomain|))))) . #1#)) (|stuffDomainSlots| |$|) (QSETREFV |$| 6 |#1|) (QSETREFV |$| 7 |#2|) (QSETREFV |$| 8 |#3|) (QSETREFV |$| 9 |#4|) (QSETREFV |$| 10 |#5|) (COND ((|testBitVector| |pv$| 1) (PROGN (QSETREFV |$| 48 (CONS (|dispatchFunction| |PSETCAT-;roughUnitIdeal?;SB;16|) |$|)) (QSETREFV |$| 52 (CONS (|dispatchFunction| |PSETCAT-;roughBase?;SB;18|) |$|)) (QSETREFV |$| 54 (CONS (|dispatchFunction| |PSETCAT-;roughSubIdeal?;2SB;19|) |$|)) (QSETREFV |$| 57 (CONS (|dispatchFunction| |PSETCAT-;roughEqualIdeals?;2SB;20|) |$|))))) (COND ((|HasCategory| |#2| (QUOTE (|GcdDomain|))) (COND ((|HasCategory| |#4| (QUOTE (|ConvertibleTo| (|Symbol|)))) (PROGN (QSETREFV |$| 72 (CONS (|dispatchFunction| |PSETCAT-;headRemainder;PSR;23|) |$|)) (QSETREFV |$| 79 (CONS (|dispatchFunction| |PSETCAT-;remainder;PSR;25|) |$|)) (QSETREFV |$| 86 (CONS (|dispatchFunction| |PSETCAT-;rewriteIdealWithHeadRemainder;LSL;26|) |$|)) (QSETREFV |$| 89 (CONS (|dispatchFunction| |PSETCAT-;rewriteIdealWithRemainder;LSL;27|) |$|))))))) |$|)))) - -(MAKEPROP (QUOTE |PolynomialSetCategory&|) (QUOTE |infovec|) (LIST (QUOTE #(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|) (|local| |#3|) (|local| |#4|) (|local| |#5|) (|List| 10) (0 . |members|) (|List| 9) (5 . |variables|) (|Boolean|) (10 . |<|) (|List| |$|) (16 . |concat|) (21 . |removeDuplicates|) (|Mapping| 15 9 9) (26 . |sort|) (32 . |mvar|) |PSETCAT-;variables;SL;4| (37 . |ground?|) (|Mapping| 15 10) (42 . |remove|) |PSETCAT-;mainVariables;SL;5| (48 . |=|) |PSETCAT-;mainVariable?;VarSetSB;6| (54 . |construct|) |PSETCAT-;collectUnder;SVarSetS;7| |PSETCAT-;collectUpper;SVarSetS;8| |PSETCAT-;collect;SVarSetS;9| (|Record| (|:| |under| |$|) (|:| |floor| |$|) (|:| |upper| |$|)) |PSETCAT-;sort;SVarSetR;10| (|Set| 10) (59 . |brace|) (64 . |=|) |PSETCAT-;=;2SB;11| (70 . |degree|) (75 . |<|) (81 . |zero?|) (86 . |any?|) (|Mapping| 15 10 10) (92 . |sort|) |PSETCAT-;triangular?;SB;14| |PSETCAT-;trivialIdeal?;SB;15| (98 . |roughUnitIdeal?|) (103 . |sup|) (109 . |+|) (115 . |=|) (121 . |roughBase?|) (126 . |rewriteIdealWithRemainder|) (132 . |roughSubIdeal?|) (138 . |=|) (144 . |roughSubIdeal?|) (150 . |roughEqualIdeals?|) (156 . |quo|) (|Union| |$| (QUOTE "failed")) (162 . |exquo|) (168 . |One|) (172 . |reductum|) (177 . |subtractIfCan|) (183 . |leadingCoefficient|) (188 . |gcd|) (194 . |*|) (200 . |monomial|) (206 . |*|) (212 . |-|) (218 . |*|) (|Record| (|:| |num| 10) (|:| |den| 7)) (224 . |headRemainder|) (230 . |gcd|) (236 . |one?|) (241 . |exactQuotient!|) (247 . |headRemainder|) (253 . |+|) (|Record| (|:| |rnum| 7) (|:| |polnum| 10) (|:| |den| 7)) (259 . |remainder|) (265 . |trivialIdeal?|) (270 . |roughUnitIdeal?|) (275 . |Zero|) (279 . |One|) (283 . |primitivePart!|) (288 . |removeDuplicates|) (293 . |rewriteIdealWithHeadRemainder|) (299 . |remainder|) (305 . |unitCanonical|) (310 . |rewriteIdealWithRemainder|))) (QUOTE #(|variables| 316 |trivialIdeal?| 321 |triangular?| 326 |sort| 331 |roughUnitIdeal?| 337 |roughSubIdeal?| 342 |roughEqualIdeals?| 348 |roughBase?| 354 |rewriteIdealWithRemainder| 359 |rewriteIdealWithHeadRemainder| 365 |remainder| 371 |mainVariables| 377 |mainVariable?| 382 |headRemainder| 388 |collectUpper| 394 |collectUnder| 400 |collect| 406 |=| 412)) (QUOTE NIL) (CONS (|makeByteWordVec2| 1 (QUOTE NIL)) (CONS (QUOTE #()) (CONS (QUOTE #()) (|makeByteWordVec2| 89 (QUOTE (1 6 11 0 12 1 10 13 0 14 2 9 15 0 0 16 1 13 0 17 18 1 13 0 0 19 2 13 0 20 0 21 1 10 9 0 22 1 10 15 0 24 2 11 0 25 0 26 2 9 15 0 0 28 1 6 0 11 30 1 36 0 11 37 2 36 15 0 0 38 1 10 8 0 40 2 8 15 0 0 41 1 10 15 0 42 2 11 15 25 0 43 2 11 0 44 0 45 1 0 15 0 48 2 8 0 0 0 49 2 8 0 0 0 50 2 8 15 0 0 51 1 0 15 0 52 2 6 11 11 0 53 2 0 15 0 0 54 2 6 15 0 0 55 2 6 15 0 0 56 2 0 15 0 0 57 2 7 0 0 0 58 2 7 59 0 0 60 0 7 0 61 1 10 0 0 62 2 8 59 0 0 63 1 10 7 0 64 2 7 0 0 0 65 2 10 0 7 0 66 2 10 0 7 8 67 2 10 0 0 0 68 2 10 0 0 0 69 2 7 0 0 0 70 2 0 71 10 0 72 2 10 7 7 0 73 1 7 15 0 74 2 10 0 0 7 75 2 6 71 10 0 76 2 10 0 0 0 77 2 0 78 10 0 79 1 6 15 0 80 1 6 15 0 81 0 10 0 82 0 10 0 83 1 10 0 0 84 1 11 0 0 85 2 0 11 11 0 86 2 6 78 10 0 87 1 10 0 0 88 2 0 11 11 0 89 1 0 13 0 23 1 0 15 0 47 1 0 15 0 46 2 0 34 0 9 35 1 0 15 0 48 2 0 15 0 0 54 2 0 15 0 0 57 1 0 15 0 52 2 0 11 11 0 89 2 0 11 11 0 86 2 0 78 10 0 79 1 0 13 0 27 2 0 15 9 0 29 2 0 71 10 0 72 2 0 0 0 9 32 2 0 0 0 9 31 2 0 0 0 9 33 2 0 15 0 0 39)))))) (QUOTE |lookupComplete|))) -@ \section{domain GPOLSET GeneralPolynomialSet} <>= )abbrev domain GPOLSET GeneralPolynomialSet @@ -572,7 +126,6 @@ GeneralPolynomialSet(R,E,VarSet,P) : Exports == Implementation where <<*>>= <> -<> <> @ \eject diff --git a/src/algebra/regset.spad.pamphlet b/src/algebra/regset.spad.pamphlet index 2a1e80c..e9a65a0 100644 --- a/src/algebra/regset.spad.pamphlet +++ b/src/algebra/regset.spad.pamphlet @@ -9,348 +9,6 @@ \eject \tableofcontents \eject -\section{category RSETCAT RegularTriangularSetCategory} -<>= -)abbrev category RSETCAT RegularTriangularSetCategory -++ Author: Marc Moreno Maza -++ Date Created: 09/03/1998 -++ Date Last Updated: 12/15/1998 -++ Basic Functions: -++ Related Constructors: -++ Also See: essai Graphisme -++ AMS Classifications: -++ Keywords: polynomial, multivariate, ordered variables set -++ Description: -++ The category of regular triangular sets, introduced under -++ the name regular chains in [1] (and other papers). -++ In [3] it is proved that regular triangular sets and towers of simple -++ extensions of a field are equivalent notions. -++ In the following definitions, all polynomials and ideals -++ are taken from the polynomial ring \spad{k[x1,...,xn]} where \spad{k} -++ is the fraction field of \spad{R}. -++ The triangular set \spad{[t1,...,tm]} is regular -++ iff for every \spad{i} the initial of \spad{ti+1} is invertible -++ in the tower of simple extensions associated with \spad{[t1,...,ti]}. -++ A family \spad{[T1,...,Ts]} of regular triangular sets -++ is a split of Kalkbrener of a given ideal \spad{I} -++ iff the radical of \spad{I} is equal to the intersection -++ of the radical ideals generated by the saturated ideals -++ of the \spad{[T1,...,Ti]}. -++ A family \spad{[T1,...,Ts]} of regular triangular sets -++ is a split of Kalkbrener of a given triangular set \spad{T} -++ iff it is a split of Kalkbrener of the saturated ideal of \spad{T}. -++ Let \spad{K} be an algebraic closure of \spad{k}. -++ Assume that \spad{V} is finite with cardinality -++ \spad{n} and let \spad{A} be the affine space \spad{K^n}. -++ For a regular triangular set \spad{T} let denote by \spad{W(T)} the -++ set of regular zeros of \spad{T}. -++ A family \spad{[T1,...,Ts]} of regular triangular sets -++ is a split of Lazard of a given subset \spad{S} of \spad{A} -++ iff the union of the \spad{W(Ti)} contains \spad{S} and -++ is contained in the closure of \spad{S} (w.r.t. Zariski topology). -++ A family \spad{[T1,...,Ts]} of regular triangular sets -++ is a split of Lazard of a given triangular set \spad{T} -++ if it is a split of Lazard of \spad{W(T)}. -++ Note that if \spad{[T1,...,Ts]} is a split of Lazard of -++ \spad{T} then it is also a split of Kalkbrener of \spad{T}. -++ The converse is false. -++ This category provides operations related to both kinds of -++ splits, the former being related to ideals decomposition whereas -++ the latter deals with varieties decomposition. -++ See the example illustrating the \spadtype{RegularTriangularSet} constructor -++ for more explanations about decompositions by means of regular triangular sets. \newline -++ References : -++ [1] M. KALKBRENER "Three contributions to elimination theory" -++ Phd Thesis, University of Linz, Austria, 1991. -++ [2] M. KALKBRENER "Algorithmic properties of polynomial rings" -++ Journal of Symbol. Comp. 1998 -++ [3] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories -++ of Triangular Sets" Journal of Symbol. Comp. (to appear) -++ [4] M. MORENO MAZA "A new algorithm for computing triangular -++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. -++ Version: 2 - -RegularTriangularSetCategory(R:GcdDomain, E:OrderedAbelianMonoidSup,_ - V:OrderedSet,P:RecursivePolynomialCategory(R,E,V)): - Category == - TriangularSetCategory(R,E,V,P) with - - purelyAlgebraic?: (P,$) -> Boolean - ++ \spad{purelyAlgebraic?(p,ts)} returns \spad{true} iff every - ++ variable of \spad{p} is algebraic w.r.t. \spad{ts}. - purelyTranscendental? : (P,$) -> Boolean - ++ \spad{purelyTranscendental?(p,ts)} returns \spad{true} iff every - ++ variable of \spad{p} is not algebraic w.r.t. \spad{ts} - algebraicCoefficients? : (P,$) -> Boolean - ++ \spad{algebraicCoefficients?(p,ts)} returns \spad{true} iff every - ++ variable of \spad{p} which is not the main one of \spad{p} - ++ is algebraic w.r.t. \spad{ts}. - purelyAlgebraic?: $ -> Boolean - ++ \spad{purelyAlgebraic?(ts)} returns true iff for every algebraic - ++ variable \spad{v} of \spad{ts} we have - ++ \spad{algebraicCoefficients?(t_v,ts_v_-)} where \spad{ts_v} - ++ is \axiomOpFrom{select}{TriangularSetCategory}(ts,v) and \spad{ts_v_-} is - ++ \axiomOpFrom{collectUnder}{TriangularSetCategory}(ts,v). - purelyAlgebraicLeadingMonomial?: (P, $) -> Boolean - ++ \spad{purelyAlgebraicLeadingMonomial?(p,ts)} returns true iff - ++ the main variable of any non-constant iterarted initial - ++ of \spad{p} is algebraic w.r.t. \spad{ts}. - invertibleElseSplit? : (P,$) -> Union(Boolean,List $) - ++ \spad{invertibleElseSplit?(p,ts)} returns \spad{true} (resp. - ++ \spad{false}) if \spad{p} is invertible in the tower - ++ associated with \spad{ts} or returns a split of Kalkbrener - ++ of \spad{ts}. - invertible? : (P,$) -> List Record(val : Boolean, tower : $) - ++ \spad{invertible?(p,ts)} returns \spad{lbwt} where \spad{lbwt.i} - ++ is the result of \spad{invertibleElseSplit?(p,lbwt.i.tower)} and - ++ the list of the \spad{(lqrwt.i).tower} is a split of Kalkbrener of \spad{ts}. - invertible?: (P,$) -> Boolean - ++ \spad{invertible?(p,ts)} returns true iff \spad{p} is invertible - ++ in the tower associated with \spad{ts}. - invertibleSet: (P,$) -> List $ - ++ \spad{invertibleSet(p,ts)} returns a split of Kalkbrener of the - ++ quotient ideal of the ideal \axiom{I} by \spad{p} where \spad{I} is - ++ the radical of saturated of \spad{ts}. - lastSubResultantElseSplit: (P, P, $) -> Union(P,List $) - ++ \spad{lastSubResultantElseSplit(p1,p2,ts)} returns either - ++ \spad{g} a quasi-monic gcd of \spad{p1} and \spad{p2} w.r.t. - ++ the \spad{ts} or a split of Kalkbrener of \spad{ts}. - ++ This assumes that \spad{p1} and \spad{p2} have the same maim - ++ variable and that this variable is greater that any variable - ++ occurring in \spad{ts}. - lastSubResultant: (P, P, $) -> List Record(val : P, tower : $) - ++ \spad{lastSubResultant(p1,p2,ts)} returns \spad{lpwt} such that - ++ \spad{lpwt.i.val} is a quasi-monic gcd of \spad{p1} and \spad{p2} - ++ w.r.t. \spad{lpwt.i.tower}, for every \spad{i}, and such - ++ that the list of the \spad{lpwt.i.tower} is a split of Kalkbrener of - ++ \spad{ts}. Moreover, if \spad{p1} and \spad{p2} do not - ++ have a non-trivial gcd w.r.t. \spad{lpwt.i.tower} then \spad{lpwt.i.val} - ++ is the resultant of these polynomials w.r.t. \spad{lpwt.i.tower}. - ++ This assumes that \spad{p1} and \spad{p2} have the same maim - ++ variable and that this variable is greater that any variable - ++ occurring in \spad{ts}. - squareFreePart: (P,$) -> List Record(val : P, tower : $) - ++ \spad{squareFreePart(p,ts)} returns \spad{lpwt} such that - ++ \spad{lpwt.i.val} is a square-free polynomial - ++ w.r.t. \spad{lpwt.i.tower}, this polynomial being associated with \spad{p} - ++ modulo \spad{lpwt.i.tower}, for every \spad{i}. Moreover, - ++ the list of the \spad{lpwt.i.tower} is a split - ++ of Kalkbrener of \spad{ts}. - ++ WARNING: This assumes that \spad{p} is a non-constant polynomial such that - ++ if \spad{p} is added to \spad{ts}, then the resulting set is a - ++ regular triangular set. - intersect: (P,$) -> List $ - ++ \spad{intersect(p,ts)} returns the same as - ++ \spad{intersect([p],ts)} - intersect: (List P, $) -> List $ - ++ \spad{intersect(lp,ts)} returns \spad{lts} a split of Lazard - ++ of the intersection of the affine variety associated - ++ with \spad{lp} and the regular zero set of \spad{ts}. - intersect: (List P, List $) -> List $ - ++ \spad{intersect(lp,lts)} returns the same as - ++ \spad{concat([intersect(lp,ts) for ts in lts])|} - intersect: (P, List $) -> List $ - ++ \spad{intersect(p,lts)} returns the same as - ++ \spad{intersect([p],lts)} - augment: (P,$) -> List $ - ++ \spad{augment(p,ts)} assumes that \spad{p} is a non-constant - ++ polynomial whose main variable is greater than any variable - ++ of \spad{ts}. This operation assumes also that if \spad{p} is - ++ added to \spad{ts} the resulting set, say \spad{ts+p}, is a - ++ regular triangular set. Then it returns a split of Kalkbrener - ++ of \spad{ts+p}. This may not be \spad{ts+p} itself, if for - ++ instance \spad{ts+p} is required to be square-free. - augment: (P,List $) -> List $ - ++ \spad{augment(p,lts)} returns the same as - ++ \spad{concat([augment(p,ts) for ts in lts])} - augment: (List P,$) -> List $ - ++ \spad{augment(lp,ts)} returns \spad{ts} if \spad{empty? lp}, - ++ \spad{augment(p,ts)} if \spad{lp = [p]}, otherwise - ++ \spad{augment(first lp, augment(rest lp, ts))} - augment: (List P,List $) -> List $ - ++ \spad{augment(lp,lts)} returns the same as - ++ \spad{concat([augment(lp,ts) for ts in lts])} - internalAugment: (P, $) -> $ - ++ \spad{internalAugment(p,ts)} assumes that \spad{augment(p,ts)} - ++ returns a singleton and returns it. - internalAugment: (List P, $) -> $ - ++ \spad{internalAugment(lp,ts)} returns \spad{ts} if \spad{lp} - ++ is empty otherwise returns - ++ \spad{internalAugment(rest lp, internalAugment(first lp, ts))} - extend: (P,$) -> List $ - ++ \spad{extend(p,ts)} assumes that \spad{p} is a non-constant - ++ polynomial whose main variable is greater than any variable - ++ of \spad{ts}. Then it returns a split of Kalkbrener - ++ of \spad{ts+p}. This may not be \spad{ts+p} itself, if for - ++ instance \spad{ts+p} is not a regular triangular set. - extend: (P, List $) -> List $ - ++ \spad{extend(p,lts)} returns the same as - ++ \spad{concat([extend(p,ts) for ts in lts])|} - extend: (List P,$) -> List $ - ++ \spad{extend(lp,ts)} returns \spad{ts} if \spad{empty? lp} - ++ \spad{extend(p,ts)} if \spad{lp = [p]} else - ++ \spad{extend(first lp, extend(rest lp, ts))} - extend: (List P,List $) -> List $ - ++ \spad{extend(lp,lts)} returns the same as - ++ \spad{concat([extend(lp,ts) for ts in lts])|} - zeroSetSplit: (List P, Boolean) -> List $ - ++ \spad{zeroSetSplit(lp,clos?)} returns \spad{lts} a split of Kalkbrener - ++ of the radical ideal associated with \spad{lp}. - ++ If \spad{clos?} is false, it is also a decomposition of the - ++ variety associated with \spad{lp} into the regular zero set of the \spad{ts} in \spad{lts} - ++ (or, in other words, a split of Lazard of this variety). - ++ See the example illustrating the \spadtype{RegularTriangularSet} constructor - ++ for more explanations about decompositions by means of regular triangular sets. - - add - - NNI ==> NonNegativeInteger - INT ==> Integer - LP ==> List P - PWT ==> Record(val : P, tower : $) - LpWT ==> Record(val : (List P), tower : $) - Split ==> List $ - pack ==> PolynomialSetUtilitiesPackage(R,E,V,P) - - purelyAlgebraic?(p: P, ts: $): Boolean == - ground? p => true - not algebraic?(mvar(p),ts) => false - algebraicCoefficients?(p,ts) - - purelyTranscendental?(p:P,ts:$): Boolean == - empty? ts => true - lv : List V := variables(p)$P - while (not empty? lv) and (not algebraic?(first(lv),ts)) repeat lv := rest lv - empty? lv - - purelyAlgebraicLeadingMonomial?(p: P, ts: $): Boolean == - ground? p => true - algebraic?(mvar(p),ts) and purelyAlgebraicLeadingMonomial?(init(p), ts) - - algebraicCoefficients?(p:P,ts:$): Boolean == - ground? p => true - (not ground? init(p)) and not (algebraic?(mvar(init(p)),ts)) => false - algebraicCoefficients?(init(p),ts) => - ground? tail(p) => true - mvar(tail(p)) = mvar(p) => - algebraicCoefficients?(tail(p),ts) - algebraic?(mvar(tail(p)),ts) => - algebraicCoefficients?(tail(p),ts) - false - false - - if V has Finite - then - purelyAlgebraic?(ts: $): Boolean == - empty? ts => true - size()$V = #ts => true - lp: LP := sort(infRittWu?,members(ts)) - i: NonNegativeInteger := size()$V - for p in lp repeat - v: V := mvar(p) - (i = (lookup(v)$V)::NNI) => - i := subtractIfCan(i,1)::NNI - univariate?(p)$pack => - i := subtractIfCan(i,1)::NNI - not algebraicCoefficients?(p,collectUnder(ts,v)) => - return false - i := subtractIfCan(i,1)::NNI - true - - else - - purelyAlgebraic?(ts: $): Boolean == - empty? ts => true - v: V := mvar(ts) - p: P := select(ts,v)::P - ts := collectUnder(ts,v) - empty? ts => univariate?(p)$pack - not purelyAlgebraic?(ts) => false - algebraicCoefficients?(p,ts) - - augment(p:P,lts:List $) == - toSave: Split := [] - while not empty? lts repeat - ts := first lts - lts := rest lts - toSave := concat(augment(p,ts),toSave) - toSave - - augment(lp:LP,ts:$) == - toSave: Split := [ts] - empty? lp => toSave - lp := sort(infRittWu?,lp) - while not empty? lp repeat - p := first lp - lp := rest lp - toSave := augment(p,toSave) - toSave - - augment(lp:LP,lts:List $) == - empty? lp => lts - toSave: Split := [] - while not empty? lts repeat - ts := first lts - lts := rest lts - toSave := concat(augment(lp,ts),toSave) - toSave - - extend(p:P,lts:List $) == - toSave : Split := [] - while not empty? lts repeat - ts := first lts - lts := rest lts - toSave := concat(extend(p,ts),toSave) - toSave - - extend(lp:LP,ts:$) == - toSave: Split := [ts] - empty? lp => toSave - lp := sort(infRittWu?,lp) - while not empty? lp repeat - p := first lp - lp := rest lp - toSave := extend(p,toSave) - toSave - - extend(lp:LP,lts:List $) == - empty? lp => lts - toSave: Split := [] - while not empty? lts repeat - ts := first lts - lts := rest lts - toSave := concat(extend(lp,ts),toSave) - toSave - - intersect(lp:LP,lts:List $): List $ == - -- A VERY GENERAL default algorithm - (empty? lp) or (empty? lts) => lts - lp := [primitivePart(p) for p in lp] - lp := removeDuplicates lp - lp := remove(zero?,lp) - any?(ground?,lp) => [] - toSee: List LpWT := [[lp,ts]$LpWT for ts in lts] - toSave: List $ := [] - lp: LP - p: P - ts: $ - lus: List $ - while (not empty? toSee) repeat - lpwt := first toSee; toSee := rest toSee - lp := lpwt.val; ts := lpwt.tower - empty? lp => toSave := cons(ts, toSave) - p := first lp; lp := rest lp - lus := intersect(p,ts) - toSee := concat([[lp,us]$LpWT for us in lus], toSee) - toSave - - intersect(lp: LP,ts: $): List $ == - intersect(lp,[ts]) - - intersect(p: P,lts: List $): List $ == - intersect([p],lts) - -@ \section{package QCMPACK QuasiComponentPackage} <>= )abbrev package QCMPACK QuasiComponentPackage @@ -3163,7 +2821,6 @@ RegularTriangularSet(R,E,V,P) : Exports == Implementation where <<*>>= <> -<> <> <> <> diff --git a/src/algebra/sregset.spad.pamphlet b/src/algebra/sregset.spad.pamphlet index c0cdb44..88588cc 100644 --- a/src/algebra/sregset.spad.pamphlet +++ b/src/algebra/sregset.spad.pamphlet @@ -9,41 +9,6 @@ \eject \tableofcontents \eject -\section{category SFRTCAT SquareFreeRegularTriangularSetCategory} -<>= -)abbrev category SFRTCAT SquareFreeRegularTriangularSetCategory -++ Author: Marc Moreno Maza -++ Date Created: 09/03/1996 -++ Date Last Updated: 09/10/1998 -++ Basic Functions: -++ Related Constructors: -++ Also See: essai Graphisme -++ AMS Classifications: -++ Keywords: polynomial, multivariate, ordered variables set -++ Description: -++ The category of square-free regular triangular sets. -++ A regular triangular set \spad{ts} is square-free if -++ the gcd of any polynomial \spad{p} in \spad{ts} and -++ \spad{differentiate(p,mvar(p))} w.r.t. -++ \axiomOpFrom{collectUnder}{TriangularSetCategory}(ts,\axiomOpFrom{mvar}{RecursivePolynomialCategory}(p)) -++ has degree zero w.r.t. \spad{mvar(p)}. Thus any square-free regular -++ set defines a tower of square-free simple extensions.\newline -++ References : -++ [1] D. LAZARD "A new method for solving algebraic systems of -++ positive dimension" Discr. App. Math. 33:147-160,1991 -++ [2] M. KALKBRENER "Algorithmic properties of polynomial rings" -++ Habilitation Thesis, ETZH, Zurich, 1995. -++ [3] M. MORENO MAZA "A new algorithm for computing triangular -++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. - - - -SquareFreeRegularTriangularSetCategory(R:GcdDomain,E:OrderedAbelianMonoidSup,_ - V:OrderedSet,P:RecursivePolynomialCategory(R,E,V)): - Category == - RegularTriangularSetCategory(R,E,V,P) - -@ \section{package SFQCMPK SquareFreeQuasiComponentPackage} <>= )abbrev package SFQCMPK SquareFreeQuasiComponentPackage @@ -2064,7 +2029,6 @@ SquareFreeRegularTriangularSet(R,E,V,P) : Exports == Implementation where <<*>>= <> -<> <> <> <>