diff --git a/books/bookvol10.2.pamphlet b/books/bookvol10.2.pamphlet index 941a873..9be4f7e 100644 --- a/books/bookvol10.2.pamphlet +++ b/books/bookvol10.2.pamphlet @@ -306,6 +306,7 @@ This is the root of the category hierarchy and is not represented by code. \pageto{OpenMath}{OM} \pageto{Patternable}{PATAB} \pageto{PrimitiveFunctionCategory}{PRIMCAT} +\pageto{RadicalCategory}{RADCAT} \pageto{RetractableTo}{RETRACT} \pageto{SpecialFunctionCategory}{SPFCAT} \pageto{TrigonometricFunctionCategory}{TRIGCAT} @@ -549,6 +550,8 @@ is true if and only if distinct elements have distinct data structures. For example, a domain of mathematical objects which has the {\tt canonical} attribute means that two objects are mathematically equal if and only if their data structures are equal. +\item {\bf \cross{ATTREG}{approximate}} means ``is an approximation to +the real numbers''. \end{itemize} <>= @@ -621,6 +624,8 @@ AttributeRegistry(): Category == with ++ objects which has the \spad{canonical} attribute means that two ++ objects are mathematically equal if and only if their data ++ structures are equal. + approximate + ++ \spad{approximate} means "is an approximation to the real numbers". @ <>= @@ -856,6 +861,8 @@ digraph pic { \pageto{Collection}{CLAGG} \pageto{MonogenicAlgebra}{MONOGEN} \pageto{PolynomialCategory}{POLYCAT} +\pageto{RealConstant}{REAL} +\pageto{RealNumberSystem}{RNS} \pagefrom{Category}{CATEGORY} {\bf Exports:}\\ @@ -1514,6 +1521,79 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{RadicalCategory}{RADCAT} +\pagepic{ps/v102radicalcategory.ps}{RADCAT}{1.00} + +{\bf See:}\\ +\pageto{RealNumberSystem}{RNS} +\pagefrom{Category}{CATEGORY} + +{\bf Exports:}\\ +\begin{tabular}{lll} +\cross{RADCAT}{nthRoot} & +\cross{RADCAT}{sqrt} & +\cross{RADCAT}{?**?} +\end{tabular} + +These are directly exported but not implemented: +\begin{verbatim} + ?**? : (%,Fraction Integer) -> % +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + nthRoot : (%,Integer) -> % + sqrt : % -> % +\end{verbatim} + +<>= +)abbrev category RADCAT RadicalCategory +++ Author: +++ Date Created: +++ Change History: +++ Basic Operations: nthRoot, sqrt, ** +++ Related Constructors: +++ Keywords: rational numbers +++ Description: The \spad{RadicalCategory} is a model for the +++ rational numbers. +RadicalCategory(): Category == with + sqrt : % -> % + ++ sqrt(x) returns the square root of x. + nthRoot: (%, Integer) -> % + ++ nthRoot(x,n) returns the nth root of x. + _*_* : (%, Fraction Integer) -> % + ++ x ** y is the rational exponentiation of x by the power y. + add + sqrt x == x ** inv(2::Fraction(Integer)) + nthRoot(x, n) == x ** inv(n::Fraction(Integer)) + +@ +<>= +"RADCAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=RADCAT"]; +"RADCAT" -> "CATEGORY" + +@ +<>= +"RadicalCategory()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=RADCAT"]; +"RadicalCategory()" -> "Category" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"RadicalCategory()" [color=lightblue]; +"RadicalCategory()" -> "Category" + +"Category" [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{RetractableTo}{RETRACT} \pagepic{ps/v102retractableto.ps}{RETRACT}{1.00} @@ -1521,9 +1601,12 @@ digraph pic { \pageto{ExtensionField}{XF} \pageto{FiniteAlgebraicExtensionField}{FAXF} \pageto{FortranMachineTypeCategory}{FMTC} +\pageto{FreeModuleCat}{FMCAT} \pageto{FullyRetractableTo}{FRETRCT} \pageto{GradedAlgebra}{GRALG} \pageto{PolynomialCategory}{POLYCAT} +\pageto{RealNumberSystem}{RNS} +\pageto{XFreeAlgebra}{XFALG} \pagefrom{Category}{CATEGORY} {\bf Exports:}\\ @@ -1620,6 +1703,10 @@ RetractableTo(S: Type): Category == with [color=seagreen,href="bookvol10.2.pdf#nameddest=RETRACT"]; "RetractableTo(Field)" -> "RetractableTo(a:Type)" +"RetractableTo(OrderedFreeMonoid(OrderedSet))" + [color=seagreen,href="bookvol10.2.pdf#nameddest=RETRACT"]; +"RetractableTo(OrderedFreeMonoid(OrderedSet))" -> "RetractableTo(a:Type)" + @ <>= digraph pic { @@ -1991,6 +2078,81 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{RealConstant}{REAL} +\pagepic{ps/v102realconstant.ps}{REAL}{1.00} + +{\bf See:}\\ +\pageto{RealNumberSystem}{RNS} +\pagefrom{ConvertibleTo}{KONVERT} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\end{tabular} + +These exports come from \refto{ConvertibleTo}(DoubleFloat): +\begin{verbatim} + convert : % -> DoubleFloat +\end{verbatim} + +These exports come from \refto{ConvertibleTo}(Float): +\begin{verbatim} + convert : % -> Float +\end{verbatim} + +<>= +)abbrev category REAL RealConstant +++ Author: +++ Date Created: +++ Date Last Updated: +++ Basic Functions: +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: +++ The category of real numeric domains, i.e. convertible to floats. +RealConstant(): Category == + Join(ConvertibleTo DoubleFloat, ConvertibleTo Float) + +@ +<>= +"REAL" + [color=lightblue,href="bookvol10.2.pdf#nameddest=REAL"]; +"REAL" -> "KONVERT" + +@ +<>= +"RealConstant()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=REAL"]; +"RealConstant()" -> "ConvertibleTo(DoubleFloat)" +"RealConstant()" -> "ConvertibleTo(Float)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"RealConstant()" [color=lightblue]; +"RealConstant()" -> "ConvertibleTo(DoubleFloat)" +"RealConstant()" -> "ConvertibleTo(Float)" + +"ConvertibleTo(DoubleFloat)" [color=seagreen]; +"ConvertibleTo(DoubleFloat)" -> "ConvertibleTo(a:Type)" + +"ConvertibleTo(Float)" [color=seagreen]; +"ConvertibleTo(Float)" -> "ConvertibleTo(a:Type)" + +"ConvertibleTo(a:Type)" [color=lightblue]; +"ConvertibleTo(a:Type)" -> "Category" + +"Category" [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{EltableAggregate}{ELTAGG} \pagepic{ps/v102eltableaggregate.ps}{ELTAGG}{0.75} @@ -4985,6 +5147,7 @@ digraph pic { {\bf See:}\\ \pageto{BitAggregate}{BTAGG} +\pageto{CachableSet}{CACHSET} \pageto{FortranMachineTypeCategory}{FMTC} \pageto{OrderedAbelianSemiGroup}{OASGP} \pageto{OrderedFinite}{ORDFIN} @@ -5117,6 +5280,7 @@ digraph pic { {\bf See:}\\ \pageto{PolynomialCategory}{POLYCAT} +\pageto{RealNumberSystem}{RNS} \pagefrom{SetCategory}{SETCAT} {\bf Exports:}\\ @@ -5136,10 +5300,6 @@ These are directly exported but not implemented: -> PatternMatchResult(S,%) \end{verbatim} -These are implemented by this category: -\begin{verbatim} -\end{verbatim} - These exports come from \refto{SetCategory}(): \begin{verbatim} coerce : % -> OutputForm @@ -6524,6 +6684,108 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{CachableSet}{CACHSET} +\pagepic{ps/v102cachableset.ps}{CACHSET}{1.00} + +{\bf See:}\\ +\pagefrom{OrderedSet}{ORDSET} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{CACHESET}{coerce} & +\cross{CACHESET}{hash} & +\cross{CACHESET}{latex} & +\cross{CACHESET}{max} & +\cross{CACHESET}{min} \\ +\cross{CACHESET}{position} & +\cross{CACHESET}{setPosition} & +\cross{CACHESET}{?\~{}=?} & +\cross{CACHESET}{?$<$?} & +\cross{CACHESET}{?$<=$?} \\ +\cross{CACHESET}{?=?} & +\cross{CACHESET}{?$>$?} & +\cross{CACHESET}{?$>=$?} && +\end{tabular} + +These are directly exported but not implemented: +\begin{verbatim} + position : % -> NonNegativeInteger + setPosition : (%,NonNegativeInteger) -> Void +\end{verbatim} + +These exports come from \refto{OrderedSet}(): +\begin{verbatim} + coerce : % -> OutputForm + hash : % -> SingleInteger + latex : % -> String + max : (%,%) -> % + min : (%,%) -> % + ?~=? : (%,%) -> Boolean + ? Boolean + ?<=? : (%,%) -> Boolean + ?=? : (%,%) -> Boolean + ?>? : (%,%) -> Boolean + ?>=? : (%,%) -> Boolean +\end{verbatim} + +<>= +)abbrev category CACHSET CachableSet +++ Sets whose elements can cache an integer +++ Author: Manuel Bronstein +++ Date Created: 31 Oct 1988 +++ Date Last Updated: 14 May 1991 +++ Description: +++ A cachable set is a set whose elements keep an integer as part +++ of their structure. +CachableSet: Category == OrderedSet with + position : % -> NonNegativeInteger + ++ position(x) returns the integer n associated to x. + setPosition: (%, NonNegativeInteger) -> Void + ++ setPosition(x, n) associates the integer n to x. + +@ +<>= +"CACHSET" + [color=lightblue,href="bookvol10.2.pdf#nameddest=CACHSET"]; +"CACHSET" -> "ORDSET" + +@ +<>= +"CachableSet()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=CACHSET"]; +"CachableSet()" -> "OrderedSet()" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"CachableSet()" [color=lightblue]; +"CachableSet()" -> "OrderedSet()" + +"OrderedSet()" [color=lightblue]; +"OrderedSet()" -> "SetCategory()" + +"SetCategory()" [color=lightblue]; +"SetCategory()" -> "BasicType()" +"SetCategory()" -> "CoercibleTo(OutputForm)" + +"BasicType()" [color=lightblue]; +"BasicType()" -> "Category" + +"CoercibleTo(OutputForm)" [color=seagreen]; +"CoercibleTo(OutputForm)" -> "CoercibleTo(a:Type)" + +"CoercibleTo(a:Type)" [color=lightblue]; +"CoercibleTo(a:Type)" -> "Category" + +"Category" [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{Collection}{CLAGG} \pagepic{ps/v102collection.ps}{CLAGG}{1.00} @@ -18222,7 +18484,9 @@ digraph pic { \pageto{AbelianMonoidRing}{AMR} \pageto{CommutativeRing}{COMRING} \pageto{EntireRing}{ENTIRER} +\pageto{FreeModuleCat}{FMCAT} \pageto{Module}{MODULE} +\pageto{XAlgebra}{XALG} \pagefrom{LeftModule}{LMODULE} \pagefrom{RightModule}{RMODULE} @@ -19397,6 +19661,8 @@ digraph pic { \pageto{LinearlyExplicitRingOver}{LINEXP} \pageto{OrderedRing}{ORDRING} \pageto{PartialDifferentialRing}{PDRING} +\pageto{XAlgebra}{XALG} +\pageto{XFreeAlgebra}{XFALG} \pagefrom{LeftModule}{LMODULE} \pagefrom{Monoid}{MONOID} \pagefrom{Rng}{RNG} @@ -20353,6 +20619,7 @@ digraph pic { {\bf See:}\\ \pageto{FiniteRankAlgebra}{FINRALG} +\pageto{RealNumberSystem}{RNS} \pagefrom{Ring}{RING} {\bf Exports:}\\ @@ -20998,6 +21265,223 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{FreeModuleCat}{FMCAT} +\pagepic{ps/v102freemodulecat.ps}{FMCAT}{0.75} + +{\bf See:}\\ +\pagefrom{BiModule}{BMODULE} +\pagefrom{RetractableTo}{RETRACT} + +{\bf Exports:}\\ +\begin{tabular}{llll} +\cross{FMCAT}{0} & +\cross{FMCAT}{coefficient} & +\cross{FMCAT}{coefficients} & +\cross{FMCAT}{coerce} \\ +\cross{FMCAT}{hash} & +\cross{FMCAT}{latex} & +\cross{FMCAT}{leadingCoefficient} & +\cross{FMCAT}{leadingMonomial} \\ +\cross{FMCAT}{leadingTerm} & +\cross{FMCAT}{ListOfTerms} & +\cross{FMCAT}{map} & +\cross{FMCAT}{monom} \\ +\cross{FMCAT}{monomial?} & +\cross{FMCAT}{monomials} & +\cross{FMCAT}{numberOfMonomials} & +\cross{FMCAT}{reductum} \\ +\cross{FMCAT}{retract} & +\cross{FMCAT}{retractIfCan} & +\cross{FMCAT}{sample} & +\cross{FMCAT}{subtractIfCan} \\ +\cross{FMCAT}{zero?} & +\cross{FMCAT}{?\~{}=?} & +\cross{FMCAT}{?*?} & +\cross{FMCAT}{?+?} \\ +\cross{FMCAT}{?-?} & +\cross{FMCAT}{-?} & +\cross{FMCAT}{?=?} & +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item {\bf \cross{FMCAT}{leftUnitary}} +is true if $1 * x = x$ for all x. +\item {\bf \cross{FMCAT}{rightUnitary}} +is true if $x * 1 = x$ for all x. +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + coefficient : (%,Basis) -> R + coefficients : % -> List R + leadingCoefficient : % -> R + leadingMonomial : % -> Basis + leadingTerm : % -> Record(k: Basis,c: R) + ListOfTerms : % -> List Record(k: Basis,c: R) + map : ((R -> R),%) -> % + monom : (Basis,R) -> % + monomial? : % -> Boolean + monomials : % -> List % + numberOfMonomials : % -> NonNegativeInteger + reductum : % -> % + ?*? : (R,Basis) -> % +\end{verbatim} + +These exports come from \refto{BiModule}(R:Ring,R:Ring): +\begin{verbatim} + 0 : () -> % + coerce : % -> OutputForm + hash : % -> SingleInteger + latex : % -> String + sample : () -> % + subtractIfCan : (%,%) -> Union(%,"failed") + zero? : % -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (R,%) -> % + ?=? : (%,%) -> Boolean + ?+? : (%,%) -> % + ?*? : (PositiveInteger,%) -> % + ?*? : (NonNegativeInteger,%) -> % + ?*? : (Integer,%) -> % + ?-? : (%,%) -> % + -? : % -> % + ?*? : (%,R) -> % +\end{verbatim} + +These exports come from \refto{RetractableTo}(Basis:SetCategory): +\begin{verbatim} + coerce : Basis -> % + retract : % -> Basis + retractIfCan : % -> Union(Basis,"failed") +\end{verbatim} + +<>= +)abbrev category FMCAT FreeModuleCat +++ Author: Michel Petitot petitot@lifl.fr +++ Date Created: 91 +++ Date Last Updated: 7 Juillet 92 +++ Fix History: compilation v 2.1 le 13 dec 98 +++ Basic Functions: +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: +++ A domain of this category +++ implements formal linear combinations +++ of elements from a domain \spad{Basis} with coefficients +++ in a domain \spad{R}. The domain \spad{Basis} needs only +++ to belong to the category \spadtype{SetCategory} and \spad{R} +++ to the category \spadtype{Ring}. Thus the coefficient ring +++ may be non-commutative. +++ See the \spadtype{XDistributedPolynomial} constructor +++ for examples of domains built with the \spadtype{FreeModuleCat} +++ category constructor. +++ Author: Michel Petitot (petitot@lifl.fr) + +FreeModuleCat(R, Basis):Category == Exports where + R: Ring + Basis: SetCategory + TERM ==> Record(k: Basis, c: R) + + Exports == Join(BiModule(R,R), RetractableTo Basis) with + "*" : (R, Basis) -> % + ++ \spad{r*b} returns the product of \spad{r} by \spad{b}. + coefficient : (%, Basis) -> R + ++ \spad{coefficient(x,b)} returns the coefficient + ++ of \spad{b} in \spad{x}. + map : (R -> R, %) -> % + ++ \spad{map(fn,u)} maps function \spad{fn} onto the coefficients + ++ of the non-zero monomials of \spad{u}. + monom : (Basis, R) -> % + ++ \spad{monom(b,r)} returns the element with the single monomial + ++ \spad{b} and coefficient \spad{r}. + monomial? : % -> Boolean + ++ \spad{monomial?(x)} returns true if \spad{x} contains a single + ++ monomial. + ListOfTerms : % -> List TERM + ++ \spad{ListOfTerms(x)} returns a list \spad{lt} of terms with type + ++ \spad{Record(k: Basis, c: R)} such that \spad{x} equals + ++ \spad{reduce(+, map(x +-> monom(x.k, x.c), lt))}. + coefficients : % -> List R + ++ \spad{coefficients(x)} returns the list of coefficients of \spad{x} + monomials : % -> List % + ++ \spad{monomials(x)} returns the list of \spad{r_i*b_i} + ++ whose sum is \spad{x}. + numberOfMonomials : % -> NonNegativeInteger + ++ \spad{numberOfMonomials(x)} returns the number of monomials + ++ of \spad{x}. + leadingMonomial : % -> Basis + ++ \spad{leadingMonomial(x)} returns the first element from + ++ \spad{Basis} which appears in \spad{ListOfTerms(x)}. + leadingCoefficient : % -> R + ++ \spad{leadingCoefficient(x)} returns the first coefficient + ++ which appears in \spad{ListOfTerms(x)}. + leadingTerm : % -> TERM + ++ \spad{leadingTerm(x)} returns the first term which + ++ appears in \spad{ListOfTerms(x)}. + reductum : % -> % + ++ \spad{reductum(x)} returns \spad{x} minus its leading term. + + -- attributs + if R has CommutativeRing then Module(R) + +@ +<>= +"FMCAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FMCAT"]; +"FMCAT" -> "BMODULE" +"FMCAT" -> "RETRACT" + +@ +<>= +"FreeModuleCat(a:Ring,b:SetCategory)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FMCAT"]; +"FreeModuleCat(a:Ring,b:SetCategory)" -> "BiModule(a:Ring,b:Ring)" +"FreeModuleCat(a:Ring,b:SetCategory)" -> "RetractableTo(SetCategory)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"FreeModuleCat(a:Ring,b:SetCategory)" [color=lightblue]; +"FreeModuleCat(a:Ring,b:SetCategory)" -> "BiModule(a:Ring,b:Ring)" +"FreeModuleCat(a:Ring,b:SetCategory)" -> "RetractableTo(SetCategory)" + +"RetractableTo(SetCategory)" [color=seagreen]; +"RetractableTo(SetCategory)" -> "RetractableTo(a:Type)" + +"RetractableTo(a:Type)" [color=lightblue]; +"RetractableTo(a:Type)" -> "Category" + +"Category" [color=lightblue]; + +"BiModule(a:Ring,b:Ring)" [color=lightblue]; +"BiModule(a:Ring,b:Ring)" -> "LeftModule(a:Ring)" +"BiModule(a:Ring,b:Ring)" -> "RightModule(a:Ring)" + +"RightModule(a:Ring)" [color=seagreen]; +"RightModule(a:Ring)" -> "RightModule(a:Rng)" + +"RightModule(a:Rng)" [color=lightblue]; +"RightModule(a:Rng)" -> "ABELGRP..." + +"LeftModule(a:Ring)" [color=seagreen]; +"LeftModule(a:Ring)" -> "LeftModule(a:Rng)" + +"LeftModule(a:Rng)" [color=lightblue]; +"LeftModule(a:Rng)" -> "ABELGRP..." + +"ABELGRP..." [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{LeftAlgebra}{LALG} \pagepic{ps/v102leftalgebra.ps}{LALG}{1.00} @@ -21303,6 +21787,7 @@ digraph pic { {\bf See:}\\ \pageto{OrderedIntegralDomain}{OINTDOM} +\pageto{RealNumberSystem}{RNS} \pagefrom{Monoid}{MONOID} \pagefrom{OrderedAbelianGroup}{OAGROUP} \pagefrom{Ring}{RING} @@ -21720,6 +22205,181 @@ digraph pic { } @ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{XAlgebra}{XALG} +\pagepic{ps/v102xalgebra.ps}{XALG}{0.65} + +{\bf See:}\\ +\pageto{XFreeAlgebra}{XFALG} +\pagefrom{BiModule}{BMODULE} +\pagefrom{Ring}{RING} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{XALG}{0} & +\cross{XALG}{1} & +\cross{XALG}{characteristic} & +\cross{XALG}{coerce} & +\cross{XALG}{hash} \\ +\cross{XALG}{latex} & +\cross{XALG}{one?} & +\cross{XALG}{recip} & +\cross{XALG}{sample} & +\cross{XALG}{subtractIfCan} \\ +\cross{XALG}{zero?} & +\cross{XALG}{?\^{}?} & +\cross{XALG}{?\~{}=?} & +\cross{XALG}{?*?} & +\cross{XALG}{?**?} \\ +\cross{XALG}{?+?} & +\cross{XALG}{?-?} & +\cross{XALG}{-?} & +\cross{XALG}{?=?} & + +\end{tabular} + + +{\bf Attributes Exported:} +\begin{itemize} +\item {\bf \cross{XALG}{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{XALG}{leftUnitary}} +is true if $1 * x = x$ for all x. +\item {\bf \cross{XALG}{rightUnitary}} +is true if $x * 1 = x$ for all x. +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + coerce : R -> % +\end{verbatim} + +These exports come from \refto{Ring}(): +\begin{verbatim} + 0 : () -> % + 1 : () -> % + characteristic : () -> NonNegativeInteger + coerce : % -> OutputForm + coerce : Integer -> % + hash : % -> SingleInteger + latex : % -> String + one? : % -> Boolean + recip : % -> Union(%,"failed") + sample : () -> % + subtractIfCan : (%,%) -> Union(%,"failed") + zero? : % -> Boolean + ?+? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (NonNegativeInteger,%) -> % + ?*? : (PositiveInteger,%) -> % + ?*? : (Integer,%) -> % + ?*? : (%,%) -> % + ?-? : (%,%) -> % + -? : % -> % + ?**? : (%,NonNegativeInteger) -> % + ?**? : (%,PositiveInteger) -> % + ?^? : (%,NonNegativeInteger) -> % + ?^? : (%,PositiveInteger) -> % +\end{verbatim} + +These exports come from \refto{BiModule}(R:Ring,R:Ring): +\begin{verbatim} + ?*? : (R,%) -> % + ?*? : (%,R) -> % +\end{verbatim} + +<>= +)abbrev category XALG XAlgebra +++ Author: Michel Petitot petitot@lifl.fr +++ Date Created: 91 +++ Date Last Updated: 7 Juillet 92 +++ Fix History: compilation v 2.1 le 13 dec 98 +++ Basic Functions: +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: +++ This is the category of algebras over non-commutative rings. +++ It is used by constructors of non-commutative algebras such as: +++ \spadtype{XPolynomialRing}. +++ \spadtype{XFreeAlgebra} +++ Author: Michel Petitot (petitot@lifl.fr) + +XAlgebra(R: Ring): Category == + Join(Ring, BiModule(R,R)) with + coerce: R -> % + ++ \spad{coerce(r)} equals \spad{r*1}. + if R has CommutativeRing then Algebra(R) + +@ +<>= +"XALG" + [color=lightblue,href="bookvol10.2.pdf#nameddest=XALG"]; +"XALG" -> "BMODULE" +"XALG" -> "RING" + +@ +<>= +"XAlgebra(a:Ring)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=XALG"]; +"XAlgebra(a:Ring)" -> "Ring()" +"XAlgebra(a:Ring)" -> "BiModule(a:Ring,b:Ring)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"XAlgebra(a:Ring)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=XALG"]; +"XAlgebra(a:Ring)" -> "Ring()" +"XAlgebra(a:Ring)" -> "BiModule(a:Ring,b:Ring)" + +"Ring()" [color=lightblue]; +"Ring()" -> "Rng()" +"Ring()" -> "Monoid()" +"Ring()" -> "LeftModule(a:Ring)" + +"BiModule(a:Ring,b:Ring)" [color=lightblue]; +"BiModule(a:Ring,b:Ring)" -> "LeftModule(a:Ring)" +"BiModule(a:Ring,b:Ring)" -> "RightModule(a:Ring)" + +"RightModule(a:Ring)" [color=seagreen]; +"RightModule(a:Ring)" -> "RightModule(a:Rng)" + +"RightModule(a:Rng)" [color=lightblue]; +"RightModule(a:Rng)" -> "ABELGRP..." + +"Rng()" [color=lightblue]; +"Rng()" -> "ABELGRP..." +"Rng()" -> "SemiGroup()" + +"Monoid()" [color=lightblue]; +"Monoid()" -> "SemiGroup()" + +"LeftModule(a:Ring)" [color=seagreen]; +"LeftModule(a:Ring)" -> "LeftModule(a:Rng)" + +"LeftModule(a:Rng)" [color=lightblue]; +"LeftModule(a:Rng)" -> "ABELGRP..." + +"SemiGroup()" [color=lightblue]; +"SemiGroup()" -> "SETCAT..." +"SemiGroup()" -> "REPSQ..." + +"REPSQ..." [color="#00EE00"]; +"SETCAT..." [color=lightblue]; +"ABELGRP..." [color=lightblue]; +} + +@ \chapter{Category Layer 10} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{DifferentialExtension}{DIFEXT} @@ -22493,6 +23153,7 @@ digraph pic { {\bf See:}\\ \pageto{Algebra}{ALGEBRA} +\pageto{LieAlgebra}{LIECAT} \pageto{NonAssociativeAlgebra}{NAALG} \pageto{VectorSpace}{VSPACE} \pagefrom{BiModule}{BMODULE} @@ -22621,6 +23282,325 @@ digraph pic { } @ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{XFreeAlgebra}{XFALG} +\pagepic{ps/v102xfreealgebra.ps}{XFALG}{0.50} + +{\bf See:}\\ +\pageto{XPolynomialsCat}{XPOLYC} +\pagefrom{RetractableTo}{RETRACT} +\pagefrom{Ring}{RING} +\pagefrom{XAlgebra}{XALG} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{XFALG}{0} & +\cross{XFALG}{1} & +\cross{XFALG}{characteristic} & +\cross{XFALG}{coef} & +\cross{XFALG}{coerce} \\ +\cross{XFALG}{constant} & +\cross{XFALG}{constant?} & +\cross{XFALG}{hash} & +\cross{XFALG}{latex} & +\cross{XFALG}{lquo} \\ +\cross{XFALG}{map} & +\cross{XFALG}{mindeg} & +\cross{XFALG}{mindegTerm} & +\cross{XFALG}{mirror} & +\cross{XFALG}{monom} \\ +\cross{XFALG}{monomial?} & +\cross{XFALG}{one?} & +\cross{XFALG}{quasiRegular} & +\cross{XFALG}{quasiRegular?} & +\cross{XFALG}{recip} \\ +\cross{XFALG}{retract} & +\cross{XFALG}{retractIfCan} & +\cross{XFALG}{rquo} & +\cross{XFALG}{sample} & +\cross{XFALG}{sh} \\ +\cross{XFALG}{subtractIfCan} & +\cross{XFALG}{varList} & +\cross{XFALG}{zero?} & +\cross{XFALG}{?*?} & +\cross{XFALG}{?**?} \\ +\cross{XFALG}{?+?} & +\cross{XFALG}{?-?} & +\cross{XFALG}{-?} & +\cross{XFALG}{?=?} & +\cross{XFALG}{?\^{}?} \\ +\cross{XFALG}{?\~{}=?} &&&& +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item if Ring has noZeroDivisors then noZeroDivisors where +{\bf \cross{XFALG}{noZeroDivisors}} +is true if $x * y \ne 0$ implies both x and y are non-zero. +\item {\bf \cross{XFALG}{commutative("*")}} +is true if it has an operation $"*": (D,D) -> D$ +which is commutative. +\item {\bf \cross{XFALG}{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{XFALG}{leftUnitary}} +is true if $1 * x = x$ for all x. +\item {\bf \cross{XFALG}{rightUnitary}} +is true if $x * 1 = x$ for all x. +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + coef : (%,OrderedFreeMonoid vl) -> R + coef : (%,%) -> R + coerce : vl -> % + constant : % -> R + constant? : % -> Boolean + lquo : (%,vl) -> % + lquo : (%,%) -> % + lquo : (%,OrderedFreeMonoid vl) -> % + map : ((R -> R),%) -> % + mindeg : % -> OrderedFreeMonoid vl + mindegTerm : % -> Record(k: OrderedFreeMonoid vl,c: R) + mirror : % -> % + monom : (OrderedFreeMonoid vl,R) -> % + monomial? : % -> Boolean + quasiRegular : % -> % + quasiRegular? : % -> Boolean + rquo : (%,OrderedFreeMonoid vl) -> % + rquo : (%,%) -> % + rquo : (%,vl) -> % + sh : (%,NonNegativeInteger) -> % if R has COMRING + sh : (%,%) -> % if R has COMRING + varList : % -> List vl + ?*? : (vl,%) -> % + ?*? : (%,R) -> % +\end{verbatim} + +These exports come from \refto{Ring}(): +\begin{verbatim} + 0 : () -> % + 1 : () -> % + characteristic : () -> NonNegativeInteger + coerce : % -> OutputForm + coerce : Integer -> % + hash : % -> SingleInteger + latex : % -> String + one? : % -> Boolean + recip : % -> Union(%,"failed") + sample : () -> % + subtractIfCan : (%,%) -> Union(%,"failed") + zero? : % -> Boolean + ?+? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (NonNegativeInteger,%) -> % + ?*? : (PositiveInteger,%) -> % + ?*? : (Integer,%) -> % + ?*? : (%,%) -> % + ?-? : (%,%) -> % + -? : % -> % + ?**? : (%,PositiveInteger) -> % + ?**? : (%,NonNegativeInteger) -> % + ?^? : (%,NonNegativeInteger) -> % + ?^? : (%,PositiveInteger) -> % +\end{verbatim} + +These exports come from \refto{XAlgebra}(a:Ring): +\begin{verbatim} + coerce : R -> % + ?*? : (R,%) -> % +\end{verbatim} + +These exports come from \refto{RetractableTo}(WORD)\\ +where WORD:OrderedFreeMonoid(OrderedSet)) +\begin{verbatim} + coerce : OrderedFreeMonoid vl -> % + retract : % -> OrderedFreeMonoid vl + retractIfCan : % -> Union(OrderedFreeMonoid vl,"failed") +\end{verbatim} + +<>= +)abbrev category XFALG XFreeAlgebra +++ Author: Michel Petitot petitot@lifl.fr +++ Date Created: 91 +++ Date Last Updated: 7 Juillet 92 +++ Fix History: compilation v 2.1 le 13 dec 98 +++ Basic Functions: +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: +++ This category specifies opeations for polynomials +++ and formal series with non-commutative variables. +++ Author: Michel Petitot (petitot@lifl.fr) + +XFreeAlgebra(vl:OrderedSet,R:Ring):Category == Catdef where + WORD ==> OrderedFreeMonoid(vl) -- monoide libre + NNI ==> NonNegativeInteger + I ==> Integer + TERM ==> Record(k: WORD, c: R) + + Catdef == Join(Ring, XAlgebra(R), RetractableTo WORD) + with + "*": (vl,%) -> % + ++ \spad{v * x} returns the product of a variable \spad{x} + ++ by \spad{x}. + "*": (%, R) -> % + ++ \spad{x * r} returns the product of \spad{x} by \spad{r}. + ++ Usefull if \spad{R} is a non-commutative Ring. + mindeg: % -> WORD + ++ \spad{mindeg(x)} returns the little word which appears + ++ in \spad{x}. Error if \spad{x=0}. + mindegTerm: % -> TERM + ++ \spad{mindegTerm(x)} returns the term whose word is + ++ \spad{mindeg(x)}. + coef : (%,WORD) -> R + ++ \spad{coef(x,w)} returns the coefficient of the word \spad{w} + ++ in \spad{x}. + coef : (%,%) -> R + ++ \spad{coef(x,y)} returns scalar product of \spad{x} by \spad{y}, + ++ the set of words being regarded as an orthogonal basis. + lquo : (%,vl) -> % + ++ \spad{lquo(x,v)} returns the left simplification of \spad{x} + ++ by the variable \spad{v}. + lquo : (%,WORD) -> % + ++ \spad{lquo(x,w)} returns the left simplification of \spad{x} + ++ by the word \spad{w}. + lquo : (%,%) -> % + ++ \spad{lquo(x,y)} returns the left simplification of \spad{x} + ++ by \spad{y}. + rquo : (%,vl) -> % + ++ \spad{rquo(x,v)} returns the right simplification of \spad{x} + ++ by the variable \spad{v}. + rquo : (%,WORD) -> % + ++ \spad{rquo(x,w)} returns the right simplification of \spad{x} + ++ by \spad{w}. + rquo : (%,%) -> % + ++ \spad{rquo(x,y)} returns the right simplification of \spad{x} + ++ by \spad{y}. + monom : (WORD , R) -> % + ++ \spad{monom(w,r)} returns the product of the word \spad{w} + ++ by the coefficient \spad{r}. + monomial? : % -> Boolean + ++ \spad{monomial?(x)} returns true if \spad{x} is a monomial + mirror: % -> % + ++ \spad{mirror(x)} returns \spad{Sum(r_i mirror(w_i))} if + ++ \spad{x} writes \spad{Sum(r_i w_i)}. + coerce : vl -> % + ++ \spad{coerce(v)} returns \spad{v}. + constant?:% -> Boolean + ++ \spad{constant?(x)} returns true if \spad{x} is constant. + constant: % -> R + ++ \spad{constant(x)} returns the constant term of \spad{x}. + quasiRegular? : % -> Boolean + ++ \spad{quasiRegular?(x)} return true if \spad{constant(x)} is zero + quasiRegular : % -> % + ++ \spad{quasiRegular(x)} return \spad{x} minus its constant term. + if R has CommutativeRing then + sh :(%,%) -> % + ++ \spad{sh(x,y)} returns the shuffle-product of \spad{x} + ++ by \spad{y}. + ++ This multiplication is associative and commutative. + sh :(%,NNI) -> % + ++ \spad{sh(x,n)} returns the shuffle power of \spad{x} to + ++ the \spad{n}. + map : (R -> R, %) -> % + ++ \spad{map(fn,x)} returns \spad{Sum(fn(r_i) w_i)} if \spad{x} + ++ writes \spad{Sum(r_i w_i)}. + varList: % -> List vl + ++ \spad{varList(x)} returns the list of variables which + ++ appear in \spad{x}. + + -- Attributs + if R has noZeroDivisors then noZeroDivisors + +@ +<>= +"XFALG" + [color=lightblue,href="bookvol10.2.pdf#nameddest=XFALG"]; +"XFALG" -> "RETRACT" +"XFALG" -> "RING" +"XFALG" -> "XALG" + +@ +<>= +"XFreeAlgebra(a:OrderedSet,b:Ring)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=XFALG"]; +"XFreeAlgebra(a:OrderedSet,b:Ring)" -> "Ring()" +"XFreeAlgebra(a:OrderedSet,b:Ring)" -> "XAlgebra(a:Ring)" +"XFreeAlgebra(a:OrderedSet,b:Ring)" -> + "RetractableTo(OrderedFreeMonoid(OrderedSet))" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"XFreeAlgebra(a:OrderedSet,b:Ring)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=XFALG"]; +"XFreeAlgebra(a:OrderedSet,b:Ring)" -> "Ring()" +"XFreeAlgebra(a:OrderedSet,b:Ring)" -> "XAlgebra(a:Ring)" +"XFreeAlgebra(a:OrderedSet,b:Ring)" -> + "RetractableTo(OrderedFreeMonoid(OrderedSet))" + +"RetractableTo(OrderedFreeMonoid(OrderedSet))" + [color=seagreen,href="bookvol10.2.pdf#nameddest=RETRACT"]; +"RetractableTo(OrderedFreeMonoid(OrderedSet))" -> "RetractableTo(a:Type)" + +"XAlgebra(a:Ring)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=XALG"]; +"XAlgebra(a:Ring)" -> "Ring()" +"XAlgebra(a:Ring)" -> "BiModule(a:Ring,b:Ring)" + +"Ring()" [color=lightblue]; +"Ring()" -> "Rng()" +"Ring()" -> "Monoid()" +"Ring()" -> "LeftModule(a:Ring)" + +"BiModule(a:Ring,b:Ring)" [color=lightblue]; +"BiModule(a:Ring,b:Ring)" -> "LeftModule(a:Ring)" +"BiModule(a:Ring,b:Ring)" -> "RightModule(a:Ring)" + +"RightModule(a:Ring)" [color=seagreen]; +"RightModule(a:Ring)" -> "RightModule(a:Rng)" + +"RightModule(a:Rng)" [color=lightblue]; +"RightModule(a:Rng)" -> "ABELGRP..." + +"Rng()" [color=lightblue]; +"Rng()" -> "ABELGRP..." +"Rng()" -> "SemiGroup()" + +"Monoid()" [color=lightblue]; +"Monoid()" -> "SemiGroup()" + +"LeftModule(a:Ring)" [color=seagreen]; +"LeftModule(a:Ring)" -> "LeftModule(a:Rng)" + +"LeftModule(a:Rng)" [color=lightblue]; +"LeftModule(a:Rng)" -> "ABELGRP..." + +"SemiGroup()" [color=lightblue]; +"SemiGroup()" -> "SETCAT..." +"SemiGroup()" -> "REPSQ..." + +"RetractableTo(a:Type)" [color=lightblue]; +"RetractableTo(a:Type)" -> "Category" + +"Category" [color=lightblue]; + +"REPSQ..." [color="#00EE00"]; +"SETCAT..." [color=lightblue]; +"ABELGRP..." [color=lightblue]; +} + +@ \chapter{Category Layer 11} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{Algebra}{ALGEBRA} @@ -22819,6 +23799,159 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{LieAlgebra}{LIECAT} +\pagepic{ps/v102liealgebra.ps}{LIECAT}{1.00} + +{\bf See:}\\ +\pageto{FreeLieAlgebra}{FLALG} +\pagefrom{Module}{MODULE} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{LIECAT}{0} & +\cross{LIECAT}{coerce} & +\cross{LIECAT}{construct} & +\cross{LIECAT}{hash} & +\cross{LIECAT}{latex} \\ +\cross{LIECAT}{sample} & +\cross{LIECAT}{subtractIfCan} & +\cross{LIECAT}{zero?} & +\cross{LIECAT}{?\~{}=?} & +\cross{LIECAT}{?/?} \\ +\cross{LIECAT}{?*?} & +\cross{LIECAT}{?+?} & +\cross{LIECAT}{?-?} & +\cross{LIECAT}{-?} & +\cross{LIECAT}{?=?} \\ +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item {\bf \cross{LIECAT}{NullSquare}} +means that $[x,x] = 0$ holds. See {\tt LieAlgebra}. +\item {\bf \cross{LIECAT}{JacobiIdentity}} +means that $[x,[y,z]]+[y,[z,x]]+[z,[x,y]] = 0$ holds. +See {\tt LieAlgebra}. +\item {\bf \cross{LIECAT}{leftUnitary}} +is true if $1 * x = x$ for all x. +\item {\bf \cross{LIECAT}{rightUnitary}} +is true if $x * 1 = x$ for all x. +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + construct : (%,%) -> % +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + ?/? : (%,R) -> % if R has FIELD +\end{verbatim} + +These exports come from \refto{Module}(R:Ring): +\begin{verbatim} + 0 : () -> % + coerce : % -> OutputForm + hash : % -> SingleInteger + latex : % -> String + sample : () -> % + subtractIfCan : (%,%) -> Union(%,"failed") + zero? : % -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (NonNegativeInteger,%) -> % + ?*? : (%,R) -> % + ?*? : (R,%) -> % + ?*? : (Integer,%) -> % + ?*? : (PositiveInteger,%) -> % + ?+? : (%,%) -> % + ?-? : (%,%) -> % + -? : % -> % + ?=? : (%,%) -> Boolean +\end{verbatim} + +<>= +)abbrev category LIECAT LieAlgebra +++ Author: Michel Petitot (petitot@lifl.fr). +++ Date Created: 91 +++ Date Last Updated: 7 Juillet 92 +++ Fix History: compilation v 2.1 le 13 dec 98 +++ Basic Functions: +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: +++ The category of Lie Algebras. +++ It is used by the following domains of non-commutative algebra: +++ \axiomType{LiePolynomial} and +++ \axiomType{XPBWPolynomial}. \newline +++ Author : Michel Petitot (petitot@lifl.fr). +LieAlgebra(R: CommutativeRing): Category == Module(R) with + NullSquare + ++ \axiom{NullSquare} means that \axiom{[x,x] = 0} holds. + JacobiIdentity + ++ \axiom{JacobiIdentity} means that + ++ \axiom{[x,[y,z]]+[y,[z,x]]+[z,[x,y]] = 0} holds. + construct: ($,$) -> $ + ++ \axiom{construct(x,y)} returns the Lie bracket of \axiom{x} + ++ and \axiom{y}. + if R has Field then + "/" : ($,R) -> $ + ++ \axiom{x/r} returns the division of \axiom{x} by \axiom{r}. + add + if R has Field then x / r == inv(r)$R * x + +@ +<>= +"LIECAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=LIECAT"]; +"LIECAT" -> "MODULE" + +@ +<>= +"LieAlgebra(a:CommutativeRing)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=LIECAT"]; +"LieAlgebra(a:CommutativeRing)" -> "Module(a:CommutativeRing)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"LieAlgebra(a:CommutativeRing)" [color=lightblue]; +"LieAlgebra(a:CommutativeRing)" -> "Module(a:CommutativeRing)" + +"Module(a:CommutativeRing)" [color=lightblue]; +"Module(a:CommutativeRing)" -> + "BiModule(a:CommutativeRing,b:CommutativeRing)" + +"BiModule(a:CommutativeRing,b:CommutativeRing)" [color=seagreen]; +"BiModule(a:CommutativeRing,b:CommutativeRing)" -> "BiModule(a:Ring,b:Ring)" + +"BiModule(a:Ring,b:Ring)" [color=lightblue]; +"BiModule(a:Ring,b:Ring)" -> "LeftModule(a:Ring)" +"BiModule(a:Ring,b:Ring)" -> "RightModule(a:Ring)" + +"RightModule(a:Ring)" [color=seagreen]; +"RightModule(a:Ring)" -> "RightModule(a:Rng)" + +"RightModule(a:Rng)" [color=lightblue]; +"RightModule(a:Rng)" -> "ABELGRP..." + +"LeftModule(a:Ring)" [color=seagreen]; +"LeftModule(a:Ring)" -> "LeftModule(a:Rng)" + +"LeftModule(a:Rng)" [color=lightblue]; +"LeftModule(a:Rng)" -> "ABELGRP..." + +"ABELGRP..." [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{NonAssociativeAlgebra}{NAALG} \pagepic{ps/v102nonassociativealgebra.ps}{NAALG}{0.75} @@ -23129,6 +24262,260 @@ digraph pic { } @ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{XPolynomialsCat}{XPOLYC} +\pagepic{ps/v102xpolynomialscat.ps}{XPOLYC}{0.50} + +{\bf See:}\\ +\pagefrom{XFreeAlgebra}{XFALG} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{XPOLYC}{0} & +\cross{XPOLYC}{1} & +\cross{XPOLYC}{characteristic} & +\cross{XPOLYC}{coef} & +\cross{XPOLYC}{coerce} \\ +\cross{XPOLYC}{constant} & +\cross{XPOLYC}{constant?} & +\cross{XPOLYC}{degree} & +\cross{XPOLYC}{hash} & +\cross{XPOLYC}{latex} \\ +\cross{XPOLYC}{lquo} & +\cross{XPOLYC}{map} & +\cross{XPOLYC}{maxdeg} & +\cross{XPOLYC}{mindeg} & +\cross{XPOLYC}{mindegTerm} \\ +\cross{XPOLYC}{mirror} & +\cross{XPOLYC}{monom} & +\cross{XPOLYC}{monomial?} & +\cross{XPOLYC}{one?} & +\cross{XPOLYC}{quasiRegular} \\ +\cross{XPOLYC}{quasiRegular?} & +\cross{XPOLYC}{recip} & +\cross{XPOLYC}{retract} & +\cross{XPOLYC}{retractIfCan} & +\cross{XPOLYC}{rquo} \\ +\cross{XPOLYC}{sample} & +\cross{XPOLYC}{sh} & +\cross{XPOLYC}{subtractIfCan} & +\cross{XPOLYC}{trunc} & +\cross{XPOLYC}{varList} \\ +\cross{XPOLYC}{zero?} & +\cross{XPOLYC}{?*?} & +\cross{XPOLYC}{?**?} & +\cross{XPOLYC}{?+?} & +\cross{XPOLYC}{?-?} \\ +\cross{XPOLYC}{-?} & +\cross{XPOLYC}{?=?} & +\cross{XPOLYC}{?\^{}?} & +\cross{XPOLYC}{?\~{}=?} & +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item if Ring has noZeroDivisors then noZeroDivisors where +{\bf \cross{FIELD}{noZeroDivisors}} +is true if $x * y \ne 0$ implies both x and y are non-zero. +\item {\bf \cross{FIELD}{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{FIELD}{leftUnitary}} +is true if $1 * x = x$ for all x. +\item {\bf \cross{FIELD}{rightUnitary}} +is true if $x * 1 = x$ for all x. +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + degree : % -> NonNegativeInteger + maxdeg : % -> OrderedFreeMonoid vl + trunc : (%,NonNegativeInteger) -> % +\end{verbatim} + +These exports come from \refto{Aggregate}(): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{XFreeAlgebra}(vl:OrderedSet,R:Ring): +\begin{verbatim} + 0 : () -> % + 1 : () -> % + characteristic : () -> NonNegativeInteger + coef : (%,OrderedFreeMonoid vl) -> R + coef : (%,%) -> R + coerce : % -> OutputForm + coerce : R -> % + coerce : OrderedFreeMonoid vl -> % + coerce : Integer -> % + coerce : vl -> % + constant : % -> R + constant? : % -> Boolean + hash : % -> SingleInteger + latex : % -> String + lquo : (%,OrderedFreeMonoid vl) -> % + lquo : (%,%) -> % + lquo : (%,vl) -> % + map : ((R -> R),%) -> % + mindeg : % -> OrderedFreeMonoid vl + mindegTerm : % -> Record(k: OrderedFreeMonoid vl,c: R) + mirror : % -> % + monom : (OrderedFreeMonoid vl,R) -> % + monomial? : % -> Boolean + one? : % -> Boolean + quasiRegular : % -> % + quasiRegular? : % -> Boolean + recip : % -> Union(%,"failed") + retract : % -> OrderedFreeMonoid vl + retractIfCan : % -> Union(OrderedFreeMonoid vl,"failed") + rquo : (%,OrderedFreeMonoid vl) -> % + rquo : (%,%) -> % + rquo : (%,vl) -> % + sample : () -> % + sh : (%,NonNegativeInteger) -> % if R has COMRING + sh : (%,%) -> % if R has COMRING + subtractIfCan : (%,%) -> Union(%,"failed") + varList : % -> List vl + zero? : % -> Boolean + ?+? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (NonNegativeInteger,%) -> % + ?*? : (PositiveInteger,%) -> % + ?*? : (Integer,%) -> % + ?*? : (%,%) -> % + ?*? : (R,%) -> % + ?*? : (%,R) -> % + ?-? : (%,%) -> % + -? : % -> % + ?**? : (%,PositiveInteger) -> % + ?**? : (%,NonNegativeInteger) -> % + ?^? : (%,NonNegativeInteger) -> % + ?^? : (%,PositiveInteger) -> % + ?*? : (vl,%) -> % +\end{verbatim} + +These exports come from \refto{SetCategory}(): +\begin{verbatim} +\end{verbatim} + +<>= +)abbrev category XPOLYC XPolynomialsCat +++ Author: Michel Petitot petitot@lifl.fr +++ Date Created: 91 +++ Date Last Updated: 7 Juillet 92 +++ Fix History: compilation v 2.1 le 13 dec 98 +++ Basic Functions: +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: +++ The Category of polynomial rings with non-commutative variables. +++ The coefficient ring may be non-commutative too. +++ However coefficients commute with vaiables. +++ Author: Michel Petitot (petitot@lifl.fr) + +XPolynomialsCat(vl:OrderedSet,R:Ring):Category == Export where + WORD ==> OrderedFreeMonoid(vl) + + Export == XFreeAlgebra(vl,R) with + maxdeg: % -> WORD + ++ \spad{maxdeg(p)} returns the greatest leading word in the + ++ support of \spad{p}. + degree: % -> NonNegativeInteger + ++ \spad{degree(p)} returns the degree of \spad{p}. + ++ Note that the degree of a word is its length. + trunc : (% , NonNegativeInteger) -> % + ++ \spad{trunc(p,n)} returns the polynomial \spad{p} truncated + ++ at order \spad{n}. + +@ +<>= +"XPOLYC" + [color=lightblue,href="bookvol10.2.pdf#nameddest=XPOLYC"]; +"XPOLYC" -> "XFALG" + +@ +<>= +"XPolynomialsCat(a:OrderedRing,b:Ring)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=XPOLYC"]; +"XPolynomialsCat(a:OrderedRing,b:Ring)" -> + "XFreeAlgebra(a:OrderedSet,b:Ring)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"XPolynomialsCat(a:OrderedRing,b:Ring)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=XPOLYC"]; +"XPolynomialsCat(a:OrderedRing,b:Ring)" -> + "XFreeAlgebra(a:OrderedSet,b:Ring)" + +"XFreeAlgebra(a:OrderedSet,b:Ring)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=XFALG"]; +"XFreeAlgebra(a:OrderedSet,b:Ring)" -> "Ring()" +"XFreeAlgebra(a:OrderedSet,b:Ring)" -> "XAlgebra(a:Ring)" +"XFreeAlgebra(a:OrderedSet,b:Ring)" -> + "RetractableTo(OrderedFreeMonoid(OrderedSet))" + +"RetractableTo(OrderedFreeMonoid(OrderedSet))" + [color=seagreen,href="bookvol10.2.pdf#nameddest=RETRACT"]; +"RetractableTo(OrderedFreeMonoid(OrderedSet))" -> "RetractableTo(a:Type)" + +"XAlgebra(a:Ring)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=XALG"]; +"XAlgebra(a:Ring)" -> "Ring()" +"XAlgebra(a:Ring)" -> "BiModule(a:Ring,b:Ring)" + +"Ring()" [color=lightblue]; +"Ring()" -> "Rng()" +"Ring()" -> "Monoid()" +"Ring()" -> "LeftModule(a:Ring)" + +"BiModule(a:Ring,b:Ring)" [color=lightblue]; +"BiModule(a:Ring,b:Ring)" -> "LeftModule(a:Ring)" +"BiModule(a:Ring,b:Ring)" -> "RightModule(a:Ring)" + +"RightModule(a:Ring)" [color=seagreen]; +"RightModule(a:Ring)" -> "RightModule(a:Rng)" + +"RightModule(a:Rng)" [color=lightblue]; +"RightModule(a:Rng)" -> "ABELGRP..." + +"Rng()" [color=lightblue]; +"Rng()" -> "ABELGRP..." +"Rng()" -> "SemiGroup()" + +"Monoid()" [color=lightblue]; +"Monoid()" -> "SemiGroup()" + +"LeftModule(a:Ring)" [color=seagreen]; +"LeftModule(a:Ring)" -> "LeftModule(a:Rng)" + +"LeftModule(a:Rng)" [color=lightblue]; +"LeftModule(a:Rng)" -> "ABELGRP..." + +"SemiGroup()" [color=lightblue]; +"SemiGroup()" -> "SETCAT..." +"SemiGroup()" -> "REPSQ..." + +"RetractableTo(a:Type)" [color=lightblue]; +"RetractableTo(a:Type)" -> "Category" + +"Category" [color=lightblue]; + +"REPSQ..." [color="#00EE00"]; +"SETCAT..." [color=lightblue]; +"ABELGRP..." [color=lightblue]; +} + +@ \chapter{Category Layer 12} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{DivisionRing}{DIVRING} @@ -24224,7 +25611,214 @@ digraph pic { } @ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{FreeLieAlgebra}{FLALG} +\pagepic{ps/v102freeliealgebra.ps}{FLALG}{1.00} + +{\bf See:}\\ +\pagefrom{LieAlgebra}{LIECAT} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{FLALG}{0} & +\cross{FLALG}{coef} & +\cross{FLALG}{coerce} & +\cross{FLALG}{construct} & +\cross{FLALG}{degree} \\ +\cross{FLALG}{eval} & +\cross{FLALG}{hash} & +\cross{FLALG}{latex} & +\cross{FLALG}{LiePoly} & +\cross{FLALG}{lquo} \\ +\cross{FLALG}{mirror} & +\cross{FLALG}{rquo} & +\cross{FLALG}{sample} & +\cross{FLALG}{subtractIfCan} & +\cross{FLALG}{trunc} \\ +\cross{FLALG}{varList} & +\cross{FLALG}{zero?} & +\cross{FLALG}{?\~{}=?} & +\cross{FLALG}{?*?} & +\cross{FLALG}{?/?} \\ +\cross{FLALG}{?+?} & +\cross{FLALG}{?-?} & +\cross{FLALG}{-?} & +\cross{FLALG}{?=?} & +\end{tabular} + + +{\bf Attributes Exported:} +\begin{itemize} +\item {\bf \cross{FLALG}{NullSquare}} +means that $[x,x] = 0$ holds. See {\tt LieAlgebra}. +\item {\bf \cross{FLALG}{JacobiIdentity}} +means that $[x,[y,z]]+[y,[z,x]]+[z,[x,y]] = 0$ holds. +See {\tt LieAlgebra}. +\item {\bf \cross{FLALG}{leftUnitary}} +is true if $1 * x = x$ for all x. +\item {\bf \cross{FLALG}{rightUnitary}} +is true if $x * 1 = x$ for all x. +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + coef : (XRecursivePolynomial(VarSet,R),%) -> R + coerce : VarSet -> % + coerce : % -> XRecursivePolynomial(VarSet,R) + coerce : % -> XDistributedPolynomial(VarSet,R) + degree : % -> NonNegativeInteger + eval : (%,List VarSet,List %) -> % + eval : (%,VarSet,%) -> % + LiePoly : LyndonWord VarSet -> % + lquo : (XRecursivePolynomial(VarSet,R),%) -> XRecursivePolynomial(VarSet,R) + mirror : % -> % + rquo : (XRecursivePolynomial(VarSet,R),%) -> XRecursivePolynomial(VarSet,R) + trunc : (%,NonNegativeInteger) -> % + varList : % -> List VarSet +\end{verbatim} + +These exports come from \refto{LieAlgebra}(CommutativeRing): +\begin{verbatim} + 0 : () -> % + coerce : % -> OutputForm + construct : (%,%) -> % + hash : % -> SingleInteger + latex : % -> String + sample : () -> % + subtractIfCan : (%,%) -> Union(%,"failed") + zero? : % -> Boolean + ?/? : (%,R) -> % if R has FIELD + ?~=? : (%,%) -> Boolean + ?*? : (NonNegativeInteger,%) -> % + ?*? : (%,R) -> % + ?*? : (R,%) -> % + ?*? : (Integer,%) -> % + ?*? : (PositiveInteger,%) -> % + ?+? : (%,%) -> % + ?-? : (%,%) -> % + -? : % -> % + ?=? : (%,%) -> Boolean +\end{verbatim} + +<>= +)abbrev category FLALG FreeLieAlgebra +++ Author: Michel Petitot (petitot@lifl.fr) +++ Date Created: 91 +++ Date Last Updated: 7 Juillet 92 +++ Fix History: compilation v 2.1 le 13 dec 98 +++ Basic Functions: +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: +++ The category of free Lie algebras. +++ It is used by domains of non-commutative algebra: +++ \spadtype{LiePolynomial} and +++ \spadtype{XPBWPolynomial}. \newline Author: Michel Petitot (petitot@lifl.fr) + +FreeLieAlgebra(VarSet:OrderedSet, R:CommutativeRing) :Category == _ + CatDef where + XRPOLY ==> XRecursivePolynomial(VarSet,R) + XDPOLY ==> XDistributedPolynomial(VarSet,R) + RN ==> Fraction Integer + LWORD ==> LyndonWord(VarSet) + + CatDef == Join(LieAlgebra(R)) with + coef : (XRPOLY , $) -> R + ++ \axiom{coef(x,y)} returns the scalar product of \axiom{x} by + ++ \axiom{y}, the set of words being regarded as an orthogonal basis. + coerce : VarSet -> $ + ++ \axiom{coerce(x)} returns \axiom{x} as a Lie polynomial. + coerce : $ -> XDPOLY + ++ \axiom{coerce(x)} returns \axiom{x} as distributed polynomial. + coerce : $ -> XRPOLY + ++ \axiom{coerce(x)} returns \axiom{x} as a recursive polynomial. + degree : $ -> NonNegativeInteger + ++ \axiom{degree(x)} returns the greatest length of a word in the + ++ support of \axiom{x}. + --if R has Module(RN) then + -- Hausdorff : ($,$,PositiveInteger) -> $ + lquo : (XRPOLY , $) -> XRPOLY + ++ \axiom{lquo(x,y)} returns the left simplification of \axiom{x} + ++ by \axiom{y}. + rquo : (XRPOLY , $) -> XRPOLY + ++ \axiom{rquo(x,y)} returns the right simplification of \axiom{x} + ++ by \axiom{y}. + LiePoly : LWORD -> $ + ++ \axiom{LiePoly(l)} returns the bracketed form of \axiom{l} as + ++ a Lie polynomial. + mirror : $ -> $ + ++ \axiom{mirror(x)} returns \axiom{Sum(r_i mirror(w_i))} + ++ if \axiom{x} is \axiom{Sum(r_i w_i)}. + trunc : ($, NonNegativeInteger) -> $ + ++ \axiom{trunc(p,n)} returns the polynomial \axiom{p} + ++ truncated at order \axiom{n}. + varList : $ -> List VarSet + ++ \axiom{varList(x)} returns the list of distinct entries + ++ of \axiom{x}. + eval : ($, VarSet, $) -> $ + ++ \axiom{eval(p, x, v)} replaces \axiom{x} by \axiom{v} + ++ in \axiom{p}. + eval : ($, List VarSet, List $) -> $ + ++ \axiom{eval(p, [x1,...,xn], [v1,...,vn])} replaces \axiom{xi} + ++ by \axiom{vi} in \axiom{p}. + +@ +<>= +"FLALG" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FLALG"]; +"FLALG" -> "LIECAT" + +@ +<>= +"FreeLieAlgebra(a:OrderedSet,b:CommutativeRing)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FLALG"]; +"FreeLieAlgebra(a:OrderedSet,b:CommutativeRing)" -> + "LieAlgebra(a:CommutativeRing)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"FreeLieAlgebra(a:OrderedSet,b:CommutativeRing)" [color=lightblue]; +"FreeLieAlgebra(a:OrderedSet,b:CommutativeRing)" -> + "LieAlgebra(a:CommutativeRing)" + +"LieAlgebra(a:CommutativeRing)" [color=lightblue]; +"LieAlgebra(a:CommutativeRing)" -> "Module(a:CommutativeRing)" + +"Module(a:CommutativeRing)" [color=lightblue]; +"Module(a:CommutativeRing)" -> + "BiModule(a:CommutativeRing,b:CommutativeRing)" + +"BiModule(a:CommutativeRing,b:CommutativeRing)" [color=seagreen]; +"BiModule(a:CommutativeRing,b:CommutativeRing)" -> "BiModule(a:Ring,b:Ring)" + +"BiModule(a:Ring,b:Ring)" [color=lightblue]; +"BiModule(a:Ring,b:Ring)" -> "LeftModule(a:Ring)" +"BiModule(a:Ring,b:Ring)" -> "RightModule(a:Ring)" + +"RightModule(a:Ring)" [color=seagreen]; +"RightModule(a:Ring)" -> "RightModule(a:Rng)" + +"RightModule(a:Rng)" [color=lightblue]; +"RightModule(a:Rng)" -> "ABELGRP..." + +"LeftModule(a:Ring)" [color=seagreen]; +"LeftModule(a:Ring)" -> "LeftModule(a:Rng)" + +"LeftModule(a:Rng)" [color=lightblue]; +"LeftModule(a:Rng)" -> "ABELGRP..." +"ABELGRP..." [color=lightblue]; +} + +@ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{IntegralDomain}{INTDOM} \pagepic{ps/v102integraldomain.ps}{INTDOM}{0.65} @@ -24503,7 +26097,7 @@ digraph pic { {\bf Attributes Exported:} \begin{itemize} \item {\bf \cross{FMTC}{noZeroDivisors}} -is true if $x * y ~= 0$ implies both x and y are non-zero. +is true if $x * y \ne 0$ implies both x and y are non-zero. \item {\bf \cross{FMTC}{commutative("*")}} is true if it has an operation $"*": (D,D) -> D$ which is commutative. @@ -26686,6 +28280,7 @@ digraph pic { \pageto{ExtensionField}{XF} \pageto{FieldOfPrimeCharacteristic}{FPC} \pageto{FiniteRankAlgebra}{FINRALG} +\pageto{RealNumberSystem}{RNS} \pageto{UnivariatePolynomialCategory}{UPOLYC} \pagefrom{DivisionRing}{DIVRING} \pagefrom{EuclideanDomain}{EUCDOM} @@ -28561,6 +30156,352 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{RealNumberSystem}{RNS} +\pagepic{ps/v102realnumbersystem.ps}{RNS}{0.40} + +{\bf See:}\\ +\pageto{FloatingPointSystem}{FPS} +\pagefrom{CharacteristicZero}{CHARZ} +\pagefrom{ConvertibleTo}{KONVERT} +\pagefrom{Field}{FIELD} +\pagefrom{OrderedRing}{ORDRING} +\pagefrom{PatternMatchable}{PATMAB} +\pagefrom{RadicalCategory}{RADCAT} +\pagefrom{RealConstant}{REAL} +\pagefrom{RetractableTo}{RETRACT} + +{\bf Exports:}\\ +\begin{tabular}{llll} +\cross{RNS}{0} & +\cross{RNS}{1} & +\cross{RNS}{abs} & +\cross{RNS}{associates?} \\ +\cross{RNS}{ceiling} & +\cross{RNS}{characteristic} & +\cross{RNS}{coerce} & +\cross{RNS}{convert} \\ +\cross{RNS}{divide} & +\cross{RNS}{euclideanSize} & +\cross{RNS}{expressIdealMember} & +\cross{RNS}{exquo} \\ +\cross{RNS}{extendedEuclidean} & +\cross{RNS}{factor} & +\cross{RNS}{floor} & +\cross{RNS}{fractionPart} \\ +\cross{RNS}{gcd} & +\cross{RNS}{gcdPolynomial} & +\cross{RNS}{hash} & +\cross{RNS}{inv} \\ +\cross{RNS}{latex} & +\cross{RNS}{lcm} & +\cross{RNS}{max} & +\cross{RNS}{min} \\ +\cross{RNS}{multiEuclidean} & +\cross{RNS}{negative?} & +\cross{RNS}{norm} & +\cross{RNS}{nthRoot} \\ +\cross{RNS}{one?} & +\cross{RNS}{patternMatch} & +\cross{RNS}{positive?} & +\cross{RNS}{prime?} \\ +\cross{RNS}{principalIdeal} & +\cross{RNS}{recip} & +\cross{RNS}{retract} & +\cross{RNS}{retractIfCan} \\ +\cross{RNS}{round} & +\cross{RNS}{sample} & +\cross{RNS}{sign} & +\cross{RNS}{sizeLess?} \\ +\cross{RNS}{sqrt} & +\cross{RNS}{squareFree} & +\cross{RNS}{squareFreePart} & +\cross{RNS}{subtractIfCan} \\ +\cross{RNS}{truncate} & +\cross{RNS}{unit?} & +\cross{RNS}{unitCanonical} & +\cross{RNS}{unitNormal} \\ +\cross{RNS}{wholePart} & +\cross{RNS}{zero?} & +\cross{RNS}{?*?} & +\cross{RNS}{?**?} \\ +\cross{RNS}{?+?} & +\cross{RNS}{?-?} & +\cross{RNS}{-?} & +\cross{RNS}{?/?} \\ +\cross{RNS}{?$<$?} & +\cross{RNS}{?$<=$?} & +\cross{RNS}{?=?} & +\cross{RNS}{?$>$?} \\ +\cross{RNS}{?$>=$?} & +\cross{RNS}{?\^{}?} & +\cross{RNS}{?quo?} & +\cross{RNS}{?rem?} \\ +\cross{RNS}{?\~{}=?} && +\end{tabular} + +These are directly exported but not implemented: +\begin{verbatim} + abs : % -> % + wholePart : % -> Integer +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + characteristic : () -> NonNegativeInteger + ceiling : % -> % + coerce : Fraction Integer -> % + convert : % -> Pattern Float + floor : % -> % + fractionPart : % -> % + norm : % -> % + patternMatch : + (%,Pattern Float,PatternMatchResult(Float,%)) -> + PatternMatchResult(Float,%) + round : % -> % + truncate : % -> % +\end{verbatim} + +These exports come from \refto{Field}(): +\begin{verbatim} + 0 : () -> % + 1 : () -> % + associates? : (%,%) -> Boolean + coerce : % -> % + coerce : Integer -> % + coerce : Integer -> % + coerce : Fraction Integer -> % + coerce : % -> OutputForm + divide : (%,%) -> Record(quotient: %,remainder: %) + euclideanSize : % -> NonNegativeInteger + expressIdealMember : (List %,%) -> Union(List %,"failed") + extendedEuclidean : (%,%,%) -> Union(Record(coef1: %,coef2: %),"failed") + extendedEuclidean : (%,%) -> Record(coef1: %,coef2: %,generator: %) + exquo : (%,%) -> Union(%,"failed") + factor : % -> Factored % + gcd : List % -> % + gcd : (%,%) -> % + gcdPolynomial : + (SparseUnivariatePolynomial %, + SparseUnivariatePolynomial %) -> + SparseUnivariatePolynomial % + hash : % -> SingleInteger + inv : % -> % + latex : % -> String + lcm : List % -> % + lcm : (%,%) -> % + multiEuclidean : (List %,%) -> Union(List %,"failed") + one? : % -> Boolean + prime? : % -> Boolean + principalIdeal : List % -> Record(coef: List %,generator: %) + recip : % -> Union(%,"failed") + sample : () -> % + sizeLess? : (%,%) -> Boolean + squareFree : % -> Factored % + squareFreePart : % -> % + subtractIfCan : (%,%) -> Union(%,"failed") + unit? : % -> Boolean + unitCanonical : % -> % + unitNormal : % -> Record(unit: %,canonical: %,associate: %) + zero? : % -> Boolean + ?+? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (Fraction Integer,%) -> % + ?*? : (%,Fraction Integer) -> % + ?**? : (%,Fraction Integer) -> % + ?^? : (%,Integer) -> % + ?*? : (%,%) -> % + ?*? : (Integer,%) -> % + ?*? : (PositiveInteger,%) -> % + ?*? : (NonNegativeInteger,%) -> % + ?-? : (%,%) -> % + -? : % -> % + ?**? : (%,PositiveInteger) -> % + ?**? : (%,NonNegativeInteger) -> % + ?^? : (%,NonNegativeInteger) -> % + ?^? : (%,PositiveInteger) -> % + ?/? : (%,%) -> % + ?quo? : (%,%) -> % + ?rem? : (%,%) -> % +\end{verbatim} + +These exports come from \refto{OrderedRing}(): +\begin{verbatim} + negative? : % -> Boolean + positive? : % -> Boolean + sign : % -> Integer + max : (%,%) -> % + min : (%,%) -> % + ? Boolean + ?<=? : (%,%) -> Boolean + ?>? : (%,%) -> Boolean + ?>=? : (%,%) -> Boolean +\end{verbatim} + +These exports come from \refto{RealConstant}(): +\begin{verbatim} + convert : % -> DoubleFloat + convert : % -> Float +\end{verbatim} + +These exports come from \refto{RetractableTo}(Integer): +\begin{verbatim} + retract : % -> Integer + retractIfCan : % -> Union(Integer,"failed") +\end{verbatim} + +These exports come from \refto{RetractableTo}(Fraction(Integer)): +\begin{verbatim} + retract : % -> Fraction Integer + retractIfCan : % -> Union(Fraction Integer,"failed") +\end{verbatim} + +These exports come from \refto{RadicalCategory}(): +\begin{verbatim} + nthRoot : (%,Integer) -> % + sqrt : % -> % +\end{verbatim} + +These exports come from \refto{ConvertibleTo}(Pattern(Float)): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{PatternMatchable}(Float): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{CharacteristicZero}(): +\begin{verbatim} +\end{verbatim} + +<>= +)abbrev category RNS RealNumberSystem +++ Author: Michael Monagan and Stephen M. Watt +++ Date Created: +++ January 1988 +++ Change History: +++ Basic Operations: abs, ceiling, wholePart, floor, fractionPart, norm, round, truncate +++ Related Constructors: +++ Keywords: real numbers +++ Description: +++ The real number system category is intended as a model for the real +++ numbers. The real numbers form an ordered normed field. Note that +++ we have purposely not included \spadtype{DifferentialRing} or +++ the elementary functions (see \spadtype{TranscendentalFunctionCategory}) +++ in the definition. +RealNumberSystem(): Category == + Join(Field, OrderedRing, RealConstant, RetractableTo Integer, + RetractableTo Fraction Integer, RadicalCategory, + ConvertibleTo Pattern Float, PatternMatchable Float, + CharacteristicZero) with + norm : % -> % + ++ norm x returns the same as absolute value. + ceiling : % -> % + ++ ceiling x returns the small integer \spad{>= x}. + floor: % -> % + ++ floor x returns the largest integer \spad{<= x}. + wholePart : % -> Integer + ++ wholePart x returns the integer part of x. + fractionPart : % -> % + ++ fractionPart x returns the fractional part of x. + truncate: % -> % + ++ truncate x returns the integer between x and 0 closest to x. + round: % -> % + ++ round x computes the integer closest to x. + abs : % -> % + ++ abs x returns the absolute value of x. + add + characteristic() == 0 + + fractionPart x == x - truncate x + + truncate x == (negative? x => -floor(-x); floor x) + + round x == (negative? x => truncate(x-1/2::%); truncate(x+1/2::%)) + + norm x == abs x + + coerce(x:Fraction Integer):% == numer(x)::% / denom(x)::% + + convert(x:%):Pattern(Float) == convert(x)@Float :: Pattern(Float) + + floor x == + x1 := (wholePart x) :: % + x = x1 => x + x < 0 => (x1 - 1) + x1 + + ceiling x == + x1 := (wholePart x)::% + x = x1 => x + x >= 0 => (x1 + 1) + x1 + + patternMatch(x, p, l) == + generic? p => addMatch(p, x, l) + constant? p => + (r := retractIfCan(p)@Union(Float, "failed")) case Float => + convert(x)@Float = r::Float => l + failed() + failed() + failed() + +@ +<>= +"RNS" + [color=lightblue,href="bookvol10.2.pdf#nameddest=RNS"]; +"RNS" -> "FIELD" +"RNS" -> "ORDRING" +"RNS" -> "REAL" +"RNS" -> "RETRACT" +"RNS" -> "RADCAT" +"RNS" -> "KONVERT" +"RNS" -> "PATMAB" +"RNS" -> "CHARZ" + +@ +<>= +"RealNumberSystem()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=RNS"]; +"RealNumberSystem()" -> "Field()" +"RealNumberSystem()" -> "OrderedRing()" +"RealNumberSystem()" -> "RealConstant()" +"RealNumberSystem()" -> "RetractableTo(Integer)" +"RealNumberSystem()" -> "RetractableTo(Fraction(Integer))" +"RealNumberSystem()" -> "RadicalCategory()" +"RealNumberSystem()" -> "ConvertibleTo(Pattern(Float))" +"RealNumberSystem()" -> "PatternMatchable(Float)" +"RealNumberSystem()" -> "CharacteristicZero()" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"RealNumberSystem()" [color=lightblue]; +"RealNumberSystem()" -> "FIELD..." +"RealNumberSystem()" -> "ORDRING..." +"RealNumberSystem()" -> "REAL..." +"RealNumberSystem()" -> "RETRACT..." +"RealNumberSystem()" -> "RADCAT..." +"RealNumberSystem()" -> "KONVERT..." +"RealNumberSystem()" -> "PATMAB..." +"RealNumberSystem()" -> "CHARZ..." + +"FIELD..." [color=lightblue]; +"ORDRING..." [color=lightblue]; +"REAL..." [color=lightblue]; +"RETRACT..." [color=lightblue]; +"RADCAT..." [color=lightblue]; +"KONVERT..." [color=lightblue]; +"PATMAB..." [color=lightblue]; +"CHARZ..." [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{UnivariatePolynomialCategory}{UPOLYC} \pagepic{ps/v102univariatepolynomialcategory.ps}{UPOLYC}{0.35} @@ -29873,7 +31814,7 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{FiniteFieldCategory}{FFIELDC} -\pagepic{ps/v102finitefieldcategory.ps}{FFIELDC}{1.00} +\pagepic{ps/v102finitefieldcategory.ps}{FFIELDC}{0.60} {\bf See:}\\ \pagefrom{DifferentialRing}{DIFRING} @@ -29882,68 +31823,68 @@ digraph pic { \pagefrom{StepThrough}{STEP} {\bf Exports:}\\ -\begin{tabular}{lllll} +\begin{tabular}{lll} \cross{FFIELDC}{0} & \cross{FFIELDC}{1} & -\cross{FFIELDC}{associates?} & +\cross{FFIELDC}{associates?} \\ \cross{FFIELDC}{characteristic} & -\cross{FFIELDC}{charthRoot} \\ -\cross{FFIELDC}{coerce} & +\cross{FFIELDC}{charthRoot} & +\cross{FFIELDC}{coerce} \\ \cross{FFIELDC}{conditionP} & \cross{FFIELDC}{createPrimitiveElement} & -\cross{FFIELDC}{D} & -\cross{FFIELDC}{differentiate} \\ +\cross{FFIELDC}{D} \\ +\cross{FFIELDC}{differentiate} & \cross{FFIELDC}{discreteLog} & -\cross{FFIELDC}{divide} & +\cross{FFIELDC}{divide} \\ \cross{FFIELDC}{euclideanSize} & \cross{FFIELDC}{expressIdealMember} & \cross{FFIELDC}{exquo} \\ \cross{FFIELDC}{extendedEuclidean} & \cross{FFIELDC}{factor} & -\cross{FFIELDC}{factorsOfCyclicGroupSize} & +\cross{FFIELDC}{factorsOfCyclicGroupSize} \\ \cross{FFIELDC}{gcd} & -\cross{FFIELDC}{gcdPolynomial} \\ -\cross{FFIELDC}{hash} & +\cross{FFIELDC}{gcdPolynomial} & +\cross{FFIELDC}{hash} \\ \cross{FFIELDC}{index} & \cross{FFIELDC}{init} & -\cross{FFIELDC}{inv} & -\cross{FFIELDC}{latex} \\ +\cross{FFIELDC}{inv} \\ +\cross{FFIELDC}{latex} & \cross{FFIELDC}{lcm} & -\cross{FFIELDC}{lookup} & +\cross{FFIELDC}{lookup} \\ \cross{FFIELDC}{multiEuclidean} & \cross{FFIELDC}{nextItem} & \cross{FFIELDC}{one?} \\ \cross{FFIELDC}{order} & \cross{FFIELDC}{prime?} & -\cross{FFIELDC}{primeFrobenius} & +\cross{FFIELDC}{primeFrobenius} \\ \cross{FFIELDC}{primitive?} & -\cross{FFIELDC}{primitiveElement} \\ -\cross{FFIELDC}{principalIdeal} & +\cross{FFIELDC}{primitiveElement} & +\cross{FFIELDC}{principalIdeal} \\ \cross{FFIELDC}{random} & \cross{FFIELDC}{recip} & -\cross{FFIELDC}{representationType} & -\cross{FFIELDC}{sample} \\ +\cross{FFIELDC}{representationType} \\ +\cross{FFIELDC}{sample} & \cross{FFIELDC}{size} & -\cross{FFIELDC}{sizeLess?} & +\cross{FFIELDC}{sizeLess?} \\ \cross{FFIELDC}{squareFree} & \cross{FFIELDC}{squareFreePart} & \cross{FFIELDC}{subtractIfCan} \\ \cross{FFIELDC}{tableForDiscreteLogarithm} & \cross{FFIELDC}{unit?} & -\cross{FFIELDC}{unitCanonical} & +\cross{FFIELDC}{unitCanonical} \\ \cross{FFIELDC}{unitNormal} & -\cross{FFIELDC}{zero?} \\ -\cross{FFIELDC}{?*?} & +\cross{FFIELDC}{zero?} & +\cross{FFIELDC}{?*?} \\ \cross{FFIELDC}{?**?} & \cross{FFIELDC}{?+?} & -\cross{FFIELDC}{?-?} & -\cross{FFIELDC}{-?} \\ +\cross{FFIELDC}{?-?} \\ +\cross{FFIELDC}{-?} & \cross{FFIELDC}{?/?} & -\cross{FFIELDC}{?=?} & +\cross{FFIELDC}{?=?} \\ \cross{FFIELDC}{?\^{}?} & \cross{FFIELDC}{?quo?} & \cross{FFIELDC}{?rem?} \\ -\cross{FFIELDC}{?\~{}=?} &&&& +\cross{FFIELDC}{?\~{}=?} && \end{tabular} {\bf Attributes Exported:} @@ -30372,6 +32313,386 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{FloatingPointSystem}{FPS} +\pagepic{ps/v102floatingpointsystem.ps}{FPS}{0.40} + +{\bf See:}\\ +\pagefrom{RealNumberSystem}{RNS} + +{\bf Exports:}\\ +\begin{tabular}{llll} +\cross{FPS}{0} & +\cross{FPS}{1} & +\cross{FPS}{abs} & +\cross{FPS}{associates?} \\ +\cross{FPS}{base} & +\cross{FPS}{bits} & +\cross{FPS}{characteristic} & +\cross{FPS}{ceiling} \\ +\cross{FPS}{coerce} & +\cross{FPS}{convert} & +\cross{FPS}{decreasePrecision} & +\cross{FPS}{digits} \\ +\cross{FPS}{divide} & +\cross{FPS}{euclideanSize} & +\cross{FPS}{exponent} & +\cross{FPS}{expressIdealMember} \\ +\cross{FPS}{exquo} & +\cross{FPS}{extendedEuclidean} & +\cross{FPS}{factor} & +\cross{FPS}{float} \\ +\cross{FPS}{floor} & +\cross{FPS}{fractionPart} & +\cross{FPS}{gcd} & +\cross{FPS}{gcdPolynomial} \\ +\cross{FPS}{hash} & +\cross{FPS}{increasePrecision} & +\cross{FPS}{inv} & +\cross{FPS}{latex} \\ +\cross{FPS}{lcm} & +\cross{FPS}{mantissa} & +\cross{FPS}{max} & +\cross{FPS}{min} \\ +\cross{FPS}{multiEuclidean} & +\cross{FPS}{negative?} & +\cross{FPS}{norm} & +\cross{FPS}{nthRoot} \\ +\cross{FPS}{one?} & +\cross{FPS}{order} & +\cross{FPS}{patternMatch} & +\cross{FPS}{positive?} \\ +\cross{FPS}{precision} & +\cross{FPS}{prime?} & +\cross{FPS}{principalIdeal} & +\cross{FPS}{recip} \\ +\cross{FPS}{retract} & +\cross{FPS}{retractIfCan} & +\cross{FPS}{round} & +\cross{FPS}{sample} \\ +\cross{FPS}{sign} & +\cross{FPS}{sizeLess?} & +\cross{FPS}{sqrt} & +\cross{FPS}{squareFree} \\ +\cross{FPS}{squareFreePart} & +\cross{FPS}{subtractIfCan} & +\cross{FPS}{truncate} & +\cross{FPS}{unit?} \\ +\cross{FPS}{unitCanonical} & +\cross{FPS}{unitNormal} & +\cross{FPS}{wholePart} & +\cross{FPS}{zero?} \\ +\cross{FPS}{?*?} & +\cross{FPS}{?**?} & +\cross{FPS}{?+?} & +\cross{FPS}{?-?} \\ +\cross{FPS}{-?} & +\cross{FPS}{?/?} & +\cross{FPS}{?$<$?} & +\cross{FPS}{?$<=$?} \\ +\cross{FPS}{?=?} & +\cross{FPS}{?$>$?} & +\cross{FPS}{?$>=$?} & +\cross{FPS}{?\^{}?} \\ +\cross{FPS}{?\~{}=?} & +\cross{FPS}{?quo?} & +\cross{FPS}{?rem?} & +\end{tabular} + +{\bf Attributes Exported:} +\begin{itemize} +\item {\bf \cross{FPS}{approximate}} means ``is an approximation to +the real numbers''. +\item {\bf \cross{FPS}{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{FPS}{canonicalsClosed}} +is true if\\ +{\tt unitCanonical(a)*unitCanonical(b) = unitCanonical(a*b)}. +\item {\bf \cross{FPS}{noZeroDivisors}} +is true if $x * y \ne 0$ implies both x and y are non-zero. +\item {\bf \cross{FPS}{commutative("*")}} +is true if it has an operation $"*": (D,D) -> D$ +which is commutative. +\item {\bf \cross{FPS}{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{FPS}{leftUnitary}} +is true if $1 * x = x$ for all x. +\item {\bf \cross{FPS}{rightUnitary}} +is true if $x * 1 = x$ for all x. +\end{itemize} + +These are directly exported but not implemented: +\begin{verbatim} + base : () -> PositiveInteger + bits : () -> PositiveInteger + bits : PositiveInteger -> PositiveInteger + if $ has arbitraryPrecision + decreasePrecision : Integer -> PositiveInteger + if $ has arbitraryPrecision + digits : PositiveInteger -> PositiveInteger + if $ has arbitraryPrecision + exponent : % -> Integer + float : (Integer,Integer,PositiveInteger) -> % + increasePrecision : Integer -> PositiveInteger + if $ has arbitraryPrecision + mantissa : % -> Integer + max : () -> % + if not has($,arbitraryPrecision) + and not has($,arbitraryExponent) + min : () -> % + if not has($,arbitraryPrecision) + and not has($,arbitraryExponent) + order : % -> Integer + precision : () -> PositiveInteger + precision : PositiveInteger -> PositiveInteger + if $ has arbitraryPrecision +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + digits : () -> PositiveInteger + float : (Integer,Integer) -> % +\end{verbatim} + +These exports come from \refto{RealNumberSystem}(): +\begin{verbatim} + 0 : () -> % + 1 : () -> % + abs : % -> % + associates? : (%,%) -> Boolean + characteristic : () -> NonNegativeInteger + ceiling : % -> % + coerce : Fraction Integer -> % + coerce : Integer -> % + coerce : Fraction Integer -> % + coerce : % -> % + coerce : Integer -> % + coerce : % -> OutputForm + convert : % -> Pattern Float + convert : % -> DoubleFloat + convert : % -> Float + 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 % + floor : % -> % + fractionPart : % -> % + gcd : List % -> % + gcd : (%,%) -> % + gcdPolynomial : + (SparseUnivariatePolynomial %, + SparseUnivariatePolynomial %) -> + SparseUnivariatePolynomial % + hash : % -> SingleInteger + inv : % -> % + latex : % -> String + lcm : List % -> % + lcm : (%,%) -> % + max : (%,%) -> % + min : (%,%) -> % + multiEuclidean : (List %,%) -> Union(List %,"failed") + negative? : % -> Boolean + norm : % -> % + nthRoot : (%,Integer) -> % + one? : % -> Boolean + patternMatch : + (%,Pattern Float,PatternMatchResult(Float,%)) -> + PatternMatchResult(Float,%) + positive? : % -> Boolean + prime? : % -> Boolean + principalIdeal : List % -> Record(coef: List %,generator: %) + recip : % -> Union(%,"failed") + retract : % -> Fraction Integer + retract : % -> Integer + retractIfCan : % -> Union(Fraction Integer,"failed") + retractIfCan : % -> Union(Integer,"failed") + round : % -> % + sample : () -> % + sign : % -> Integer + sizeLess? : (%,%) -> Boolean + sqrt : % -> % + squareFree : % -> Factored % + squareFreePart : % -> % + subtractIfCan : (%,%) -> Union(%,"failed") + truncate : % -> % + unit? : % -> Boolean + unitCanonical : % -> % + unitNormal : % -> Record(unit: %,canonical: %,associate: %) + wholePart : % -> Integer + zero? : % -> Boolean + ?*? : (Fraction Integer,%) -> % + ?*? : (%,Fraction Integer) -> % + ?*? : (%,%) -> % + ?*? : (Integer,%) -> % + ?*? : (PositiveInteger,%) -> % + ?**? : (%,Fraction Integer) -> % + ?**? : (%,Integer) -> % + ?**? : (%,PositiveInteger) -> % + ?+? : (%,%) -> % + ?-? : (%,%) -> % + -? : % -> % + ?/? : (%,%) -> % + ? Boolean + ?<=? : (%,%) -> Boolean + ?=? : (%,%) -> Boolean + ?>? : (%,%) -> Boolean + ?>=? : (%,%) -> Boolean + ?^? : (%,Integer) -> % + ?^? : (%,PositiveInteger) -> % + ?~=? : (%,%) -> Boolean + ?*? : (NonNegativeInteger,%) -> % + ?**? : (%,NonNegativeInteger) -> % + ?^? : (%,NonNegativeInteger) -> % + ?quo? : (%,%) -> % + ?rem? : (%,%) -> % +\end{verbatim} + +<>= +)abbrev category FPS FloatingPointSystem +++ Author: +++ Date Created: +++ Change History: +++ Basic Operations: approximate, base, bits, digits, exponent, float, +++ mantissa, order, precision, round? +++ Related Constructors: +++ Keywords: float, floating point +++ Description: +++ This category is intended as a model for floating point systems. +++ A floating point system is a model for the real numbers. In fact, +++ it is an approximation in the sense that not all real numbers are +++ exactly representable by floating point numbers. +++ A floating point system is characterized by the following: +++ +++ 1: \spadfunFrom{base}{FloatingPointSystem} of the +++ \spadfunFrom{exponent}{FloatingPointSystem}. +++ (actual implemenations are usually binary or decimal) +++ 2: \spadfunFrom{precision}{FloatingPointSystem} of the +++ \spadfunFrom{mantissa}{FloatingPointSystem} (arbitrary or fixed) +++ 3: rounding error for operations +--++ 4: when, and what happens if exponent overflow/underflow occurs +++ +++ Because a Float is an approximation to the real numbers, even though +++ it is defined to be a join of a Field and OrderedRing, some of +++ the attributes do not hold. In particular associative("+") +++ does not hold. Algorithms defined over a field need special +++ considerations when the field is a floating point system. +FloatingPointSystem(): Category == RealNumberSystem() with + approximate + ++ \spad{approximate} means "is an approximation to the real numbers". + float: (Integer,Integer) -> % + ++ float(a,e) returns \spad{a * base() ** e}. + float: (Integer,Integer,PositiveInteger) -> % + ++ float(a,e,b) returns \spad{a * b ** e}. + order: % -> Integer + ++ order x is the order of magnitude of x. + ++ Note: \spad{base ** order x <= |x| < base ** (1 + order x)}. + base: () -> PositiveInteger + ++ base() returns the base of the + ++\spadfunFrom{exponent}{FloatingPointSystem}. + + exponent: % -> Integer + ++ exponent(x) returns the + ++ \spadfunFrom{exponent}{FloatingPointSystem} part of x. + + mantissa: % -> Integer + ++ mantissa(x) returns the mantissa part of x. + -- round?: () -> B + -- ++ round?() returns the rounding or chopping. + + bits: () -> PositiveInteger + ++ bits() returns ceiling's precision in bits. + digits: () -> PositiveInteger + ++ digits() returns ceiling's precision in decimal digits. + precision: () -> PositiveInteger + ++ precision() returns the precision in digits base. + + if % has arbitraryPrecision then + bits: PositiveInteger -> PositiveInteger + ++ bits(n) set the \spadfunFrom{precision}{FloatingPointSystem} + ++ to n bits. + + digits: PositiveInteger -> PositiveInteger + ++ digits(d) set the \spadfunFrom{precision}{FloatingPointSystem} + ++ to d digits. + + precision: PositiveInteger -> PositiveInteger + ++ precision(n) set the precision in the base to n decimal digits. + + increasePrecision: Integer -> PositiveInteger + ++ increasePrecision(n) increases the current + ++ \spadfunFrom{precision}{FloatingPointSystem} by n decimal digits. + + decreasePrecision: Integer -> PositiveInteger + ++ decreasePrecision(n) decreases the current + ++ \spadfunFrom{precision}{FloatingPointSystem} precision + ++ by n decimal digits. + + if not (% has arbitraryExponent) then + -- overflow: (()->Exit) -> Void + -- ++ overflow() returns the Exponent overflow of float + -- underflow: (()->Exit) -> Void + -- ++ underflow() returns the Exponent underflow of float + -- maxExponent: () -> Integer + -- ++ maxExponent() returns the max Exponent of float + if not (% has arbitraryPrecision) then + min: () -> % + ++ min() returns the minimum floating point number. + max: () -> % + ++ max() returns the maximum floating point number. + add + float(ma, ex) == float(ma, ex, base()) + digits() == max(1,4004 * (bits()-1) quo 13301)::PositiveInteger + +@ +<>= +"FPS" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FPS"]; +"FPS" -> "RNS" + +@ +<>= +"FloatingPointSystem()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FPS"]; +"FloatingPointSystem()" -> "RealNumberSystem()" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"FloatingPointSystem()" [color=lightblue]; +"FloatingPointSystem()" -> "RealNumberSystem()" + +"RealNumberSystem()" [color=lightblue]; +"RealNumberSystem()" -> "FIELD..." +"RealNumberSystem()" -> "ORDRING..." +"RealNumberSystem()" -> "REAL..." +"RealNumberSystem()" -> "RETRACT..." +"RealNumberSystem()" -> "RADCAT..." +"RealNumberSystem()" -> "KONVERT..." +"RealNumberSystem()" -> "PATMAB..." +"RealNumberSystem()" -> "CHARZ..." + +"FIELD..." [color=lightblue]; +"ORDRING..." [color=lightblue]; +"REAL..." [color=lightblue]; +"RETRACT..." [color=lightblue]; +"RADCAT..." [color=lightblue]; +"KONVERT..." [color=lightblue]; +"PATMAB..." [color=lightblue]; +"CHARZ..." [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{FunctionFieldCategory}{FFCAT} \pagepic{ps/v102functionfieldcategory.ps}{FFCAT}{0.70} @@ -34743,6 +37064,155 @@ Note that this code is not included in the generated catdef.spad file. 0 0 71 1 0 0 0 8 0 0 0 44 1 0 31 32 33 1 0 0 0 38 1 0 15 0 39)))))) (QUOTE |lookupComplete|))) @ +\section{FPS.lsp BOOTSTRAP} +{\bf FPS} 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 FPS} category which we can write +into the {\bf MID} directory. We compile the lisp code and copy the +{\bf FPS.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 |FloatingPointSystem;AL| (QUOTE NIL)) + +(DEFUN |FloatingPointSystem| NIL + (LET (#:G105645) + (COND + (|FloatingPointSystem;AL|) + (T (SETQ |FloatingPointSystem;AL| (|FloatingPointSystem;|)))))) + +(DEFUN |FloatingPointSystem;| NIL + (PROG (#1=#:G105643) + (RETURN + (PROG1 + (LETT #1# + (|Join| + (|RealNumberSystem|) + (|mkCategory| + (QUOTE |domain|) + (QUOTE ( + ((|float| (|$| (|Integer|) (|Integer|))) T) + ((|float| (|$| (|Integer|) (|Integer|) (|PositiveInteger|))) T) + ((|order| ((|Integer|) |$|)) T) + ((|base| ((|PositiveInteger|))) T) + ((|exponent| ((|Integer|) |$|)) T) + ((|mantissa| ((|Integer|) |$|)) T) + ((|bits| ((|PositiveInteger|))) T) + ((|digits| ((|PositiveInteger|))) T) + ((|precision| ((|PositiveInteger|))) T) + ((|bits| ((|PositiveInteger|) (|PositiveInteger|))) + (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) + ((|digits| ((|PositiveInteger|) (|PositiveInteger|))) + (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) + ((|precision| ((|PositiveInteger|) (|PositiveInteger|))) + (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) + ((|increasePrecision| ((|PositiveInteger|) (|Integer|))) + (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) + ((|decreasePrecision| ((|PositiveInteger|) (|Integer|))) + (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) + ((|min| (|$|)) + (AND + (|not| (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) + (|not| (|has| |$| (ATTRIBUTE |arbitraryExponent|))))) + ((|max| (|$|)) + (AND + (|not| (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) + (|not| (|has| |$| (ATTRIBUTE |arbitraryExponent|))))))) + (QUOTE ((|approximate| T))) + (QUOTE ((|PositiveInteger|) (|Integer|))) + NIL)) + |FloatingPointSystem|) + (SETELT #1# 0 (QUOTE (|FloatingPointSystem|))))))) + +(MAKEPROP (QUOTE |FloatingPointSystem|) (QUOTE NILADIC) T) + +@ +\section{FPS-.lsp BOOTSTRAP} +{\bf FPS-} depends {\bf FPS}. +We need to break this cycle to build the algebra. So we keep a +cached copy of the translated {\bf FPS-} category which we can write +into the {\bf MID} directory. We compile the lisp code and copy the +{\bf FPS-.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 |FPS-;float;2IS;1| (|ma| |ex| |$|) + (SPADCALL |ma| |ex| (SPADCALL (QREFELT |$| 8)) (QREFELT |$| 10))) + +(DEFUN |FPS-;digits;Pi;2| (|$|) + (PROG (#1=#:G105654) + (RETURN + (PROG1 + (LETT #1# + (MAX 1 + (QUOTIENT2 + (SPADCALL 4004 + (|-| (SPADCALL (QREFELT |$| 13)) 1) + (QREFELT |$| 14)) + 13301)) + |FPS-;digits;Pi;2|) + (|check-subtype| (|>| #1# 0) (QUOTE (|PositiveInteger|)) #1#))))) + +(DEFUN |FloatingPointSystem&| (|#1|) + (PROG (|DV$1| |dv$| |$| |pv$|) + (RETURN + (PROGN + (LETT |DV$1| (|devaluate| |#1|) . #1=(|FloatingPointSystem&|)) + (LETT |dv$| (LIST (QUOTE |FloatingPointSystem&|) |DV$1|) . #1#) + (LETT |$| (GETREFV 17) . #1#) + (QSETREFV |$| 0 |dv$|) + (QSETREFV |$| 3 + (LETT |pv$| + (|buildPredVector| 0 0 + (LIST + (|HasAttribute| |#1| (QUOTE |arbitraryExponent|)) + (|HasAttribute| |#1| (QUOTE |arbitraryPrecision|)))) . #1#)) + (|stuffDomainSlots| |$|) + (QSETREFV |$| 6 |#1|) + |$|)))) + +(MAKEPROP + (QUOTE |FloatingPointSystem&|) + (QUOTE |infovec|) + (LIST + (QUOTE + #(NIL NIL NIL NIL NIL NIL + (|local| |#1|) + (|PositiveInteger|) + (0 . |base|) + (|Integer|) + (4 . |float|) + |FPS-;float;2IS;1| + (11 . |One|) + (15 . |bits|) + (19 . |*|) + (25 . |max|) + |FPS-;digits;Pi;2|)) + (QUOTE #(|float| 29 |digits| 35)) + (QUOTE NIL) + (CONS + (|makeByteWordVec2| 1 (QUOTE NIL)) + (CONS + (QUOTE #()) + (CONS + (QUOTE #()) + (|makeByteWordVec2| 16 + (QUOTE + (0 6 7 8 3 6 0 9 9 7 10 0 6 0 12 0 6 7 13 2 9 0 7 0 14 0 6 0 15 + 2 0 0 9 9 11 0 0 7 16)))))) + (QUOTE |lookupComplete|))) + +@ \section{GCDDOM.lsp BOOTSTRAP} {\bf GCDDOM} needs {\bf COMRING} which needs @@ -38915,6 +41385,283 @@ Note that this code is not included in the generated catdef.spad file. (MAKEPROP (QUOTE |Rng|) (QUOTE NILADIC) T) @ +\section{RNS.lsp BOOTSTRAP} +{\bf RNS} 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 RNS} category which we can write +into the {\bf MID} directory. We compile the lisp code and copy the +{\bf RNS.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 |RealNumberSystem;AL| (QUOTE NIL)) + +(DEFUN |RealNumberSystem| NIL + (LET (#:G105478) + (COND + (|RealNumberSystem;AL|) + (T (SETQ |RealNumberSystem;AL| (|RealNumberSystem;|)))))) + +(DEFUN |RealNumberSystem;| NIL + (PROG (#1=#:G105476) + (RETURN + (PROG1 + (LETT #1# + (|sublisV| + (PAIR + (QUOTE (#2=#:G105472 #3=#:G105473 #4=#:G105474 #5=#:G105475)) + (LIST + (QUOTE (|Integer|)) + (QUOTE (|Fraction| (|Integer|))) + (QUOTE (|Pattern| (|Float|))) + (QUOTE (|Float|)))) + (|Join| + (|Field|) + (|OrderedRing|) + (|RealConstant|) + (|RetractableTo| (QUOTE #2#)) + (|RetractableTo| (QUOTE #3#)) + (|RadicalCategory|) + (|ConvertibleTo| (QUOTE #4#)) + (|PatternMatchable| (QUOTE #5#)) + (|CharacteristicZero|) + (|mkCategory| + (QUOTE |domain|) + (QUOTE ( + ((|norm| (|$| |$|)) T) + ((|ceiling| (|$| |$|)) T) + ((|floor| (|$| |$|)) T) + ((|wholePart| ((|Integer|) |$|)) T) + ((|fractionPart| (|$| |$|)) T) + ((|truncate| (|$| |$|)) T) + ((|round| (|$| |$|)) T) + ((|abs| (|$| |$|)) T))) + NIL + (QUOTE ((|Integer|))) + NIL))) + |RealNumberSystem|) + (SETELT #1# 0 (QUOTE (|RealNumberSystem|))))))) + +(MAKEPROP (QUOTE |RealNumberSystem|) (QUOTE NILADIC) T) + +@ +\section{RNS-.lsp BOOTSTRAP} +{\bf RNS-} depends {\bf RNS}. +We need to break this cycle to build the algebra. So we keep a +cached copy of the translated {\bf RNS-} category which we can write +into the {\bf MID} directory. We compile the lisp code and copy the +{\bf RNS.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) + +(PUT + (QUOTE |RNS-;characteristic;Nni;1|) + (QUOTE |SPADreplace|) + (QUOTE (XLAM NIL 0))) + +(DEFUN |RNS-;characteristic;Nni;1| (|$|) 0) + +(DEFUN |RNS-;fractionPart;2S;2| (|x| |$|) + (SPADCALL |x| (SPADCALL |x| (QREFELT |$| 9)) (QREFELT |$| 10))) + +(DEFUN |RNS-;truncate;2S;3| (|x| |$|) + (COND + ((SPADCALL |x| (QREFELT |$| 13)) + (SPADCALL + (SPADCALL + (SPADCALL |x| (QREFELT |$| 14)) + (QREFELT |$| 15)) + (QREFELT |$| 14))) + ((QUOTE T) (SPADCALL |x| (QREFELT |$| 15))))) + +(DEFUN |RNS-;round;2S;4| (|x| |$|) + (COND + ((SPADCALL |x| (QREFELT |$| 13)) + (SPADCALL + (SPADCALL |x| + (SPADCALL + (|spadConstant| |$| 17) + (SPADCALL 2 (QREFELT |$| 19)) + (QREFELT |$| 20)) + (QREFELT |$| 10)) + (QREFELT |$| 9))) + ((QUOTE T) + (SPADCALL + (SPADCALL |x| + (SPADCALL + (|spadConstant| |$| 17) + (SPADCALL 2 (QREFELT |$| 19)) + (QREFELT |$| 20)) + (QREFELT |$| 21)) + (QREFELT |$| 9))))) + +(DEFUN |RNS-;norm;2S;5| (|x| |$|) + (SPADCALL |x| (QREFELT |$| 23))) + +(DEFUN |RNS-;coerce;FS;6| (|x| |$|) + (SPADCALL + (SPADCALL + (SPADCALL |x| (QREFELT |$| 26)) + (QREFELT |$| 19)) + (SPADCALL + (SPADCALL |x| (QREFELT |$| 27)) + (QREFELT |$| 19)) + (QREFELT |$| 20))) + +(DEFUN |RNS-;convert;SP;7| (|x| |$|) + (SPADCALL (SPADCALL |x| (QREFELT |$| 30)) (QREFELT |$| 32))) + +(DEFUN |RNS-;floor;2S;8| (|x| |$|) + (PROG (|x1|) + (RETURN + (SEQ + (LETT |x1| + (SPADCALL (SPADCALL |x| (QREFELT |$| 34)) (QREFELT |$| 19)) + |RNS-;floor;2S;8|) + (EXIT + (COND + ((SPADCALL |x| |x1| (QREFELT |$| 35)) |x|) + ((SPADCALL |x| (|spadConstant| |$| 36) (QREFELT |$| 37)) + (SPADCALL |x1| (|spadConstant| |$| 17) (QREFELT |$| 10))) + ((QUOTE T) |x1|))))))) + +(DEFUN |RNS-;ceiling;2S;9| (|x| |$|) + (PROG (|x1|) + (RETURN + (SEQ + (LETT |x1| + (SPADCALL (SPADCALL |x| (QREFELT |$| 34)) (QREFELT |$| 19)) + |RNS-;ceiling;2S;9|) + (EXIT + (COND + ((SPADCALL |x| |x1| (QREFELT |$| 35)) |x|) + ((SPADCALL |x| (|spadConstant| |$| 36) (QREFELT |$| 37)) |x1|) + ((QUOTE T) + (SPADCALL |x1| (|spadConstant| |$| 17) (QREFELT |$| 21))))))))) + +(DEFUN |RNS-;patternMatch;SP2Pmr;10| (|x| |p| |l| |$|) + (PROG (|r|) + (RETURN + (SEQ + (COND + ((SPADCALL |p| (QREFELT |$| 40)) + (SPADCALL |p| |x| |l| (QREFELT |$| 42))) + ((SPADCALL |p| (QREFELT |$| 43)) + (SEQ + (LETT |r| + (SPADCALL |p| (QREFELT |$| 45)) + |RNS-;patternMatch;SP2Pmr;10|) + (EXIT + (COND + ((QEQCAR |r| 0) + (COND + ((SPADCALL + (SPADCALL |x| (QREFELT |$| 30)) + (QCDR |r|) + (QREFELT |$| 46)) + |l|) + ((QUOTE T) (SPADCALL (QREFELT |$| 47))))) + ((QUOTE T) (SPADCALL (QREFELT |$| 47))))))) + ((QUOTE T) (SPADCALL (QREFELT |$| 47)))))))) + +(DEFUN |RealNumberSystem&| (|#1|) + (PROG (|DV$1| |dv$| |$| |pv$|) + (RETURN + (PROGN + (LETT |DV$1| (|devaluate| |#1|) . #1=(|RealNumberSystem&|)) + (LETT |dv$| (LIST (QUOTE |RealNumberSystem&|) |DV$1|) . #1#) + (LETT |$| (GETREFV 52) . #1#) + (QSETREFV |$| 0 |dv$|) + (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#)) + (|stuffDomainSlots| |$|) + (QSETREFV |$| 6 |#1|) + |$|)))) + +(MAKEPROP + (QUOTE |RealNumberSystem&|) + (QUOTE |infovec|) + (LIST + (QUOTE + #(NIL NIL NIL NIL NIL NIL + (|local| |#1|) + (|NonNegativeInteger|) + |RNS-;characteristic;Nni;1| + (0 . |truncate|) + (5 . |-|) + |RNS-;fractionPart;2S;2| + (|Boolean|) + (11 . |negative?|) + (16 . |-|) + (21 . |floor|) + |RNS-;truncate;2S;3| + (26 . |One|) + (|Integer|) + (30 . |coerce|) + (35 . |/|) + (41 . |+|) + |RNS-;round;2S;4| + (47 . |abs|) + |RNS-;norm;2S;5| + (|Fraction| 18) + (52 . |numer|) + (57 . |denom|) + |RNS-;coerce;FS;6| + (|Float|) + (62 . |convert|) + (|Pattern| 29) + (67 . |coerce|) + |RNS-;convert;SP;7| + (72 . |wholePart|) + (77 . |=|) + (83 . |Zero|) + (87 . |<|) + |RNS-;floor;2S;8| + |RNS-;ceiling;2S;9| + (93 . |generic?|) + (|PatternMatchResult| 29 6) + (98 . |addMatch|) + (105 . |constant?|) + (|Union| 29 (QUOTE "failed")) + (110 . |retractIfCan|) + (115 . |=|) + (121 . |failed|) + (|PatternMatchResult| 29 |$|) + |RNS-;patternMatch;SP2Pmr;10| + (|DoubleFloat|) + (|OutputForm|))) + (QUOTE + #(|truncate| 125 |round| 130 |patternMatch| 135 |norm| 142 + |fractionPart| 147 |floor| 152 |convert| 157 |coerce| 162 + |characteristic| 172 |ceiling| 176)) + (QUOTE NIL) + (CONS + (|makeByteWordVec2| 1 (QUOTE NIL)) + (CONS + (QUOTE #()) + (CONS + (QUOTE #()) + (|makeByteWordVec2| 49 + (QUOTE + (1 6 0 0 9 2 6 0 0 0 10 1 6 12 0 13 1 6 0 0 14 1 6 0 0 15 0 6 0 + 17 1 6 0 18 19 2 6 0 0 0 20 2 6 0 0 0 21 1 6 0 0 23 1 25 18 0 + 26 1 25 18 0 27 1 6 29 0 30 1 31 0 29 32 1 6 18 0 34 2 6 12 0 + 0 35 0 6 0 36 2 6 12 0 0 37 1 31 12 0 40 3 41 0 31 6 0 42 1 31 + 12 0 43 1 31 44 0 45 2 29 12 0 0 46 0 41 0 47 1 0 0 0 16 1 0 0 + 0 22 3 0 48 0 31 48 49 1 0 0 0 24 1 0 0 0 11 1 0 0 0 38 1 0 31 + 0 33 1 0 0 25 28 1 0 0 25 28 0 0 7 8 1 0 0 0 39)))))) + (QUOTE |lookupComplete|))) + +@ \section{SETAGG.lsp BOOTSTRAP} {\bf SETAGG} 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 SETAGG} @@ -42048,6 +44795,7 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> @@ -42078,7 +44826,9 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> +<> <> <> <> @@ -42087,6 +44837,7 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> @@ -42107,6 +44858,7 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> @@ -42144,11 +44896,14 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> +<> <> <> <> <> +<> <> <> <> @@ -42169,7 +44924,10 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> +<> +<> @ <>= digraph dotabb { @@ -42197,6 +44955,7 @@ digraph dotabb { <> <> <> +<> <> <> <> @@ -42226,7 +44985,9 @@ digraph dotabb { <> <> <> +<> <> +<> <> <> <> @@ -42235,6 +44996,7 @@ digraph dotabb { <> <> <> +<> <> <> <> @@ -42254,6 +45016,7 @@ digraph dotabb { <> <> <> +<> <> <> <> @@ -42291,11 +45054,14 @@ digraph dotabb { <> <> <> +<> <> +<> <> <> <> <> +<> <> <> <> @@ -42316,7 +45082,10 @@ digraph dotabb { <> <> <> +<> <> +<> +<> } @ <>= @@ -42347,6 +45116,7 @@ digraph dotfull { <> <> <> +<> <> <> <> @@ -42376,7 +45146,9 @@ digraph dotfull { <> <> <> +<> <> +<> <> <> <> @@ -42385,6 +45157,7 @@ digraph dotfull { <> <> <> +<> <> <> <> @@ -42404,6 +45177,7 @@ digraph dotfull { <> <> <> +<> <> <> <> @@ -42441,11 +45215,14 @@ digraph dotfull { <> <> <> +<> <> +<> <> <> <> <> +<> <> <> <> @@ -42466,7 +45243,10 @@ digraph dotfull { <> <> <> +<> <> +<> +<> } @ \eject diff --git a/books/ps/v102cachableset.ps b/books/ps/v102cachableset.ps new file mode 100644 index 0000000..8232df8 --- /dev/null +++ b/books/ps/v102cachableset.ps @@ -0,0 +1,540 @@ +%!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 290 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 290 440 +%%PageOrientation: Portrait +gsave +36 36 254 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 +252 402 lineto +252 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 402 lineto +252 402 lineto +252 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% CachableSet() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 152 396 moveto +58 396 lineto +58 360 lineto +152 360 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 152 396 moveto +58 396 lineto +58 360 lineto +152 360 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +65 373 moveto +(CachableSet\(\)) +[9.36 6.24 6 6.96 6.24 6.96 3.84 6.24 7.68 6 3.84 4.56 4.56] +xshow +end grestore +end grestore +% OrderedSet() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 149 324 moveto +61 324 lineto +61 288 lineto +149 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 149 324 moveto +61 324 lineto +61 288 lineto +149 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +68 301 moveto +(OrderedSet\(\)) +[10.08 4.56 6.96 6.24 4.8 6.24 6.96 7.68 6 3.84 4.56 4.56] +xshow +end grestore +end grestore +% CachableSet()->OrderedSet() +newpath 105 360 moveto +105 352 105 343 105 334 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 109 334 moveto +105 324 lineto +102 334 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 109 334 moveto +105 324 lineto +102 334 lineto +closepath +stroke +end grestore +% SetCategory() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 152 252 moveto +58 252 lineto +58 216 lineto +152 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 152 252 moveto +58 252 lineto +58 216 lineto +152 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +65 229 moveto +(SetCategory\(\)) +[7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 4.56] +xshow +end grestore +end grestore +% OrderedSet()->SetCategory() +newpath 105 288 moveto +105 280 105 271 105 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 109 262 moveto +105 252 lineto +102 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 109 262 moveto +105 252 lineto +102 262 lineto +closepath +stroke +end grestore +% BasicType() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 84 108 moveto +0 108 lineto +0 72 lineto +84 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 84 108 moveto +0 108 lineto +0 72 lineto +84 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 85 moveto +(BasicType\(\)) +[9.36 6.24 5.52 3.84 6.24 7.2 6.96 6.96 6.24 4.56 4.56] +xshow +end grestore +end grestore +% SetCategory()->BasicType() +newpath 93 216 moveto +86 206 78 192 73 180 curveto +64 160 55 136 50 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 53 117 moveto +47 108 lineto +47 119 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 53 117 moveto +47 108 lineto +47 119 lineto +closepath +stroke +end grestore +% CoercibleTo(OutputForm) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 246 180 moveto +82 180 lineto +82 144 lineto +246 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 246 180 moveto +82 180 lineto +82 144 lineto +246 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +90 157 moveto +(CoercibleTo\(OutputForm\)) +[9.36 6.96 6.24 4.8 6.24 3.84 6.96 3.84 6.24 7.44 6.96 4.56 10.08 6.96 3.84 6.96 6.96 3.84 7.44 6.96 5.04 10.8 4.56] +xshow +end grestore +end grestore +% SetCategory()->CoercibleTo(OutputForm) +newpath 120 216 moveto +127 207 135 197 143 188 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 146 190 moveto +149 180 lineto +140 186 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 146 190 moveto +149 180 lineto +140 186 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 139 36 moveto +71 36 lineto +71 0 lineto +139 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 139 36 moveto +71 36 lineto +71 0 lineto +139 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +79 13 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% BasicType()->Category +newpath 58 72 moveto +66 63 75 53 82 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 85 46 moveto +89 36 lineto +80 41 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 85 46 moveto +89 36 lineto +80 41 lineto +closepath +stroke +end grestore +% CoercibleTo(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 234 108 moveto +102 108 lineto +102 72 lineto +234 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 234 108 moveto +102 108 lineto +102 72 lineto +234 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +110 85 moveto +(CoercibleTo\(a:Type\)) +[9.36 6.96 6.24 4.8 6.24 3.84 6.96 3.84 6.24 7.44 6.96 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% CoercibleTo(OutputForm)->CoercibleTo(a:Type) +newpath 165 144 moveto +166 136 166 127 166 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 169 118 moveto +167 108 lineto +163 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 169 118 moveto +167 108 lineto +163 118 lineto +closepath +stroke +end grestore +% CoercibleTo(a:Type)->Category +newpath 152 72 moveto +144 63 135 53 128 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 130 41 moveto +121 36 lineto +125 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 130 41 moveto +121 36 lineto +125 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102floatingpointsystem.ps b/books/ps/v102floatingpointsystem.ps new file mode 100644 index 0000000..b1220fb --- /dev/null +++ b/books/ps/v102floatingpointsystem.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 812 224 +%%EndComments +save +%%BeginProlog +/DotDict 200 dict def +DotDict begin + +/setupLatin1 { +mark +/EncodingVector 256 array def + EncodingVector 0 + +ISOLatin1Encoding 0 255 getinterval putinterval +EncodingVector 45 /hyphen put + +% Set up ISO Latin 1 character encoding +/starnetISO { + dup dup findfont dup length dict begin + { 1 index /FID ne { def }{ pop pop } ifelse + } forall + /Encoding EncodingVector def + currentdict end definefont +} def +/Times-Roman starnetISO def +/Times-Italic starnetISO def +/Times-Bold starnetISO def +/Times-BoldItalic starnetISO def +/Helvetica starnetISO def +/Helvetica-Oblique starnetISO def +/Helvetica-Bold starnetISO def +/Helvetica-BoldOblique starnetISO def +/Courier starnetISO def +/Courier-Oblique starnetISO def +/Courier-Bold starnetISO def +/Courier-BoldOblique starnetISO def +cleartomark +} bind def + +%%BeginResource: procset graphviz 0 0 +/coord-font-family /Times-Roman def +/default-font-family /Times-Roman def +/coordfont coord-font-family findfont 8 scalefont def + +/InvScaleFactor 1.0 def +/set_scale { + dup 1 exch div /InvScaleFactor exch def + dup scale +} bind def + +% styles +/solid { [] 0 setdash } bind def +/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def +/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def +/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def +/bold { 2 setlinewidth } bind def +/filled { } bind def +/unfilled { } bind def +/rounded { } bind def +/diagonals { } bind def + +% hooks for setting color +/nodecolor { sethsbcolor } bind def +/edgecolor { sethsbcolor } bind def +/graphcolor { sethsbcolor } bind def +/nopcolor {pop pop pop} bind def + +/beginpage { % i j npages + /npages exch def + /j exch def + /i exch def + /str 10 string def + npages 1 gt { + gsave + coordfont setfont + 0 0 moveto + (\() show i str cvs show (,) show j str cvs show (\)) show + grestore + } if +} bind def + +/set_font { + findfont exch + scalefont setfont +} def + +% draw aligned label in bounding box aligned to current point +/alignedtext { % width adj text + /text exch def + /adj exch def + /width exch def + gsave + width 0 gt { + text stringwidth pop adj mul 0 rmoveto + } if + [] 0 setdash + text show + grestore +} def + +/boxprim { % xcorner ycorner xsize ysize + 4 2 roll + moveto + 2 copy + exch 0 rlineto + 0 exch rlineto + pop neg 0 rlineto + closepath +} bind def + +/ellipse_path { + /ry exch def + /rx exch def + /y exch def + /x exch def + matrix currentmatrix + newpath + x y translate + rx ry scale + 0 0 1 0 360 arc + setmatrix +} bind def + +/endpage { showpage } bind def +/showpage { } def + +/layercolorseq + [ % layer color sequence - darkest to lightest + [0 0 0] + [.2 .8 .8] + [.4 .8 .8] + [.6 .8 .8] + [.8 .8 .8] + ] +def + +/layerlen layercolorseq length def + +/setlayer {/maxlayer exch def /curlayer exch def + layercolorseq curlayer 1 sub layerlen mod get + aload pop sethsbcolor + /nodecolor {nopcolor} def + /edgecolor {nopcolor} def + /graphcolor {nopcolor} def +} bind def + +/onlayer { curlayer ne {invis} if } def + +/onlayers { + /myupper exch def + /mylower exch def + curlayer mylower lt + curlayer myupper gt + or + {invis} if +} def + +/curlayer 0 def + +%%EndResource +%%EndProlog +%%BeginSetup +14 default-font-family set_font +1 setmiterlimit +% /arrowlength 10 def +% /arrowwidth 5 def + +% make sure pdfmark is harmless for PS-interpreters other than Distiller +/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse +% make '<<' and '>>' safe on PS Level 1 devices +/languagelevel where {pop languagelevel}{1} ifelse +2 lt { + userdict (<<) cvn ([) cvn load put + userdict (>>) cvn ([) cvn load put +} if + +%%EndSetup +%%Page: 1 1 +%%PageBoundingBox: 36 36 812 224 +%%PageOrientation: Portrait +gsave +36 36 776 188 boxprim clip newpath +36 36 translate +0 0 1 beginpage +1.0000 set_scale +4 4 translate 0 rotate +0.167 0.600 1.000 graphcolor +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 186 lineto +774 186 lineto +774 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 186 lineto +774 186 lineto +774 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% FloatingPointSystem() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 441 180 moveto +301 180 lineto +301 144 lineto +441 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 441 180 moveto +301 180 lineto +301 144 lineto +441 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +308 157 moveto +(FloatingPointSystem\(\)) +[7.68 3.84 6.96 6.24 3.84 3.84 6.96 6.96 7.44 6.96 3.84 6.96 3.84 7.68 6.48 5.28 3.84 6.24 10.8 4.56 4.56] +xshow +end grestore +end grestore +% RealNumberSystem() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 439 108 moveto +303 108 lineto +303 72 lineto +439 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 439 108 moveto +303 108 lineto +303 72 lineto +439 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +310 85 moveto +(RealNumberSystem\(\)) +[9.12 6.24 6.24 3.84 9.84 6.96 10.8 6.96 6.24 4.8 7.68 6.48 5.28 3.84 6.24 10.8 4.56 4.56] +xshow +end grestore +end grestore +% FloatingPointSystem()->RealNumberSystem() +newpath 371 144 moveto +371 136 371 127 371 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 375 118 moveto +371 108 lineto +368 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 375 118 moveto +371 108 lineto +368 118 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 66 36 moveto +0 36 lineto +0 0 lineto +66 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 66 36 moveto +0 36 lineto +0 0 lineto +66 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 13 moveto +(FIELD...) +[7.68 4.56 8.64 8.64 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RealNumberSystem()->FIELD... +newpath 303 82 moveto +244 74 159 60 76 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 77 33 moveto +66 33 lineto +75 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 77 33 moveto +66 33 lineto +75 39 lineto +closepath +stroke +end grestore +% ORDRING... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 174 36 moveto +84 36 lineto +84 0 lineto +174 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 174 36 moveto +84 36 lineto +84 0 lineto +174 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +91 13 moveto +(ORDRING...) +[10.08 9.36 10.08 9.36 4.56 9.84 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RealNumberSystem()->ORDRING... +newpath 307 72 moveto +273 63 230 50 184 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 185 33 moveto +174 33 lineto +183 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 185 33 moveto +174 33 lineto +183 39 lineto +closepath +stroke +end grestore +% REAL... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 256 36 moveto +192 36 lineto +192 0 lineto +256 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 256 36 moveto +192 36 lineto +192 0 lineto +256 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +200 13 moveto +(REAL...) +[9.36 8.64 10.08 8.64 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RealNumberSystem()->REAL... +newpath 334 72 moveto +313 62 287 49 265 38 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 267 35 moveto +256 34 lineto +264 41 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 267 35 moveto +256 34 lineto +264 41 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 364 36 moveto +274 36 lineto +274 0 lineto +364 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 364 36 moveto +274 36 lineto +274 0 lineto +364 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +282 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 +% RealNumberSystem()->RETRACT... +newpath 358 72 moveto +352 64 345 53 338 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 341 42 moveto +332 36 lineto +335 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 341 42 moveto +332 36 lineto +335 46 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 464 36 moveto +382 36 lineto +382 0 lineto +464 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 464 36 moveto +382 36 lineto +382 0 lineto +464 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +389 13 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 +% RealNumberSystem()->RADCAT... +newpath 384 72 moveto +390 64 397 53 404 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 407 46 moveto +410 36 lineto +401 42 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 407 46 moveto +410 36 lineto +401 42 lineto +closepath +stroke +end grestore +% KONVERT... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 574 36 moveto +482 36 lineto +482 0 lineto +574 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 574 36 moveto +482 36 lineto +482 0 lineto +574 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +489 13 moveto +(KONVERT...) +[9.12 10.08 10.08 10.08 8.64 8.88 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RealNumberSystem()->KONVERT... +newpath 411 72 moveto +432 62 458 50 480 40 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 481 43 moveto +489 36 lineto +478 37 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 481 43 moveto +489 36 lineto +478 37 lineto +closepath +stroke +end grestore +% PATMAB... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 676 36 moveto +592 36 lineto +592 0 lineto +676 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 676 36 moveto +592 36 lineto +592 0 lineto +676 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +599 13 moveto +(PATMAB...) +[6.48 9.36 8.64 12.48 10.08 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RealNumberSystem()->PATMAB... +newpath 439 74 moveto +479 65 529 52 582 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 583 39 moveto +592 33 lineto +581 33 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 583 39 moveto +592 33 lineto +581 33 lineto +closepath +stroke +end grestore +% CHARZ... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 768 36 moveto +694 36 lineto +694 0 lineto +768 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 768 36 moveto +694 36 lineto +694 0 lineto +768 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +701 13 moveto +(CHARZ...) +[9.36 10.08 10.08 9.36 8.64 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RealNumberSystem()->CHARZ... +newpath 439 82 moveto +501 74 595 60 684 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 685 39 moveto +694 33 lineto +683 33 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 685 39 moveto +694 33 lineto +683 33 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102freeliealgebra.ps b/books/ps/v102freeliealgebra.ps new file mode 100644 index 0000000..9290d1f --- /dev/null +++ b/books/ps/v102freeliealgebra.ps @@ -0,0 +1,677 @@ +%!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 356 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 356 584 +%%PageOrientation: Portrait +gsave +36 36 320 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 +318 546 lineto +318 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 546 lineto +318 546 lineto +318 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% FreeLieAlgebra(a:OrderedSet,b:CommutativeRing) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 308 540 moveto +4 540 lineto +4 504 lineto +308 504 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 308 540 moveto +4 540 lineto +4 504 lineto +308 504 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +11 517 moveto +(FreeLieAlgebra\(a:OrderedSet,b:CommutativeRing\)) +[7.44 4.8 6.24 6.24 8.64 3.84 6.24 10.08 3.84 6.72 6.24 6.96 4.8 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 3.6 6.96 3.84 9.36 6.96 10.8 10.8 6.96 4.08 6.24 3.84 3.84 6.48 6.24 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% LieAlgebra(a:CommutativeRing) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 257 468 moveto +55 468 lineto +55 432 lineto +257 432 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 257 468 moveto +55 468 lineto +55 432 lineto +257 432 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +63 445 moveto +(LieAlgebra\(a:CommutativeRing\)) +[8.64 3.84 6.24 10.08 3.84 6.72 6.24 6.96 4.8 6.24 4.56 6.24 3.84 9.36 6.96 10.8 10.8 6.96 4.08 6.24 3.84 3.84 6.48 6.24 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% FreeLieAlgebra(a:OrderedSet,b:CommutativeRing)->LieAlgebra(a:CommutativeRing) +newpath 156 504 moveto +156 496 156 487 156 478 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 160 478 moveto +156 468 lineto +153 478 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 160 478 moveto +156 468 lineto +153 478 lineto +closepath +stroke +end grestore +% Module(a:CommutativeRing) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 247 396 moveto +65 396 lineto +65 360 lineto +247 360 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 247 396 moveto +65 396 lineto +65 360 lineto +247 360 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +72 373 moveto +(Module\(a:CommutativeRing\)) +[12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 10.8 10.8 6.96 4.08 6.24 3.84 3.84 6.48 6.24 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% LieAlgebra(a:CommutativeRing)->Module(a:CommutativeRing) +newpath 156 432 moveto +156 424 156 415 156 406 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 160 406 moveto +156 396 lineto +153 406 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 160 406 moveto +156 396 lineto +153 406 lineto +closepath +stroke +end grestore +% BiModule(a:CommutativeRing,b:CommutativeRing) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 312 324 moveto +0 324 lineto +0 288 lineto +312 288 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 312 324 moveto +0 324 lineto +0 288 lineto +312 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 301 moveto +(BiModule\(a:CommutativeRing,b:CommutativeRing\)) +[9.36 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 10.8 10.8 6.96 4.08 6.24 3.84 3.84 6.48 6.24 9.36 3.84 6.96 6.96 3.6 6.96 3.84 9.36 6.96 10.8 10.8 6.96 4.08 6.24 3.84 3.84 6.48 6.24 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% Module(a:CommutativeRing)->BiModule(a:CommutativeRing,b:CommutativeRing) +newpath 156 360 moveto +156 352 156 343 156 334 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 160 334 moveto +156 324 lineto +153 334 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 160 334 moveto +156 324 lineto +153 334 lineto +closepath +stroke +end grestore +% BiModule(a:Ring,b:Ring) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 237 252 moveto +75 252 lineto +75 216 lineto +237 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 237 252 moveto +75 252 lineto +75 216 lineto +237 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +83 229 moveto +(BiModule\(a:Ring,b:Ring\)) +[9.36 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 3.6 6.96 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% BiModule(a:CommutativeRing,b:CommutativeRing)->BiModule(a:Ring,b:Ring) +newpath 156 288 moveto +156 280 156 271 156 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 160 262 moveto +156 252 lineto +153 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 160 262 moveto +156 252 lineto +153 262 lineto +closepath +stroke +end grestore +% LeftModule(a:Ring) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 146 180 moveto +16 180 lineto +16 144 lineto +146 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 146 180 moveto +16 180 lineto +16 144 lineto +146 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +24 157 moveto +(LeftModule\(a:Ring\)) +[8.64 6.24 4.8 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% BiModule(a:Ring,b:Ring)->LeftModule(a:Ring) +newpath 137 216 moveto +128 207 117 197 107 187 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 110 185 moveto +100 180 lineto +105 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 110 185 moveto +100 180 lineto +105 190 lineto +closepath +stroke +end grestore +% RightModule(a:Ring) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 300 180 moveto +164 180 lineto +164 144 lineto +300 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 300 180 moveto +164 180 lineto +164 144 lineto +300 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +171 157 moveto +(RightModule\(a:Ring\)) +[9.36 3.84 6.96 6.96 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% BiModule(a:Ring,b:Ring)->RightModule(a:Ring) +newpath 175 216 moveto +185 207 196 197 206 187 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 208 190 moveto +213 180 lineto +203 185 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 208 190 moveto +213 180 lineto +203 185 lineto +closepath +stroke +end grestore +% LeftModule(a:Rng) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 145 108 moveto +19 108 lineto +19 72 lineto +145 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 145 108 moveto +19 108 lineto +19 72 lineto +145 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +27 85 moveto +(LeftModule\(a:Rng\)) +[8.64 6.24 4.8 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 6.96 4.56] +xshow +end grestore +end grestore +% LeftModule(a:Ring)->LeftModule(a:Rng) +newpath 81 144 moveto +82 136 82 127 82 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 86 118 moveto +82 108 lineto +79 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 86 118 moveto +82 108 lineto +79 118 lineto +closepath +stroke +end grestore +% RightModule(a:Rng) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 298 108 moveto +164 108 lineto +164 72 lineto +298 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 298 108 moveto +164 108 lineto +164 72 lineto +298 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +172 85 moveto +(RightModule\(a:Rng\)) +[9.36 3.84 6.96 6.96 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 6.96 4.56] +xshow +end grestore +end grestore +% RightModule(a:Ring)->RightModule(a:Rng) +newpath 232 144 moveto +231 136 231 127 231 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 235 118 moveto +231 108 lineto +228 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 235 118 moveto +231 108 lineto +228 118 lineto +closepath +stroke +end grestore +% ABELGRP... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 201 36 moveto +111 36 lineto +111 0 lineto +201 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 201 36 moveto +111 36 lineto +111 0 lineto +201 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +118 13 moveto +(ABELGRP...) +[10.08 9.36 8.64 8.64 10.08 9.36 6.24 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RightModule(a:Rng)->ABELGRP... +newpath 212 72 moveto +203 63 192 53 182 43 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 185 41 moveto +175 36 lineto +180 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 185 41 moveto +175 36 lineto +180 46 lineto +closepath +stroke +end grestore +% LeftModule(a:Rng)->ABELGRP... +newpath 101 72 moveto +110 63 121 53 131 43 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 133 46 moveto +138 36 lineto +128 41 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 133 46 moveto +138 36 lineto +128 41 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102freemodulecat.ps b/books/ps/v102freemodulecat.ps new file mode 100644 index 0000000..0daab67 --- /dev/null +++ b/books/ps/v102freemodulecat.ps @@ -0,0 +1,677 @@ +%!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 516 368 +%%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 516 368 +%%PageOrientation: Portrait +gsave +36 36 480 332 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 330 lineto +478 330 lineto +478 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 330 lineto +478 330 lineto +478 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% FreeModuleCat(a:Ring,b:SetCategory) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 410 324 moveto +176 324 lineto +176 288 lineto +410 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 410 324 moveto +176 324 lineto +176 288 lineto +410 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +184 301 moveto +(FreeModuleCat\(a:Ring,b:SetCategory\)) +[7.44 4.8 6.24 6.24 12.48 6.96 6.96 6.96 3.84 6.24 9.36 6.24 3.84 4.56 6.24 3.84 9.36 3.84 6.96 6.96 3.6 6.96 3.84 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56] +xshow +end grestore +end grestore +% BiModule(a:Ring,b:Ring) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 282 252 moveto +120 252 lineto +120 216 lineto +282 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 282 252 moveto +120 252 lineto +120 216 lineto +282 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +128 229 moveto +(BiModule\(a:Ring,b:Ring\)) +[9.36 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 3.6 6.96 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% FreeModuleCat(a:Ring,b:SetCategory)->BiModule(a:Ring,b:Ring) +newpath 270 288 moveto +259 279 244 268 232 258 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 234 255 moveto +224 252 lineto +230 261 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 234 255 moveto +224 252 lineto +230 261 lineto +closepath +stroke +end grestore +% RetractableTo(SetCategory) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 472 252 moveto +300 252 lineto +300 216 lineto +472 216 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 472 252 moveto +300 252 lineto +300 216 lineto +472 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +307 229 moveto +(RetractableTo\(SetCategory\)) +[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56] +xshow +end grestore +end grestore +% FreeModuleCat(a:Ring,b:SetCategory)->RetractableTo(SetCategory) +newpath 316 288 moveto +327 279 342 268 355 258 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 357 261 moveto +363 252 lineto +353 255 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 357 261 moveto +363 252 lineto +353 255 lineto +closepath +stroke +end grestore +% LeftModule(a:Ring) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 130 180 moveto +0 180 lineto +0 144 lineto +130 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 130 180 moveto +0 180 lineto +0 144 lineto +130 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 157 moveto +(LeftModule\(a:Ring\)) +[8.64 6.24 4.8 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% BiModule(a:Ring,b:Ring)->LeftModule(a:Ring) +newpath 167 216 moveto +149 207 126 195 108 185 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 109 182 moveto +99 180 lineto +106 188 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 109 182 moveto +99 180 lineto +106 188 lineto +closepath +stroke +end grestore +% RightModule(a:Ring) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 284 180 moveto +148 180 lineto +148 144 lineto +284 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 284 180 moveto +148 180 lineto +148 144 lineto +284 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +155 157 moveto +(RightModule\(a:Ring\)) +[9.36 3.84 6.96 6.96 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% BiModule(a:Ring,b:Ring)->RightModule(a:Ring) +newpath 205 216 moveto +206 208 208 199 210 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 213 190 moveto +212 180 lineto +207 189 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 213 190 moveto +212 180 lineto +207 189 lineto +closepath +stroke +end grestore +% RetractableTo(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 456 180 moveto +316 180 lineto +316 144 lineto +456 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 456 180 moveto +316 180 lineto +316 144 lineto +456 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +323 157 moveto +(RetractableTo\(a:Type\)) +[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% RetractableTo(SetCategory)->RetractableTo(a:Type) +newpath 386 216 moveto +386 208 386 199 386 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 390 190 moveto +386 180 lineto +383 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 390 190 moveto +386 180 lineto +383 190 lineto +closepath +stroke +end grestore +% Category +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 420 108 moveto +352 108 lineto +352 72 lineto +420 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 420 108 moveto +352 108 lineto +352 72 lineto +420 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +360 85 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% RetractableTo(a:Type)->Category +newpath 386 144 moveto +386 136 386 127 386 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 390 118 moveto +386 108 lineto +383 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 390 118 moveto +386 108 lineto +383 118 lineto +closepath +stroke +end grestore +% LeftModule(a:Rng) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 129 108 moveto +3 108 lineto +3 72 lineto +129 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 129 108 moveto +3 108 lineto +3 72 lineto +129 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +11 85 moveto +(LeftModule\(a:Rng\)) +[8.64 6.24 4.8 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 6.96 4.56] +xshow +end grestore +end grestore +% LeftModule(a:Ring)->LeftModule(a:Rng) +newpath 65 144 moveto +66 136 66 127 66 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 70 118 moveto +66 108 lineto +63 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 70 118 moveto +66 108 lineto +63 118 lineto +closepath +stroke +end grestore +% RightModule(a:Rng) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 282 108 moveto +148 108 lineto +148 72 lineto +282 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 282 108 moveto +148 108 lineto +148 72 lineto +282 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +156 85 moveto +(RightModule\(a:Rng\)) +[9.36 3.84 6.96 6.96 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 6.96 4.56] +xshow +end grestore +end grestore +% RightModule(a:Ring)->RightModule(a:Rng) +newpath 216 144 moveto +215 136 215 127 215 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 219 118 moveto +215 108 lineto +212 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 219 118 moveto +215 108 lineto +212 118 lineto +closepath +stroke +end grestore +% ABELGRP... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 185 36 moveto +95 36 lineto +95 0 lineto +185 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 185 36 moveto +95 36 lineto +95 0 lineto +185 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +102 13 moveto +(ABELGRP...) +[10.08 9.36 8.64 8.64 10.08 9.36 6.24 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RightModule(a:Rng)->ABELGRP... +newpath 196 72 moveto +187 63 176 53 166 43 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 169 41 moveto +159 36 lineto +164 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 169 41 moveto +159 36 lineto +164 46 lineto +closepath +stroke +end grestore +% LeftModule(a:Rng)->ABELGRP... +newpath 85 72 moveto +94 63 105 53 115 43 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 117 46 moveto +122 36 lineto +112 41 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 117 46 moveto +122 36 lineto +112 41 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102liealgebra.ps b/books/ps/v102liealgebra.ps new file mode 100644 index 0000000..7887442 --- /dev/null +++ b/books/ps/v102liealgebra.ps @@ -0,0 +1,631 @@ +%!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 356 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 356 512 +%%PageOrientation: Portrait +gsave +36 36 320 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 +318 474 lineto +318 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 474 lineto +318 474 lineto +318 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% LieAlgebra(a:CommutativeRing) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 257 468 moveto +55 468 lineto +55 432 lineto +257 432 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 257 468 moveto +55 468 lineto +55 432 lineto +257 432 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +63 445 moveto +(LieAlgebra\(a:CommutativeRing\)) +[8.64 3.84 6.24 10.08 3.84 6.72 6.24 6.96 4.8 6.24 4.56 6.24 3.84 9.36 6.96 10.8 10.8 6.96 4.08 6.24 3.84 3.84 6.48 6.24 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% Module(a:CommutativeRing) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 247 396 moveto +65 396 lineto +65 360 lineto +247 360 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 247 396 moveto +65 396 lineto +65 360 lineto +247 360 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +72 373 moveto +(Module\(a:CommutativeRing\)) +[12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 10.8 10.8 6.96 4.08 6.24 3.84 3.84 6.48 6.24 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% LieAlgebra(a:CommutativeRing)->Module(a:CommutativeRing) +newpath 156 432 moveto +156 424 156 415 156 406 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 160 406 moveto +156 396 lineto +153 406 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 160 406 moveto +156 396 lineto +153 406 lineto +closepath +stroke +end grestore +% BiModule(a:CommutativeRing,b:CommutativeRing) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 312 324 moveto +0 324 lineto +0 288 lineto +312 288 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 312 324 moveto +0 324 lineto +0 288 lineto +312 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 301 moveto +(BiModule\(a:CommutativeRing,b:CommutativeRing\)) +[9.36 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 10.8 10.8 6.96 4.08 6.24 3.84 3.84 6.48 6.24 9.36 3.84 6.96 6.96 3.6 6.96 3.84 9.36 6.96 10.8 10.8 6.96 4.08 6.24 3.84 3.84 6.48 6.24 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% Module(a:CommutativeRing)->BiModule(a:CommutativeRing,b:CommutativeRing) +newpath 156 360 moveto +156 352 156 343 156 334 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 160 334 moveto +156 324 lineto +153 334 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 160 334 moveto +156 324 lineto +153 334 lineto +closepath +stroke +end grestore +% BiModule(a:Ring,b:Ring) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 237 252 moveto +75 252 lineto +75 216 lineto +237 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 237 252 moveto +75 252 lineto +75 216 lineto +237 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +83 229 moveto +(BiModule\(a:Ring,b:Ring\)) +[9.36 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 3.6 6.96 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% BiModule(a:CommutativeRing,b:CommutativeRing)->BiModule(a:Ring,b:Ring) +newpath 156 288 moveto +156 280 156 271 156 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 160 262 moveto +156 252 lineto +153 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 160 262 moveto +156 252 lineto +153 262 lineto +closepath +stroke +end grestore +% LeftModule(a:Ring) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 146 180 moveto +16 180 lineto +16 144 lineto +146 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 146 180 moveto +16 180 lineto +16 144 lineto +146 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +24 157 moveto +(LeftModule\(a:Ring\)) +[8.64 6.24 4.8 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% BiModule(a:Ring,b:Ring)->LeftModule(a:Ring) +newpath 137 216 moveto +128 207 117 197 107 187 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 110 185 moveto +100 180 lineto +105 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 110 185 moveto +100 180 lineto +105 190 lineto +closepath +stroke +end grestore +% RightModule(a:Ring) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 300 180 moveto +164 180 lineto +164 144 lineto +300 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 300 180 moveto +164 180 lineto +164 144 lineto +300 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +171 157 moveto +(RightModule\(a:Ring\)) +[9.36 3.84 6.96 6.96 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% BiModule(a:Ring,b:Ring)->RightModule(a:Ring) +newpath 175 216 moveto +185 207 196 197 206 187 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 208 190 moveto +213 180 lineto +203 185 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 208 190 moveto +213 180 lineto +203 185 lineto +closepath +stroke +end grestore +% LeftModule(a:Rng) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 145 108 moveto +19 108 lineto +19 72 lineto +145 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 145 108 moveto +19 108 lineto +19 72 lineto +145 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +27 85 moveto +(LeftModule\(a:Rng\)) +[8.64 6.24 4.8 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 6.96 4.56] +xshow +end grestore +end grestore +% LeftModule(a:Ring)->LeftModule(a:Rng) +newpath 81 144 moveto +82 136 82 127 82 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 86 118 moveto +82 108 lineto +79 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 86 118 moveto +82 108 lineto +79 118 lineto +closepath +stroke +end grestore +% RightModule(a:Rng) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 298 108 moveto +164 108 lineto +164 72 lineto +298 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 298 108 moveto +164 108 lineto +164 72 lineto +298 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +172 85 moveto +(RightModule\(a:Rng\)) +[9.36 3.84 6.96 6.96 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 6.96 4.56] +xshow +end grestore +end grestore +% RightModule(a:Ring)->RightModule(a:Rng) +newpath 232 144 moveto +231 136 231 127 231 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 235 118 moveto +231 108 lineto +228 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 235 118 moveto +231 108 lineto +228 118 lineto +closepath +stroke +end grestore +% ABELGRP... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 201 36 moveto +111 36 lineto +111 0 lineto +201 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 201 36 moveto +111 36 lineto +111 0 lineto +201 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +118 13 moveto +(ABELGRP...) +[10.08 9.36 8.64 8.64 10.08 9.36 6.24 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RightModule(a:Rng)->ABELGRP... +newpath 212 72 moveto +203 63 192 53 182 43 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 185 41 moveto +175 36 lineto +180 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 185 41 moveto +175 36 lineto +180 46 lineto +closepath +stroke +end grestore +% LeftModule(a:Rng)->ABELGRP... +newpath 101 72 moveto +110 63 121 53 131 43 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 133 46 moveto +138 36 lineto +128 41 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 133 46 moveto +138 36 lineto +128 41 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102radicalcategory.ps b/books/ps/v102radicalcategory.ps new file mode 100644 index 0000000..960795c --- /dev/null +++ b/books/ps/v102radicalcategory.ps @@ -0,0 +1,294 @@ +%!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 164 152 +%%EndComments +save +%%BeginProlog +/DotDict 200 dict def +DotDict begin + +/setupLatin1 { +mark +/EncodingVector 256 array def + EncodingVector 0 + +ISOLatin1Encoding 0 255 getinterval putinterval +EncodingVector 45 /hyphen put + +% Set up ISO Latin 1 character encoding +/starnetISO { + dup dup findfont dup length dict begin + { 1 index /FID ne { def }{ pop pop } ifelse + } forall + /Encoding EncodingVector def + currentdict end definefont +} def +/Times-Roman starnetISO def +/Times-Italic starnetISO def +/Times-Bold starnetISO def +/Times-BoldItalic starnetISO def +/Helvetica starnetISO def +/Helvetica-Oblique starnetISO def +/Helvetica-Bold starnetISO def +/Helvetica-BoldOblique starnetISO def +/Courier starnetISO def +/Courier-Oblique starnetISO def +/Courier-Bold starnetISO def +/Courier-BoldOblique starnetISO def +cleartomark +} bind def + +%%BeginResource: procset graphviz 0 0 +/coord-font-family /Times-Roman def +/default-font-family /Times-Roman def +/coordfont coord-font-family findfont 8 scalefont def + +/InvScaleFactor 1.0 def +/set_scale { + dup 1 exch div /InvScaleFactor exch def + dup scale +} bind def + +% styles +/solid { [] 0 setdash } bind def +/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def +/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def +/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def +/bold { 2 setlinewidth } bind def +/filled { } bind def +/unfilled { } bind def +/rounded { } bind def +/diagonals { } bind def + +% hooks for setting color +/nodecolor { sethsbcolor } bind def +/edgecolor { sethsbcolor } bind def +/graphcolor { sethsbcolor } bind def +/nopcolor {pop pop pop} bind def + +/beginpage { % i j npages + /npages exch def + /j exch def + /i exch def + /str 10 string def + npages 1 gt { + gsave + coordfont setfont + 0 0 moveto + (\() show i str cvs show (,) show j str cvs show (\)) show + grestore + } if +} bind def + +/set_font { + findfont exch + scalefont setfont +} def + +% draw aligned label in bounding box aligned to current point +/alignedtext { % width adj text + /text exch def + /adj exch def + /width exch def + gsave + width 0 gt { + text stringwidth pop adj mul 0 rmoveto + } if + [] 0 setdash + text show + grestore +} def + +/boxprim { % xcorner ycorner xsize ysize + 4 2 roll + moveto + 2 copy + exch 0 rlineto + 0 exch rlineto + pop neg 0 rlineto + closepath +} bind def + +/ellipse_path { + /ry exch def + /rx exch def + /y exch def + /x exch def + matrix currentmatrix + newpath + x y translate + rx ry scale + 0 0 1 0 360 arc + setmatrix +} bind def + +/endpage { showpage } bind def +/showpage { } def + +/layercolorseq + [ % layer color sequence - darkest to lightest + [0 0 0] + [.2 .8 .8] + [.4 .8 .8] + [.6 .8 .8] + [.8 .8 .8] + ] +def + +/layerlen layercolorseq length def + +/setlayer {/maxlayer exch def /curlayer exch def + layercolorseq curlayer 1 sub layerlen mod get + aload pop sethsbcolor + /nodecolor {nopcolor} def + /edgecolor {nopcolor} def + /graphcolor {nopcolor} def +} bind def + +/onlayer { curlayer ne {invis} if } def + +/onlayers { + /myupper exch def + /mylower exch def + curlayer mylower lt + curlayer myupper gt + or + {invis} if +} def + +/curlayer 0 def + +%%EndResource +%%EndProlog +%%BeginSetup +14 default-font-family set_font +1 setmiterlimit +% /arrowlength 10 def +% /arrowwidth 5 def + +% make sure pdfmark is harmless for PS-interpreters other than Distiller +/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse +% make '<<' and '>>' safe on PS Level 1 devices +/languagelevel where {pop languagelevel}{1} ifelse +2 lt { + userdict (<<) cvn ([) cvn load put + userdict (>>) cvn ([) cvn load put +} if + +%%EndSetup +%%Page: 1 1 +%%PageBoundingBox: 36 36 164 152 +%%PageOrientation: Portrait +gsave +36 36 128 116 boxprim clip newpath +36 36 translate +0 0 1 beginpage +1.0000 set_scale +4 4 translate 0 rotate +0.167 0.600 1.000 graphcolor +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 114 lineto +126 114 lineto +126 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 114 lineto +126 114 lineto +126 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% RadicalCategory() +[ /Rect [ 0 72 120 108 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=RADCAT) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 120 108 moveto +0 108 lineto +0 72 lineto +120 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 120 108 moveto +0 108 lineto +0 72 lineto +120 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 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 +% Category +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 94 36 moveto +26 36 lineto +26 0 lineto +94 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 94 36 moveto +26 36 lineto +26 0 lineto +94 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +34 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 60 72 moveto +60 64 60 55 60 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 64 46 moveto +60 36 lineto +57 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 64 46 moveto +60 36 lineto +57 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102realconstant.ps b/books/ps/v102realconstant.ps new file mode 100644 index 0000000..d5d3a98 --- /dev/null +++ b/books/ps/v102realconstant.ps @@ -0,0 +1,447 @@ +%!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 370 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 370 296 +%%PageOrientation: Portrait +gsave +36 36 334 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 +332 258 lineto +332 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 258 lineto +332 258 lineto +332 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% RealConstant() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 223 252 moveto +123 252 lineto +123 216 lineto +223 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 223 252 moveto +123 252 lineto +123 216 lineto +223 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +130 229 moveto +(RealConstant\(\)) +[9.12 6.24 6.24 3.84 9.36 6.96 6.96 5.28 4.08 6.24 6.96 3.84 4.56 4.56] +xshow +end grestore +end grestore +% ConvertibleTo(DoubleFloat) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 174 180 moveto +0 180 lineto +0 144 lineto +174 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 174 180 moveto +0 180 lineto +0 144 lineto +174 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 157 moveto +(ConvertibleTo\(DoubleFloat\)) +[9.36 6.96 6.48 6.48 6.24 5.04 3.84 3.84 6.96 3.84 6.24 7.44 6.96 4.56 10.08 6.96 6.96 6.96 3.84 6.24 7.68 3.84 6.96 6.24 3.84 4.56] +xshow +end grestore +end grestore +% RealConstant()->ConvertibleTo(DoubleFloat) +newpath 151 216 moveto +140 207 127 196 116 186 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 118 183 moveto +108 180 lineto +114 189 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 118 183 moveto +108 180 lineto +114 189 lineto +closepath +stroke +end grestore +% ConvertibleTo(Float) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 326 180 moveto +192 180 lineto +192 144 lineto +326 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 326 180 moveto +192 180 lineto +192 144 lineto +326 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +200 157 moveto +(ConvertibleTo\(Float\)) +[9.36 6.96 6.48 6.48 6.24 5.04 3.84 3.84 6.96 3.84 6.24 7.44 6.96 4.56 7.68 3.84 6.96 6.24 3.84 4.56] +xshow +end grestore +end grestore +% RealConstant()->ConvertibleTo(Float) +newpath 195 216 moveto +206 207 219 196 230 186 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 232 189 moveto +238 180 lineto +228 183 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 232 189 moveto +238 180 lineto +228 183 lineto +closepath +stroke +end grestore +% ConvertibleTo(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 244 108 moveto +102 108 lineto +102 72 lineto +244 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 244 108 moveto +102 108 lineto +102 72 lineto +244 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +109 85 moveto +(ConvertibleTo\(a:Type\)) +[9.36 6.96 6.48 6.48 6.24 5.04 3.84 3.84 6.96 3.84 6.24 7.44 6.96 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% ConvertibleTo(DoubleFloat)->ConvertibleTo(a:Type) +newpath 109 144 moveto +120 135 133 124 144 114 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 146 117 moveto +152 108 lineto +142 111 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 146 117 moveto +152 108 lineto +142 111 lineto +closepath +stroke +end grestore +% ConvertibleTo(Float)->ConvertibleTo(a:Type) +newpath 237 144 moveto +226 135 213 124 202 114 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 204 111 moveto +194 108 lineto +200 117 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 204 111 moveto +194 108 lineto +200 117 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 207 36 moveto +139 36 lineto +139 0 lineto +207 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 207 36 moveto +139 36 lineto +139 0 lineto +207 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +147 13 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% ConvertibleTo(a:Type)->Category +newpath 173 72 moveto +173 64 173 55 173 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 177 46 moveto +173 36 lineto +170 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 177 46 moveto +173 36 lineto +170 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102realnumbersystem.ps b/books/ps/v102realnumbersystem.ps new file mode 100644 index 0000000..c98dc83 --- /dev/null +++ b/books/ps/v102realnumbersystem.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 812 152 +%%EndComments +save +%%BeginProlog +/DotDict 200 dict def +DotDict begin + +/setupLatin1 { +mark +/EncodingVector 256 array def + EncodingVector 0 + +ISOLatin1Encoding 0 255 getinterval putinterval +EncodingVector 45 /hyphen put + +% Set up ISO Latin 1 character encoding +/starnetISO { + dup dup findfont dup length dict begin + { 1 index /FID ne { def }{ pop pop } ifelse + } forall + /Encoding EncodingVector def + currentdict end definefont +} def +/Times-Roman starnetISO def +/Times-Italic starnetISO def +/Times-Bold starnetISO def +/Times-BoldItalic starnetISO def +/Helvetica starnetISO def +/Helvetica-Oblique starnetISO def +/Helvetica-Bold starnetISO def +/Helvetica-BoldOblique starnetISO def +/Courier starnetISO def +/Courier-Oblique starnetISO def +/Courier-Bold starnetISO def +/Courier-BoldOblique starnetISO def +cleartomark +} bind def + +%%BeginResource: procset graphviz 0 0 +/coord-font-family /Times-Roman def +/default-font-family /Times-Roman def +/coordfont coord-font-family findfont 8 scalefont def + +/InvScaleFactor 1.0 def +/set_scale { + dup 1 exch div /InvScaleFactor exch def + dup scale +} bind def + +% styles +/solid { [] 0 setdash } bind def +/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def +/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def +/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def +/bold { 2 setlinewidth } bind def +/filled { } bind def +/unfilled { } bind def +/rounded { } bind def +/diagonals { } bind def + +% hooks for setting color +/nodecolor { sethsbcolor } bind def +/edgecolor { sethsbcolor } bind def +/graphcolor { sethsbcolor } bind def +/nopcolor {pop pop pop} bind def + +/beginpage { % i j npages + /npages exch def + /j exch def + /i exch def + /str 10 string def + npages 1 gt { + gsave + coordfont setfont + 0 0 moveto + (\() show i str cvs show (,) show j str cvs show (\)) show + grestore + } if +} bind def + +/set_font { + findfont exch + scalefont setfont +} def + +% draw aligned label in bounding box aligned to current point +/alignedtext { % width adj text + /text exch def + /adj exch def + /width exch def + gsave + width 0 gt { + text stringwidth pop adj mul 0 rmoveto + } if + [] 0 setdash + text show + grestore +} def + +/boxprim { % xcorner ycorner xsize ysize + 4 2 roll + moveto + 2 copy + exch 0 rlineto + 0 exch rlineto + pop neg 0 rlineto + closepath +} bind def + +/ellipse_path { + /ry exch def + /rx exch def + /y exch def + /x exch def + matrix currentmatrix + newpath + x y translate + rx ry scale + 0 0 1 0 360 arc + setmatrix +} bind def + +/endpage { showpage } bind def +/showpage { } def + +/layercolorseq + [ % layer color sequence - darkest to lightest + [0 0 0] + [.2 .8 .8] + [.4 .8 .8] + [.6 .8 .8] + [.8 .8 .8] + ] +def + +/layerlen layercolorseq length def + +/setlayer {/maxlayer exch def /curlayer exch def + layercolorseq curlayer 1 sub layerlen mod get + aload pop sethsbcolor + /nodecolor {nopcolor} def + /edgecolor {nopcolor} def + /graphcolor {nopcolor} def +} bind def + +/onlayer { curlayer ne {invis} if } def + +/onlayers { + /myupper exch def + /mylower exch def + curlayer mylower lt + curlayer myupper gt + or + {invis} if +} def + +/curlayer 0 def + +%%EndResource +%%EndProlog +%%BeginSetup +14 default-font-family set_font +1 setmiterlimit +% /arrowlength 10 def +% /arrowwidth 5 def + +% make sure pdfmark is harmless for PS-interpreters other than Distiller +/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse +% make '<<' and '>>' safe on PS Level 1 devices +/languagelevel where {pop languagelevel}{1} ifelse +2 lt { + userdict (<<) cvn ([) cvn load put + userdict (>>) cvn ([) cvn load put +} if + +%%EndSetup +%%Page: 1 1 +%%PageBoundingBox: 36 36 812 152 +%%PageOrientation: Portrait +gsave +36 36 776 116 boxprim clip newpath +36 36 translate +0 0 1 beginpage +1.0000 set_scale +4 4 translate 0 rotate +0.167 0.600 1.000 graphcolor +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 114 lineto +774 114 lineto +774 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 114 lineto +774 114 lineto +774 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% RealNumberSystem() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 439 108 moveto +303 108 lineto +303 72 lineto +439 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 439 108 moveto +303 108 lineto +303 72 lineto +439 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +310 85 moveto +(RealNumberSystem\(\)) +[9.12 6.24 6.24 3.84 9.84 6.96 10.8 6.96 6.24 4.8 7.68 6.48 5.28 3.84 6.24 10.8 4.56 4.56] +xshow +end grestore +end grestore +% FIELD... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 66 36 moveto +0 36 lineto +0 0 lineto +66 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 66 36 moveto +0 36 lineto +0 0 lineto +66 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 13 moveto +(FIELD...) +[7.68 4.56 8.64 8.64 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RealNumberSystem()->FIELD... +newpath 303 82 moveto +244 74 159 60 76 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 77 33 moveto +66 33 lineto +75 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 77 33 moveto +66 33 lineto +75 39 lineto +closepath +stroke +end grestore +% ORDRING... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 174 36 moveto +84 36 lineto +84 0 lineto +174 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 174 36 moveto +84 36 lineto +84 0 lineto +174 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +91 13 moveto +(ORDRING...) +[10.08 9.36 10.08 9.36 4.56 9.84 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RealNumberSystem()->ORDRING... +newpath 307 72 moveto +273 63 230 50 184 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 185 33 moveto +174 33 lineto +183 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 185 33 moveto +174 33 lineto +183 39 lineto +closepath +stroke +end grestore +% REAL... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 256 36 moveto +192 36 lineto +192 0 lineto +256 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 256 36 moveto +192 36 lineto +192 0 lineto +256 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +200 13 moveto +(REAL...) +[9.36 8.64 10.08 8.64 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RealNumberSystem()->REAL... +newpath 334 72 moveto +313 62 287 49 265 38 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 267 35 moveto +256 34 lineto +264 41 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 267 35 moveto +256 34 lineto +264 41 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 364 36 moveto +274 36 lineto +274 0 lineto +364 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 364 36 moveto +274 36 lineto +274 0 lineto +364 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +282 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 +% RealNumberSystem()->RETRACT... +newpath 358 72 moveto +352 64 345 53 338 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 341 42 moveto +332 36 lineto +335 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 341 42 moveto +332 36 lineto +335 46 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 464 36 moveto +382 36 lineto +382 0 lineto +464 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 464 36 moveto +382 36 lineto +382 0 lineto +464 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +389 13 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 +% RealNumberSystem()->RADCAT... +newpath 384 72 moveto +390 64 397 53 404 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 407 46 moveto +410 36 lineto +401 42 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 407 46 moveto +410 36 lineto +401 42 lineto +closepath +stroke +end grestore +% KONVERT... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 574 36 moveto +482 36 lineto +482 0 lineto +574 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 574 36 moveto +482 36 lineto +482 0 lineto +574 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +489 13 moveto +(KONVERT...) +[9.12 10.08 10.08 10.08 8.64 8.88 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RealNumberSystem()->KONVERT... +newpath 411 72 moveto +432 62 458 50 480 40 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 481 43 moveto +489 36 lineto +478 37 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 481 43 moveto +489 36 lineto +478 37 lineto +closepath +stroke +end grestore +% PATMAB... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 676 36 moveto +592 36 lineto +592 0 lineto +676 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 676 36 moveto +592 36 lineto +592 0 lineto +676 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +599 13 moveto +(PATMAB...) +[6.48 9.36 8.64 12.48 10.08 9.36 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RealNumberSystem()->PATMAB... +newpath 439 74 moveto +479 65 529 52 582 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 583 39 moveto +592 33 lineto +581 33 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 583 39 moveto +592 33 lineto +581 33 lineto +closepath +stroke +end grestore +% CHARZ... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 768 36 moveto +694 36 lineto +694 0 lineto +768 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 768 36 moveto +694 36 lineto +694 0 lineto +768 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +701 13 moveto +(CHARZ...) +[9.36 10.08 10.08 9.36 8.64 3.6 3.6 3.6] +xshow +end grestore +end grestore +% RealNumberSystem()->CHARZ... +newpath 439 82 moveto +501 74 595 60 684 36 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 685 39 moveto +694 33 lineto +683 33 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 685 39 moveto +694 33 lineto +683 33 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102xalgebra.ps b/books/ps/v102xalgebra.ps new file mode 100644 index 0000000..a55753b --- /dev/null +++ b/books/ps/v102xalgebra.ps @@ -0,0 +1,881 @@ +%!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 536 368 +%%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 536 368 +%%PageOrientation: Portrait +gsave +36 36 500 332 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 330 lineto +498 330 lineto +498 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 330 lineto +498 330 lineto +498 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% XAlgebra(a:Ring) +[ /Rect [ 167 288 285 324 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=XALG) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 285 324 moveto +167 324 lineto +167 288 lineto +285 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 285 324 moveto +167 324 lineto +167 288 lineto +285 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +174 301 moveto +(XAlgebra\(a:Ring\)) +[10.08 10.08 3.84 6.72 6.24 6.96 4.8 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% Ring() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 190 252 moveto +136 252 lineto +136 216 lineto +190 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 190 252 moveto +136 252 lineto +136 216 lineto +190 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +144 229 moveto +(Ring\(\)) +[9.36 3.84 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% XAlgebra(a:Ring)->Ring() +newpath 210 288 moveto +202 279 193 269 186 260 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 188 257 moveto +179 252 lineto +183 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 188 257 moveto +179 252 lineto +183 262 lineto +closepath +stroke +end grestore +% BiModule(a:Ring,b:Ring) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 370 252 moveto +208 252 lineto +208 216 lineto +370 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 370 252 moveto +208 252 lineto +208 216 lineto +370 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +216 229 moveto +(BiModule\(a:Ring,b:Ring\)) +[9.36 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 3.6 6.96 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% XAlgebra(a:Ring)->BiModule(a:Ring,b:Ring) +newpath 242 288 moveto +250 279 259 269 266 260 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 269 262 moveto +273 252 lineto +264 257 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 269 262 moveto +273 252 lineto +264 257 lineto +closepath +stroke +end grestore +% Rng() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 190 180 moveto +136 180 lineto +136 144 lineto +190 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 190 180 moveto +136 180 lineto +136 144 lineto +190 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +146 157 moveto +(Rng\(\)) +[9.36 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% Ring()->Rng() +newpath 163 216 moveto +163 208 163 199 163 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 167 190 moveto +163 180 lineto +160 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 167 190 moveto +163 180 lineto +160 190 lineto +closepath +stroke +end grestore +% Monoid() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 118 180 moveto +48 180 lineto +48 144 lineto +118 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 118 180 moveto +48 180 lineto +48 144 lineto +118 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +55 157 moveto +(Monoid\(\)) +[12.48 6.96 6.96 6.96 3.84 6.96 4.56 4.56] +xshow +end grestore +end grestore +% Ring()->Monoid() +newpath 143 216 moveto +133 207 121 196 110 187 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 113 185 moveto +103 180 lineto +108 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 113 185 moveto +103 180 lineto +108 190 lineto +closepath +stroke +end grestore +% LeftModule(a:Ring) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 338 180 moveto +208 180 lineto +208 144 lineto +338 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 338 180 moveto +208 180 lineto +208 144 lineto +338 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +216 157 moveto +(LeftModule\(a:Ring\)) +[8.64 6.24 4.8 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% Ring()->LeftModule(a:Ring) +newpath 190 216 moveto +204 207 222 196 237 186 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 239 189 moveto +245 180 lineto +235 183 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 239 189 moveto +245 180 lineto +235 183 lineto +closepath +stroke +end grestore +% BiModule(a:Ring,b:Ring)->LeftModule(a:Ring) +newpath 285 216 moveto +283 208 281 199 279 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 282 189 moveto +277 180 lineto +276 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 282 189 moveto +277 180 lineto +276 190 lineto +closepath +stroke +end grestore +% RightModule(a:Ring) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 492 180 moveto +356 180 lineto +356 144 lineto +492 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 492 180 moveto +356 180 lineto +356 144 lineto +492 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +363 157 moveto +(RightModule\(a:Ring\)) +[9.36 3.84 6.96 6.96 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% BiModule(a:Ring,b:Ring)->RightModule(a:Ring) +newpath 323 216 moveto +341 207 363 195 381 185 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 383 188 moveto +390 180 lineto +380 182 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 383 188 moveto +390 180 lineto +380 182 lineto +closepath +stroke +end grestore +% ABELGRP... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 318 36 moveto +228 36 lineto +228 0 lineto +318 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 318 36 moveto +228 36 lineto +228 0 lineto +318 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +235 13 moveto +(ABELGRP...) +[10.08 9.36 8.64 8.64 10.08 9.36 6.24 3.6 3.6 3.6] +xshow +end grestore +end grestore +% Rng()->ABELGRP... +newpath 167 144 moveto +173 125 184 94 201 72 curveto +210 61 221 50 233 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 235 45 moveto +241 36 lineto +231 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 235 45 moveto +241 36 lineto +231 39 lineto +closepath +stroke +end grestore +% SemiGroup() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 131 108 moveto +41 108 lineto +41 72 lineto +131 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 131 108 moveto +41 108 lineto +41 72 lineto +131 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +49 85 moveto +(SemiGroup\(\)) +[7.68 6.24 10.8 3.84 10.08 4.8 6.96 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% Rng()->SemiGroup() +newpath 144 144 moveto +134 135 123 125 113 115 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 115 112 moveto +105 108 lineto +110 117 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 115 112 moveto +105 108 lineto +110 117 lineto +closepath +stroke +end grestore +% Monoid()->SemiGroup() +newpath 84 144 moveto +85 136 85 127 85 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 89 118 moveto +85 108 lineto +82 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 89 118 moveto +85 108 lineto +82 118 lineto +closepath +stroke +end grestore +% LeftModule(a:Rng) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 336 108 moveto +210 108 lineto +210 72 lineto +336 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 336 108 moveto +210 108 lineto +210 72 lineto +336 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +218 85 moveto +(LeftModule\(a:Rng\)) +[8.64 6.24 4.8 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 6.96 4.56] +xshow +end grestore +end grestore +% LeftModule(a:Ring)->LeftModule(a:Rng) +newpath 273 144 moveto +273 136 273 127 273 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 277 118 moveto +273 108 lineto +270 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 277 118 moveto +273 108 lineto +270 118 lineto +closepath +stroke +end grestore +% RightModule(a:Rng) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 489 108 moveto +355 108 lineto +355 72 lineto +489 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 489 108 moveto +355 108 lineto +355 72 lineto +489 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +363 85 moveto +(RightModule\(a:Rng\)) +[9.36 3.84 6.96 6.96 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 6.96 4.56] +xshow +end grestore +end grestore +% RightModule(a:Ring)->RightModule(a:Rng) +newpath 423 144 moveto +423 136 423 127 423 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 426 118 moveto +422 108 lineto +420 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 426 118 moveto +422 108 lineto +420 118 lineto +closepath +stroke +end grestore +% RightModule(a:Rng)->ABELGRP... +newpath 384 72 moveto +364 62 340 51 319 40 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 321 37 moveto +310 36 lineto +318 43 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 321 37 moveto +310 36 lineto +318 43 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 78 36 moveto +0 36 lineto +0 0 lineto +78 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 78 36 moveto +0 36 lineto +0 0 lineto +78 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 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 +% SemiGroup()->SETCAT... +newpath 74 72 moveto +69 64 62 54 56 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 59 43 moveto +51 36 lineto +53 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 59 43 moveto +51 36 lineto +53 46 lineto +closepath +stroke +end grestore +% REPSQ... +gsave 10 dict begin +filled +0.333 1.000 0.933 nodecolor +0.333 1.000 0.933 nodecolor +newpath 166 36 moveto +96 36 lineto +96 0 lineto +166 0 lineto +closepath +fill +0.333 1.000 0.933 nodecolor +newpath 166 36 moveto +96 36 lineto +96 0 lineto +166 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +103 13 moveto +(REPSQ...) +[9.36 8.64 7.68 7.68 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% SemiGroup()->REPSQ... +newpath 97 72 moveto +102 64 109 54 115 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 118 46 moveto +120 36 lineto +112 43 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 118 46 moveto +120 36 lineto +112 43 lineto +closepath +stroke +end grestore +% LeftModule(a:Rng)->ABELGRP... +newpath 273 72 moveto +273 64 273 55 273 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 277 46 moveto +273 36 lineto +270 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 277 46 moveto +273 36 lineto +270 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102xfreealgebra.ps b/books/ps/v102xfreealgebra.ps new file mode 100644 index 0000000..93d75e7 --- /dev/null +++ b/books/ps/v102xfreealgebra.ps @@ -0,0 +1,1096 @@ +%!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 722 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 722 440 +%%PageOrientation: Portrait +gsave +36 36 686 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 +684 402 lineto +684 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 402 lineto +684 402 lineto +684 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% XFreeAlgebra(a:OrderedSet,b:Ring) +[ /Rect [ 180 360 400 396 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=XFALG) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 400 396 moveto +180 396 lineto +180 360 lineto +400 360 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 400 396 moveto +180 396 lineto +180 360 lineto +400 360 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +187 373 moveto +(XFreeAlgebra\(a:OrderedSet,b:Ring\)) +[10.08 7.44 4.8 6.24 6.24 10.08 3.84 6.72 6.24 6.96 4.8 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 3.6 6.96 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% Ring() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 201 252 moveto +147 252 lineto +147 216 lineto +201 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 201 252 moveto +147 252 lineto +147 216 lineto +201 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +155 229 moveto +(Ring\(\)) +[9.36 3.84 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% XFreeAlgebra(a:OrderedSet,b:Ring)->Ring() +newpath 262 360 moveto +249 350 233 338 222 324 curveto +207 305 194 280 185 261 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 188 260 moveto +181 252 lineto +182 263 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 188 260 moveto +181 252 lineto +182 263 lineto +closepath +stroke +end grestore +% XAlgebra(a:Ring) +[ /Rect [ 231 288 349 324 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=XALG) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 349 324 moveto +231 324 lineto +231 288 lineto +349 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 349 324 moveto +231 324 lineto +231 288 lineto +349 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +238 301 moveto +(XAlgebra\(a:Ring\)) +[10.08 10.08 3.84 6.72 6.24 6.96 4.8 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% XFreeAlgebra(a:OrderedSet,b:Ring)->XAlgebra(a:Ring) +newpath 290 360 moveto +290 352 290 343 290 334 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 294 334 moveto +290 324 lineto +287 334 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 294 334 moveto +290 324 lineto +287 334 lineto +closepath +stroke +end grestore +% RetractableTo(OrderedFreeMonoid(OrderedSet)) +[ /Rect [ 388 288 678 324 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=RETRACT) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 678 324 moveto +388 324 lineto +388 288 lineto +678 288 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 678 324 moveto +388 324 lineto +388 288 lineto +678 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +395 301 moveto +(RetractableTo\(OrderedFreeMonoid\(OrderedSet\)\)) +[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 10.08 4.56 6.96 6.24 4.8 6.24 6.96 7.44 4.8 6.24 6.24 12.48 6.96 6.96 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 4.56 4.56] +xshow +end grestore +end grestore +% XFreeAlgebra(a:OrderedSet,b:Ring)->RetractableTo(OrderedFreeMonoid(OrderedSet)) +newpath 351 360 moveto +385 350 427 337 462 327 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 463 330 moveto +472 324 lineto +461 324 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 463 330 moveto +472 324 lineto +461 324 lineto +closepath +stroke +end grestore +% Rng() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 190 180 moveto +136 180 lineto +136 144 lineto +190 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 190 180 moveto +136 180 lineto +136 144 lineto +190 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +146 157 moveto +(Rng\(\)) +[9.36 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% Ring()->Rng() +newpath 171 216 moveto +170 208 168 199 167 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 170 190 moveto +166 180 lineto +164 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 170 190 moveto +166 180 lineto +164 190 lineto +closepath +stroke +end grestore +% Monoid() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 118 180 moveto +48 180 lineto +48 144 lineto +118 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 118 180 moveto +48 180 lineto +48 144 lineto +118 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +55 157 moveto +(Monoid\(\)) +[12.48 6.96 6.96 6.96 3.84 6.96 4.56 4.56] +xshow +end grestore +end grestore +% Ring()->Monoid() +newpath 151 216 moveto +140 207 126 196 114 186 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 116 183 moveto +106 180 lineto +112 189 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 116 183 moveto +106 180 lineto +112 189 lineto +closepath +stroke +end grestore +% LeftModule(a:Ring) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 338 180 moveto +208 180 lineto +208 144 lineto +338 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 338 180 moveto +208 180 lineto +208 144 lineto +338 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +216 157 moveto +(LeftModule\(a:Ring\)) +[8.64 6.24 4.8 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% Ring()->LeftModule(a:Ring) +newpath 199 216 moveto +211 207 226 196 240 186 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 242 189 moveto +248 180 lineto +238 183 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 242 189 moveto +248 180 lineto +238 183 lineto +closepath +stroke +end grestore +% XAlgebra(a:Ring)->Ring() +newpath 261 288 moveto +245 279 226 267 210 256 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 211 253 moveto +201 251 lineto +208 259 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 211 253 moveto +201 251 lineto +208 259 lineto +closepath +stroke +end grestore +% BiModule(a:Ring,b:Ring) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 381 252 moveto +219 252 lineto +219 216 lineto +381 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 381 252 moveto +219 252 lineto +219 216 lineto +381 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +227 229 moveto +(BiModule\(a:Ring,b:Ring\)) +[9.36 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 3.6 6.96 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% XAlgebra(a:Ring)->BiModule(a:Ring,b:Ring) +newpath 293 288 moveto +294 280 295 271 296 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 299 262 moveto +297 252 lineto +293 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 299 262 moveto +297 252 lineto +293 262 lineto +closepath +stroke +end grestore +% RetractableTo(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 608 252 moveto +468 252 lineto +468 216 lineto +608 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 608 252 moveto +468 252 lineto +468 216 lineto +608 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +475 229 moveto +(RetractableTo\(a:Type\)) +[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% RetractableTo(OrderedFreeMonoid(OrderedSet))->RetractableTo(a:Type) +newpath 534 288 moveto +535 280 535 271 536 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 539 262 moveto +537 252 lineto +533 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 539 262 moveto +537 252 lineto +533 262 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 578 180 moveto +510 180 lineto +510 144 lineto +578 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 578 180 moveto +510 180 lineto +510 144 lineto +578 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +518 157 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% RetractableTo(a:Type)->Category +newpath 540 216 moveto +541 208 541 199 542 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 546 190 moveto +542 180 lineto +539 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 546 190 moveto +542 180 lineto +539 190 lineto +closepath +stroke +end grestore +% BiModule(a:Ring,b:Ring)->LeftModule(a:Ring) +newpath 293 216 moveto +290 208 287 198 283 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 286 189 moveto +280 180 lineto +280 191 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 286 189 moveto +280 180 lineto +280 191 lineto +closepath +stroke +end grestore +% RightModule(a:Ring) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 492 180 moveto +356 180 lineto +356 144 lineto +492 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 492 180 moveto +356 180 lineto +356 144 lineto +492 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +363 157 moveto +(RightModule\(a:Ring\)) +[9.36 3.84 6.96 6.96 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% BiModule(a:Ring,b:Ring)->RightModule(a:Ring) +newpath 331 216 moveto +347 207 367 195 384 185 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 386 188 moveto +393 180 lineto +383 182 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 386 188 moveto +393 180 lineto +383 182 lineto +closepath +stroke +end grestore +% ABELGRP... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 318 36 moveto +228 36 lineto +228 0 lineto +318 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 318 36 moveto +228 36 lineto +228 0 lineto +318 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +235 13 moveto +(ABELGRP...) +[10.08 9.36 8.64 8.64 10.08 9.36 6.24 3.6 3.6 3.6] +xshow +end grestore +end grestore +% Rng()->ABELGRP... +newpath 168 144 moveto +173 125 184 94 201 72 curveto +210 61 222 50 234 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 236 45 moveto +242 36 lineto +232 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 236 45 moveto +242 36 lineto +232 39 lineto +closepath +stroke +end grestore +% SemiGroup() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 131 108 moveto +41 108 lineto +41 72 lineto +131 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 131 108 moveto +41 108 lineto +41 72 lineto +131 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +49 85 moveto +(SemiGroup\(\)) +[7.68 6.24 10.8 3.84 10.08 4.8 6.96 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% Rng()->SemiGroup() +newpath 144 144 moveto +134 135 123 125 113 115 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 115 112 moveto +105 108 lineto +110 117 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 115 112 moveto +105 108 lineto +110 117 lineto +closepath +stroke +end grestore +% Monoid()->SemiGroup() +newpath 84 144 moveto +85 136 85 127 85 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 89 118 moveto +85 108 lineto +82 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 89 118 moveto +85 108 lineto +82 118 lineto +closepath +stroke +end grestore +% LeftModule(a:Rng) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 336 108 moveto +210 108 lineto +210 72 lineto +336 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 336 108 moveto +210 108 lineto +210 72 lineto +336 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +218 85 moveto +(LeftModule\(a:Rng\)) +[8.64 6.24 4.8 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 6.96 4.56] +xshow +end grestore +end grestore +% LeftModule(a:Ring)->LeftModule(a:Rng) +newpath 273 144 moveto +273 136 273 127 273 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 277 118 moveto +273 108 lineto +270 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 277 118 moveto +273 108 lineto +270 118 lineto +closepath +stroke +end grestore +% RightModule(a:Rng) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 489 108 moveto +355 108 lineto +355 72 lineto +489 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 489 108 moveto +355 108 lineto +355 72 lineto +489 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +363 85 moveto +(RightModule\(a:Rng\)) +[9.36 3.84 6.96 6.96 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 6.96 4.56] +xshow +end grestore +end grestore +% RightModule(a:Ring)->RightModule(a:Rng) +newpath 423 144 moveto +423 136 423 127 423 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 426 118 moveto +422 108 lineto +420 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 426 118 moveto +422 108 lineto +420 118 lineto +closepath +stroke +end grestore +% RightModule(a:Rng)->ABELGRP... +newpath 384 72 moveto +364 62 340 51 319 40 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 321 37 moveto +310 36 lineto +318 43 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 321 37 moveto +310 36 lineto +318 43 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 78 36 moveto +0 36 lineto +0 0 lineto +78 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 78 36 moveto +0 36 lineto +0 0 lineto +78 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 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 +% SemiGroup()->SETCAT... +newpath 74 72 moveto +69 64 62 54 56 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 59 43 moveto +51 36 lineto +53 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 59 43 moveto +51 36 lineto +53 46 lineto +closepath +stroke +end grestore +% REPSQ... +gsave 10 dict begin +filled +0.333 1.000 0.933 nodecolor +0.333 1.000 0.933 nodecolor +newpath 166 36 moveto +96 36 lineto +96 0 lineto +166 0 lineto +closepath +fill +0.333 1.000 0.933 nodecolor +newpath 166 36 moveto +96 36 lineto +96 0 lineto +166 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +103 13 moveto +(REPSQ...) +[9.36 8.64 7.68 7.68 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% SemiGroup()->REPSQ... +newpath 97 72 moveto +102 64 109 54 115 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 118 46 moveto +120 36 lineto +112 43 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 118 46 moveto +120 36 lineto +112 43 lineto +closepath +stroke +end grestore +% LeftModule(a:Rng)->ABELGRP... +newpath 273 72 moveto +273 64 273 55 273 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 277 46 moveto +273 36 lineto +270 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 277 46 moveto +273 36 lineto +270 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102xpolynomialscat.ps b/books/ps/v102xpolynomialscat.ps new file mode 100644 index 0000000..97d419f --- /dev/null +++ b/books/ps/v102xpolynomialscat.ps @@ -0,0 +1,1147 @@ +%!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 722 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 722 512 +%%PageOrientation: Portrait +gsave +36 36 686 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 +684 474 lineto +684 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 474 lineto +684 474 lineto +684 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% XPolynomialsCat(a:OrderedRing,b:Ring) +[ /Rect [ 165 432 415 468 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=XPOLYC) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 415 468 moveto +165 468 lineto +165 432 lineto +415 432 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 415 468 moveto +165 468 lineto +165 432 lineto +415 432 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +173 445 moveto +(XPolynomialsCat\(a:OrderedRing,b:Ring\)) +[10.08 7.44 6.96 3.6 6.96 6.96 6.96 10.8 3.84 6.24 3.84 5.52 9.36 6.24 3.84 4.56 6.24 3.84 10.08 4.56 6.96 6.24 4.8 6.24 6.96 9.36 3.84 6.96 6.96 3.6 6.96 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% XFreeAlgebra(a:OrderedSet,b:Ring) +[ /Rect [ 180 360 400 396 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=XFALG) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 400 396 moveto +180 396 lineto +180 360 lineto +400 360 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 400 396 moveto +180 396 lineto +180 360 lineto +400 360 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +187 373 moveto +(XFreeAlgebra\(a:OrderedSet,b:Ring\)) +[10.08 7.44 4.8 6.24 6.24 10.08 3.84 6.72 6.24 6.96 4.8 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 3.6 6.96 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% XPolynomialsCat(a:OrderedRing,b:Ring)->XFreeAlgebra(a:OrderedSet,b:Ring) +newpath 290 432 moveto +290 424 290 415 290 406 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 294 406 moveto +290 396 lineto +287 406 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 294 406 moveto +290 396 lineto +287 406 lineto +closepath +stroke +end grestore +% Ring() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 201 252 moveto +147 252 lineto +147 216 lineto +201 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 201 252 moveto +147 252 lineto +147 216 lineto +201 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +155 229 moveto +(Ring\(\)) +[9.36 3.84 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% XFreeAlgebra(a:OrderedSet,b:Ring)->Ring() +newpath 262 360 moveto +249 350 233 338 222 324 curveto +207 305 194 280 185 261 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 188 260 moveto +181 252 lineto +182 263 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 188 260 moveto +181 252 lineto +182 263 lineto +closepath +stroke +end grestore +% XAlgebra(a:Ring) +[ /Rect [ 231 288 349 324 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=XALG) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 349 324 moveto +231 324 lineto +231 288 lineto +349 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 349 324 moveto +231 324 lineto +231 288 lineto +349 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +238 301 moveto +(XAlgebra\(a:Ring\)) +[10.08 10.08 3.84 6.72 6.24 6.96 4.8 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% XFreeAlgebra(a:OrderedSet,b:Ring)->XAlgebra(a:Ring) +newpath 290 360 moveto +290 352 290 343 290 334 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 294 334 moveto +290 324 lineto +287 334 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 294 334 moveto +290 324 lineto +287 334 lineto +closepath +stroke +end grestore +% RetractableTo(OrderedFreeMonoid(OrderedSet)) +[ /Rect [ 388 288 678 324 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=RETRACT) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 678 324 moveto +388 324 lineto +388 288 lineto +678 288 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 678 324 moveto +388 324 lineto +388 288 lineto +678 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +395 301 moveto +(RetractableTo\(OrderedFreeMonoid\(OrderedSet\)\)) +[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 10.08 4.56 6.96 6.24 4.8 6.24 6.96 7.44 4.8 6.24 6.24 12.48 6.96 6.96 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 4.56 4.56] +xshow +end grestore +end grestore +% XFreeAlgebra(a:OrderedSet,b:Ring)->RetractableTo(OrderedFreeMonoid(OrderedSet)) +newpath 351 360 moveto +385 350 427 337 462 327 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 463 330 moveto +472 324 lineto +461 324 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 463 330 moveto +472 324 lineto +461 324 lineto +closepath +stroke +end grestore +% Rng() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 190 180 moveto +136 180 lineto +136 144 lineto +190 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 190 180 moveto +136 180 lineto +136 144 lineto +190 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +146 157 moveto +(Rng\(\)) +[9.36 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% Ring()->Rng() +newpath 171 216 moveto +170 208 168 199 167 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 170 190 moveto +166 180 lineto +164 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 170 190 moveto +166 180 lineto +164 190 lineto +closepath +stroke +end grestore +% Monoid() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 118 180 moveto +48 180 lineto +48 144 lineto +118 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 118 180 moveto +48 180 lineto +48 144 lineto +118 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +55 157 moveto +(Monoid\(\)) +[12.48 6.96 6.96 6.96 3.84 6.96 4.56 4.56] +xshow +end grestore +end grestore +% Ring()->Monoid() +newpath 151 216 moveto +140 207 126 196 114 186 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 116 183 moveto +106 180 lineto +112 189 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 116 183 moveto +106 180 lineto +112 189 lineto +closepath +stroke +end grestore +% LeftModule(a:Ring) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 338 180 moveto +208 180 lineto +208 144 lineto +338 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 338 180 moveto +208 180 lineto +208 144 lineto +338 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +216 157 moveto +(LeftModule\(a:Ring\)) +[8.64 6.24 4.8 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% Ring()->LeftModule(a:Ring) +newpath 199 216 moveto +211 207 226 196 240 186 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 242 189 moveto +248 180 lineto +238 183 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 242 189 moveto +248 180 lineto +238 183 lineto +closepath +stroke +end grestore +% XAlgebra(a:Ring)->Ring() +newpath 261 288 moveto +245 279 226 267 210 256 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 211 253 moveto +201 251 lineto +208 259 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 211 253 moveto +201 251 lineto +208 259 lineto +closepath +stroke +end grestore +% BiModule(a:Ring,b:Ring) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 381 252 moveto +219 252 lineto +219 216 lineto +381 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 381 252 moveto +219 252 lineto +219 216 lineto +381 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +227 229 moveto +(BiModule\(a:Ring,b:Ring\)) +[9.36 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 3.6 6.96 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% XAlgebra(a:Ring)->BiModule(a:Ring,b:Ring) +newpath 293 288 moveto +294 280 295 271 296 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 299 262 moveto +297 252 lineto +293 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 299 262 moveto +297 252 lineto +293 262 lineto +closepath +stroke +end grestore +% RetractableTo(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 608 252 moveto +468 252 lineto +468 216 lineto +608 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 608 252 moveto +468 252 lineto +468 216 lineto +608 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +475 229 moveto +(RetractableTo\(a:Type\)) +[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% RetractableTo(OrderedFreeMonoid(OrderedSet))->RetractableTo(a:Type) +newpath 534 288 moveto +535 280 535 271 536 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 539 262 moveto +537 252 lineto +533 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 539 262 moveto +537 252 lineto +533 262 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 578 180 moveto +510 180 lineto +510 144 lineto +578 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 578 180 moveto +510 180 lineto +510 144 lineto +578 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +518 157 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% RetractableTo(a:Type)->Category +newpath 540 216 moveto +541 208 541 199 542 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 546 190 moveto +542 180 lineto +539 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 546 190 moveto +542 180 lineto +539 190 lineto +closepath +stroke +end grestore +% BiModule(a:Ring,b:Ring)->LeftModule(a:Ring) +newpath 293 216 moveto +290 208 287 198 283 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 286 189 moveto +280 180 lineto +280 191 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 286 189 moveto +280 180 lineto +280 191 lineto +closepath +stroke +end grestore +% RightModule(a:Ring) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 492 180 moveto +356 180 lineto +356 144 lineto +492 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 492 180 moveto +356 180 lineto +356 144 lineto +492 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +363 157 moveto +(RightModule\(a:Ring\)) +[9.36 3.84 6.96 6.96 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% BiModule(a:Ring,b:Ring)->RightModule(a:Ring) +newpath 331 216 moveto +347 207 367 195 384 185 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 386 188 moveto +393 180 lineto +383 182 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 386 188 moveto +393 180 lineto +383 182 lineto +closepath +stroke +end grestore +% ABELGRP... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 318 36 moveto +228 36 lineto +228 0 lineto +318 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 318 36 moveto +228 36 lineto +228 0 lineto +318 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +235 13 moveto +(ABELGRP...) +[10.08 9.36 8.64 8.64 10.08 9.36 6.24 3.6 3.6 3.6] +xshow +end grestore +end grestore +% Rng()->ABELGRP... +newpath 168 144 moveto +173 125 184 94 201 72 curveto +210 61 222 50 234 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 236 45 moveto +242 36 lineto +232 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 236 45 moveto +242 36 lineto +232 39 lineto +closepath +stroke +end grestore +% SemiGroup() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 131 108 moveto +41 108 lineto +41 72 lineto +131 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 131 108 moveto +41 108 lineto +41 72 lineto +131 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +49 85 moveto +(SemiGroup\(\)) +[7.68 6.24 10.8 3.84 10.08 4.8 6.96 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% Rng()->SemiGroup() +newpath 144 144 moveto +134 135 123 125 113 115 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 115 112 moveto +105 108 lineto +110 117 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 115 112 moveto +105 108 lineto +110 117 lineto +closepath +stroke +end grestore +% Monoid()->SemiGroup() +newpath 84 144 moveto +85 136 85 127 85 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 89 118 moveto +85 108 lineto +82 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 89 118 moveto +85 108 lineto +82 118 lineto +closepath +stroke +end grestore +% LeftModule(a:Rng) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 336 108 moveto +210 108 lineto +210 72 lineto +336 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 336 108 moveto +210 108 lineto +210 72 lineto +336 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +218 85 moveto +(LeftModule\(a:Rng\)) +[8.64 6.24 4.8 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 6.96 4.56] +xshow +end grestore +end grestore +% LeftModule(a:Ring)->LeftModule(a:Rng) +newpath 273 144 moveto +273 136 273 127 273 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 277 118 moveto +273 108 lineto +270 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 277 118 moveto +273 108 lineto +270 118 lineto +closepath +stroke +end grestore +% RightModule(a:Rng) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 489 108 moveto +355 108 lineto +355 72 lineto +489 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 489 108 moveto +355 108 lineto +355 72 lineto +489 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +363 85 moveto +(RightModule\(a:Rng\)) +[9.36 3.84 6.96 6.96 3.84 12.48 6.96 6.96 6.96 3.84 6.24 4.56 6.24 3.84 9.36 6.96 6.96 4.56] +xshow +end grestore +end grestore +% RightModule(a:Ring)->RightModule(a:Rng) +newpath 423 144 moveto +423 136 423 127 423 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 426 118 moveto +422 108 lineto +420 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 426 118 moveto +422 108 lineto +420 118 lineto +closepath +stroke +end grestore +% RightModule(a:Rng)->ABELGRP... +newpath 384 72 moveto +364 62 340 51 319 40 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 321 37 moveto +310 36 lineto +318 43 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 321 37 moveto +310 36 lineto +318 43 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 78 36 moveto +0 36 lineto +0 0 lineto +78 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 78 36 moveto +0 36 lineto +0 0 lineto +78 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 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 +% SemiGroup()->SETCAT... +newpath 74 72 moveto +69 64 62 54 56 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 59 43 moveto +51 36 lineto +53 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 59 43 moveto +51 36 lineto +53 46 lineto +closepath +stroke +end grestore +% REPSQ... +gsave 10 dict begin +filled +0.333 1.000 0.933 nodecolor +0.333 1.000 0.933 nodecolor +newpath 166 36 moveto +96 36 lineto +96 0 lineto +166 0 lineto +closepath +fill +0.333 1.000 0.933 nodecolor +newpath 166 36 moveto +96 36 lineto +96 0 lineto +166 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +103 13 moveto +(REPSQ...) +[9.36 8.64 7.68 7.68 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% SemiGroup()->REPSQ... +newpath 97 72 moveto +102 64 109 54 115 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 118 46 moveto +120 36 lineto +112 43 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 118 46 moveto +120 36 lineto +112 43 lineto +closepath +stroke +end grestore +% LeftModule(a:Rng)->ABELGRP... +newpath 273 72 moveto +273 64 273 55 273 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 277 46 moveto +273 36 lineto +270 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 277 46 moveto +273 36 lineto +270 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 02e2bca..6cd36af 100644 --- a/changelog +++ b/changelog @@ -1,3 +1,19 @@ +20081007 tpd books/bookvol10.2 add categories, update ATTREG +20081007 tpd books/ps/v102xpolynomialscat.ps added +20081007 tpd books/ps/v102xfreealgebra.ps added +20081007 tpd books/ps/v102xalgebra.ps added +20081007 tpd books/ps/v102realnumbersystem.ps added +20081007 tpd books/ps/v102realconstant.ps added +20081007 tpd books/ps/v102radicalcategory.ps added +20081007 tpd books/ps/v102liealgebra.ps added +20081007 tpd books/ps/v102freemodulecat.ps added +20081007 tpd books/ps/v102freeliealgebra.ps added +20081007 tpd books/ps/v102floatingpointsystem.ps added +20081007 tpd books/ps/v102cachableset.ps added +20081007 tpd books/bookvol10.2/ATTREG add approximate +20081007 tpd src/algebra/sf.spad add floating point categories to bookvol10.2 +20081007 tpd src/algebra/xpoly.spad move several categories to bookvol10.2 +20081007 tpd src/algebra/kl.spad moved CACHSET to bookvol10.2 20081006 tpd books/bookvol10.2.pamphlet add categories 20081006 tpd src/algebra/Makefile remove fortcat.spad 20081006 tpd src/algebra/fortcat.spad.pamphlet absorbed into bookvol10.2 diff --git a/src/algebra/kl.spad.pamphlet b/src/algebra/kl.spad.pamphlet index 4772c2f..21c6869 100644 --- a/src/algebra/kl.spad.pamphlet +++ b/src/algebra/kl.spad.pamphlet @@ -9,23 +9,6 @@ \eject \tableofcontents \eject -\section{category CACHSET CachableSet} -<>= -)abbrev category CACHSET CachableSet -++ Sets whose elements can cache an integer -++ Author: Manuel Bronstein -++ Date Created: 31 Oct 1988 -++ Date Last Updated: 14 May 1991 -++ Description: -++ A cachable set is a set whose elements keep an integer as part -++ of their structure. -CachableSet: Category == OrderedSet with - position : % -> NonNegativeInteger - ++ position(x) returns the integer n associated to x. - setPosition: (%, NonNegativeInteger) -> Void - ++ setPosition(x, n) associates the integer n to x. - -@ \section{package SCACHE SortedCache} <>= )abbrev package SCACHE SortedCache @@ -655,7 +638,6 @@ KernelFunctions2(R:OrderedSet, S:OrderedSet): with -- -- op KL expr function -<> <> <> <> diff --git a/src/algebra/sf.spad.pamphlet b/src/algebra/sf.spad.pamphlet index c35c3b4..825d704 100644 --- a/src/algebra/sf.spad.pamphlet +++ b/src/algebra/sf.spad.pamphlet @@ -9,670 +9,6 @@ \eject \tableofcontents \eject -\section{category REAL RealConstant} -<>= -"REAL" -> "KONVERT" -"RealConstant()" -> "ConvertibleTo(DoubleFloat)" -"RealConstant()" -> "ConvertibleTo(Float)" -@ -<>= -)abbrev category REAL RealConstant -++ Author: -++ Date Created: -++ Date Last Updated: -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ References: -++ Description: -++ The category of real numeric domains, i.e. convertible to floats. -RealConstant(): Category == - Join(ConvertibleTo DoubleFloat, ConvertibleTo Float) - -@ -\section{category RADCAT RadicalCategory} -<>= -"RADCAT" -> "CATEGORY" -"RadicalCategory()" -> "Category" -@ -<>= -)abbrev category RADCAT RadicalCategory -++ Author: -++ Date Created: -++ Change History: -++ Basic Operations: nthRoot, sqrt, ** -++ Related Constructors: -++ Keywords: rational numbers -++ Description: The \spad{RadicalCategory} is a model for the rational numbers. -RadicalCategory(): Category == with - sqrt : % -> % - ++ sqrt(x) returns the square root of x. - nthRoot: (%, Integer) -> % - ++ nthRoot(x,n) returns the nth root of x. - _*_* : (%, Fraction Integer) -> % - ++ x ** y is the rational exponentiation of x by the power y. - add - sqrt x == x ** inv(2::Fraction(Integer)) - nthRoot(x, n) == x ** inv(n::Fraction(Integer)) - -@ -\section{category RNS RealNumberSystem} -<>= -"RNS" -> "FIELD" -"RealNumberSystem()" -> "Field()" -"RNS" -> "ORDRING" -"RealNumberSystem()" -> "OrderedRing()" -"RNS" -> "REAL" -"RealNumberSystem()" -> "RealConstant()" -"RNS" -> "RETRACT" -"RealNumberSystem()" -> "RetractableTo(Integer)" -"RealNumberSystem()" -> "RetractableTo(Fraction(Integer))" -"RNS" -> "RADCAT" -"RealNumberSystem()" -> "RadicalCategory()" -"RNS" -> "KONVERT" -"RealNumberSystem()" -> "ConvertibleTo(Pattern(Float))" -"RNS" -> "PATMAB" -"RealNumberSystem()" -> "PatternMatchable(Float)" -"RNS" -> "CHARZ" -"RealNumberSystem()" -> "CharacteristicZero()" -@ -<>= -)abbrev category RNS RealNumberSystem -++ Author: Michael Monagan and Stephen M. Watt -++ Date Created: -++ January 1988 -++ Change History: -++ Basic Operations: abs, ceiling, wholePart, floor, fractionPart, norm, round, truncate -++ Related Constructors: -++ Keywords: real numbers -++ Description: -++ The real number system category is intended as a model for the real -++ numbers. The real numbers form an ordered normed field. Note that -++ we have purposely not included \spadtype{DifferentialRing} or the elementary -++ functions (see \spadtype{TranscendentalFunctionCategory}) in the definition. -RealNumberSystem(): Category == - Join(Field, OrderedRing, RealConstant, RetractableTo Integer, - RetractableTo Fraction Integer, RadicalCategory, - ConvertibleTo Pattern Float, PatternMatchable Float, - CharacteristicZero) with - norm : % -> % - ++ norm x returns the same as absolute value. - ceiling : % -> % - ++ ceiling x returns the small integer \spad{>= x}. - floor: % -> % - ++ floor x returns the largest integer \spad{<= x}. - wholePart : % -> Integer - ++ wholePart x returns the integer part of x. - fractionPart : % -> % - ++ fractionPart x returns the fractional part of x. - truncate: % -> % - ++ truncate x returns the integer between x and 0 closest to x. - round: % -> % - ++ round x computes the integer closest to x. - abs : % -> % - ++ abs x returns the absolute value of x. - - add - characteristic() == 0 - fractionPart x == x - truncate x - truncate x == (negative? x => -floor(-x); floor x) - round x == (negative? x => truncate(x-1/2::%); truncate(x+1/2::%)) - norm x == abs x - coerce(x:Fraction Integer):% == numer(x)::% / denom(x)::% - convert(x:%):Pattern(Float) == convert(x)@Float :: Pattern(Float) - - floor x == - x1 := (wholePart x) :: % - x = x1 => x - x < 0 => (x1 - 1) - x1 - - ceiling x == - x1 := (wholePart x)::% - x = x1 => x - x >= 0 => (x1 + 1) - x1 - - patternMatch(x, p, l) == - generic? p => addMatch(p, x, l) - constant? p => - (r := retractIfCan(p)@Union(Float, "failed")) case Float => - convert(x)@Float = r::Float => l - failed() - failed() - failed() - -@ -\section{RNS.lsp BOOTSTRAP} -{\bf RNS} 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 RNS} category which we can write -into the {\bf MID} directory. We compile the lisp code and copy the -{\bf RNS.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 |RealNumberSystem;AL| (QUOTE NIL)) - -(DEFUN |RealNumberSystem| NIL - (LET (#:G105478) - (COND - (|RealNumberSystem;AL|) - (T (SETQ |RealNumberSystem;AL| (|RealNumberSystem;|)))))) - -(DEFUN |RealNumberSystem;| NIL - (PROG (#1=#:G105476) - (RETURN - (PROG1 - (LETT #1# - (|sublisV| - (PAIR - (QUOTE (#2=#:G105472 #3=#:G105473 #4=#:G105474 #5=#:G105475)) - (LIST - (QUOTE (|Integer|)) - (QUOTE (|Fraction| (|Integer|))) - (QUOTE (|Pattern| (|Float|))) - (QUOTE (|Float|)))) - (|Join| - (|Field|) - (|OrderedRing|) - (|RealConstant|) - (|RetractableTo| (QUOTE #2#)) - (|RetractableTo| (QUOTE #3#)) - (|RadicalCategory|) - (|ConvertibleTo| (QUOTE #4#)) - (|PatternMatchable| (QUOTE #5#)) - (|CharacteristicZero|) - (|mkCategory| - (QUOTE |domain|) - (QUOTE ( - ((|norm| (|$| |$|)) T) - ((|ceiling| (|$| |$|)) T) - ((|floor| (|$| |$|)) T) - ((|wholePart| ((|Integer|) |$|)) T) - ((|fractionPart| (|$| |$|)) T) - ((|truncate| (|$| |$|)) T) - ((|round| (|$| |$|)) T) - ((|abs| (|$| |$|)) T))) - NIL - (QUOTE ((|Integer|))) - NIL))) - |RealNumberSystem|) - (SETELT #1# 0 (QUOTE (|RealNumberSystem|))))))) - -(MAKEPROP (QUOTE |RealNumberSystem|) (QUOTE NILADIC) T) - -@ -\section{RNS-.lsp BOOTSTRAP} -{\bf RNS-} depends {\bf RNS}. -We need to break this cycle to build the algebra. So we keep a -cached copy of the translated {\bf RNS-} category which we can write -into the {\bf MID} directory. We compile the lisp code and copy the -{\bf RNS.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) - -(PUT - (QUOTE |RNS-;characteristic;Nni;1|) - (QUOTE |SPADreplace|) - (QUOTE (XLAM NIL 0))) - -(DEFUN |RNS-;characteristic;Nni;1| (|$|) 0) - -(DEFUN |RNS-;fractionPart;2S;2| (|x| |$|) - (SPADCALL |x| (SPADCALL |x| (QREFELT |$| 9)) (QREFELT |$| 10))) - -(DEFUN |RNS-;truncate;2S;3| (|x| |$|) - (COND - ((SPADCALL |x| (QREFELT |$| 13)) - (SPADCALL - (SPADCALL - (SPADCALL |x| (QREFELT |$| 14)) - (QREFELT |$| 15)) - (QREFELT |$| 14))) - ((QUOTE T) (SPADCALL |x| (QREFELT |$| 15))))) - -(DEFUN |RNS-;round;2S;4| (|x| |$|) - (COND - ((SPADCALL |x| (QREFELT |$| 13)) - (SPADCALL - (SPADCALL |x| - (SPADCALL - (|spadConstant| |$| 17) - (SPADCALL 2 (QREFELT |$| 19)) - (QREFELT |$| 20)) - (QREFELT |$| 10)) - (QREFELT |$| 9))) - ((QUOTE T) - (SPADCALL - (SPADCALL |x| - (SPADCALL - (|spadConstant| |$| 17) - (SPADCALL 2 (QREFELT |$| 19)) - (QREFELT |$| 20)) - (QREFELT |$| 21)) - (QREFELT |$| 9))))) - -(DEFUN |RNS-;norm;2S;5| (|x| |$|) - (SPADCALL |x| (QREFELT |$| 23))) - -(DEFUN |RNS-;coerce;FS;6| (|x| |$|) - (SPADCALL - (SPADCALL - (SPADCALL |x| (QREFELT |$| 26)) - (QREFELT |$| 19)) - (SPADCALL - (SPADCALL |x| (QREFELT |$| 27)) - (QREFELT |$| 19)) - (QREFELT |$| 20))) - -(DEFUN |RNS-;convert;SP;7| (|x| |$|) - (SPADCALL (SPADCALL |x| (QREFELT |$| 30)) (QREFELT |$| 32))) - -(DEFUN |RNS-;floor;2S;8| (|x| |$|) - (PROG (|x1|) - (RETURN - (SEQ - (LETT |x1| - (SPADCALL (SPADCALL |x| (QREFELT |$| 34)) (QREFELT |$| 19)) - |RNS-;floor;2S;8|) - (EXIT - (COND - ((SPADCALL |x| |x1| (QREFELT |$| 35)) |x|) - ((SPADCALL |x| (|spadConstant| |$| 36) (QREFELT |$| 37)) - (SPADCALL |x1| (|spadConstant| |$| 17) (QREFELT |$| 10))) - ((QUOTE T) |x1|))))))) - -(DEFUN |RNS-;ceiling;2S;9| (|x| |$|) - (PROG (|x1|) - (RETURN - (SEQ - (LETT |x1| - (SPADCALL (SPADCALL |x| (QREFELT |$| 34)) (QREFELT |$| 19)) - |RNS-;ceiling;2S;9|) - (EXIT - (COND - ((SPADCALL |x| |x1| (QREFELT |$| 35)) |x|) - ((SPADCALL |x| (|spadConstant| |$| 36) (QREFELT |$| 37)) |x1|) - ((QUOTE T) - (SPADCALL |x1| (|spadConstant| |$| 17) (QREFELT |$| 21))))))))) - -(DEFUN |RNS-;patternMatch;SP2Pmr;10| (|x| |p| |l| |$|) - (PROG (|r|) - (RETURN - (SEQ - (COND - ((SPADCALL |p| (QREFELT |$| 40)) - (SPADCALL |p| |x| |l| (QREFELT |$| 42))) - ((SPADCALL |p| (QREFELT |$| 43)) - (SEQ - (LETT |r| - (SPADCALL |p| (QREFELT |$| 45)) - |RNS-;patternMatch;SP2Pmr;10|) - (EXIT - (COND - ((QEQCAR |r| 0) - (COND - ((SPADCALL - (SPADCALL |x| (QREFELT |$| 30)) - (QCDR |r|) - (QREFELT |$| 46)) - |l|) - ((QUOTE T) (SPADCALL (QREFELT |$| 47))))) - ((QUOTE T) (SPADCALL (QREFELT |$| 47))))))) - ((QUOTE T) (SPADCALL (QREFELT |$| 47)))))))) - -(DEFUN |RealNumberSystem&| (|#1|) - (PROG (|DV$1| |dv$| |$| |pv$|) - (RETURN - (PROGN - (LETT |DV$1| (|devaluate| |#1|) . #1=(|RealNumberSystem&|)) - (LETT |dv$| (LIST (QUOTE |RealNumberSystem&|) |DV$1|) . #1#) - (LETT |$| (GETREFV 52) . #1#) - (QSETREFV |$| 0 |dv$|) - (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#)) - (|stuffDomainSlots| |$|) - (QSETREFV |$| 6 |#1|) - |$|)))) - -(MAKEPROP - (QUOTE |RealNumberSystem&|) - (QUOTE |infovec|) - (LIST - (QUOTE - #(NIL NIL NIL NIL NIL NIL - (|local| |#1|) - (|NonNegativeInteger|) - |RNS-;characteristic;Nni;1| - (0 . |truncate|) - (5 . |-|) - |RNS-;fractionPart;2S;2| - (|Boolean|) - (11 . |negative?|) - (16 . |-|) - (21 . |floor|) - |RNS-;truncate;2S;3| - (26 . |One|) - (|Integer|) - (30 . |coerce|) - (35 . |/|) - (41 . |+|) - |RNS-;round;2S;4| - (47 . |abs|) - |RNS-;norm;2S;5| - (|Fraction| 18) - (52 . |numer|) - (57 . |denom|) - |RNS-;coerce;FS;6| - (|Float|) - (62 . |convert|) - (|Pattern| 29) - (67 . |coerce|) - |RNS-;convert;SP;7| - (72 . |wholePart|) - (77 . |=|) - (83 . |Zero|) - (87 . |<|) - |RNS-;floor;2S;8| - |RNS-;ceiling;2S;9| - (93 . |generic?|) - (|PatternMatchResult| 29 6) - (98 . |addMatch|) - (105 . |constant?|) - (|Union| 29 (QUOTE "failed")) - (110 . |retractIfCan|) - (115 . |=|) - (121 . |failed|) - (|PatternMatchResult| 29 |$|) - |RNS-;patternMatch;SP2Pmr;10| - (|DoubleFloat|) - (|OutputForm|))) - (QUOTE - #(|truncate| 125 |round| 130 |patternMatch| 135 |norm| 142 - |fractionPart| 147 |floor| 152 |convert| 157 |coerce| 162 - |characteristic| 172 |ceiling| 176)) - (QUOTE NIL) - (CONS - (|makeByteWordVec2| 1 (QUOTE NIL)) - (CONS - (QUOTE #()) - (CONS - (QUOTE #()) - (|makeByteWordVec2| 49 - (QUOTE - (1 6 0 0 9 2 6 0 0 0 10 1 6 12 0 13 1 6 0 0 14 1 6 0 0 15 0 6 0 - 17 1 6 0 18 19 2 6 0 0 0 20 2 6 0 0 0 21 1 6 0 0 23 1 25 18 0 - 26 1 25 18 0 27 1 6 29 0 30 1 31 0 29 32 1 6 18 0 34 2 6 12 0 - 0 35 0 6 0 36 2 6 12 0 0 37 1 31 12 0 40 3 41 0 31 6 0 42 1 31 - 12 0 43 1 31 44 0 45 2 29 12 0 0 46 0 41 0 47 1 0 0 0 16 1 0 0 - 0 22 3 0 48 0 31 48 49 1 0 0 0 24 1 0 0 0 11 1 0 0 0 38 1 0 31 - 0 33 1 0 0 25 28 1 0 0 25 28 0 0 7 8 1 0 0 0 39)))))) - (QUOTE |lookupComplete|))) - -@ -\section{category FPS FloatingPointSystem} -<>= -"FPS" -> "RNS" -"FloatingPointSystem()" -> "RealNumberSystem()" -@ -<>= -)abbrev category FPS FloatingPointSystem -++ Author: -++ Date Created: -++ Change History: -++ Basic Operations: approximate, base, bits, digits, exponent, float, -++ mantissa, order, precision, round? -++ Related Constructors: -++ Keywords: float, floating point -++ Description: -++ This category is intended as a model for floating point systems. -++ A floating point system is a model for the real numbers. In fact, -++ it is an approximation in the sense that not all real numbers are -++ exactly representable by floating point numbers. -++ A floating point system is characterized by the following: -++ -++ 1: \spadfunFrom{base}{FloatingPointSystem} of the -++ \spadfunFrom{exponent}{FloatingPointSystem}. -++ (actual implemenations are usually binary or decimal) -++ 2: \spadfunFrom{precision}{FloatingPointSystem} of the -++ \spadfunFrom{mantissa}{FloatingPointSystem} (arbitrary or fixed) -++ 3: rounding error for operations ---++ 4: when, and what happens if exponent overflow/underflow occurs -++ -++ Because a Float is an approximation to the real numbers, even though -++ it is defined to be a join of a Field and OrderedRing, some of -++ the attributes do not hold. In particular associative("+") -++ does not hold. Algorithms defined over a field need special -++ considerations when the field is a floating point system. -FloatingPointSystem(): Category == RealNumberSystem() with - approximate - ++ \spad{approximate} means "is an approximation to the real numbers". - float: (Integer,Integer) -> % - ++ float(a,e) returns \spad{a * base() ** e}. - float: (Integer,Integer,PositiveInteger) -> % - ++ float(a,e,b) returns \spad{a * b ** e}. - order: % -> Integer - ++ order x is the order of magnitude of x. - ++ Note: \spad{base ** order x <= |x| < base ** (1 + order x)}. - base: () -> PositiveInteger - ++ base() returns the base of the - ++\spadfunFrom{exponent}{FloatingPointSystem}. - - exponent: % -> Integer - ++ exponent(x) returns the - ++ \spadfunFrom{exponent}{FloatingPointSystem} part of x. - - mantissa: % -> Integer - ++ mantissa(x) returns the mantissa part of x. - -- round?: () -> B - -- ++ round?() returns the rounding or chopping. - - bits: () -> PositiveInteger - ++ bits() returns ceiling's precision in bits. - digits: () -> PositiveInteger - ++ digits() returns ceiling's precision in decimal digits. - precision: () -> PositiveInteger - ++ precision() returns the precision in digits base. - - if % has arbitraryPrecision then - bits: PositiveInteger -> PositiveInteger - ++ bits(n) set the \spadfunFrom{precision}{FloatingPointSystem} - ++ to n bits. - - digits: PositiveInteger -> PositiveInteger - ++ digits(d) set the \spadfunFrom{precision}{FloatingPointSystem} - ++ to d digits. - - precision: PositiveInteger -> PositiveInteger - ++ precision(n) set the precision in the base to n decimal digits. - - increasePrecision: Integer -> PositiveInteger - ++ increasePrecision(n) increases the current - ++ \spadfunFrom{precision}{FloatingPointSystem} by n decimal digits. - - decreasePrecision: Integer -> PositiveInteger - ++ decreasePrecision(n) decreases the current - ++ \spadfunFrom{precision}{FloatingPointSystem} precision - ++ by n decimal digits. - - if not (% has arbitraryExponent) then - -- overflow: (()->Exit) -> Void - -- ++ overflow() returns the Exponent overflow of float - -- underflow: (()->Exit) -> Void - -- ++ underflow() returns the Exponent underflow of float - -- maxExponent: () -> Integer - -- ++ maxExponent() returns the max Exponent of float - if not (% has arbitraryPrecision) then - min: () -> % - ++ min() returns the minimum floating point number. - max: () -> % - ++ max() returns the maximum floating point number. - add - float(ma, ex) == float(ma, ex, base()) - digits() == max(1,4004 * (bits()-1) quo 13301)::PositiveInteger - -@ -\section{FPS.lsp BOOTSTRAP} -{\bf FPS} 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 FPS} category which we can write -into the {\bf MID} directory. We compile the lisp code and copy the -{\bf FPS.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 |FloatingPointSystem;AL| (QUOTE NIL)) - -(DEFUN |FloatingPointSystem| NIL - (LET (#:G105645) - (COND - (|FloatingPointSystem;AL|) - (T (SETQ |FloatingPointSystem;AL| (|FloatingPointSystem;|)))))) - -(DEFUN |FloatingPointSystem;| NIL - (PROG (#1=#:G105643) - (RETURN - (PROG1 - (LETT #1# - (|Join| - (|RealNumberSystem|) - (|mkCategory| - (QUOTE |domain|) - (QUOTE ( - ((|float| (|$| (|Integer|) (|Integer|))) T) - ((|float| (|$| (|Integer|) (|Integer|) (|PositiveInteger|))) T) - ((|order| ((|Integer|) |$|)) T) - ((|base| ((|PositiveInteger|))) T) - ((|exponent| ((|Integer|) |$|)) T) - ((|mantissa| ((|Integer|) |$|)) T) - ((|bits| ((|PositiveInteger|))) T) - ((|digits| ((|PositiveInteger|))) T) - ((|precision| ((|PositiveInteger|))) T) - ((|bits| ((|PositiveInteger|) (|PositiveInteger|))) - (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) - ((|digits| ((|PositiveInteger|) (|PositiveInteger|))) - (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) - ((|precision| ((|PositiveInteger|) (|PositiveInteger|))) - (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) - ((|increasePrecision| ((|PositiveInteger|) (|Integer|))) - (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) - ((|decreasePrecision| ((|PositiveInteger|) (|Integer|))) - (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) - ((|min| (|$|)) - (AND - (|not| (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) - (|not| (|has| |$| (ATTRIBUTE |arbitraryExponent|))))) - ((|max| (|$|)) - (AND - (|not| (|has| |$| (ATTRIBUTE |arbitraryPrecision|))) - (|not| (|has| |$| (ATTRIBUTE |arbitraryExponent|))))))) - (QUOTE ((|approximate| T))) - (QUOTE ((|PositiveInteger|) (|Integer|))) - NIL)) - |FloatingPointSystem|) - (SETELT #1# 0 (QUOTE (|FloatingPointSystem|))))))) - -(MAKEPROP (QUOTE |FloatingPointSystem|) (QUOTE NILADIC) T) - -@ -\section{FPS-.lsp BOOTSTRAP} -{\bf FPS-} depends {\bf FPS}. -We need to break this cycle to build the algebra. So we keep a -cached copy of the translated {\bf FPS-} category which we can write -into the {\bf MID} directory. We compile the lisp code and copy the -{\bf FPS-.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 |FPS-;float;2IS;1| (|ma| |ex| |$|) - (SPADCALL |ma| |ex| (SPADCALL (QREFELT |$| 8)) (QREFELT |$| 10))) - -(DEFUN |FPS-;digits;Pi;2| (|$|) - (PROG (#1=#:G105654) - (RETURN - (PROG1 - (LETT #1# - (MAX 1 - (QUOTIENT2 - (SPADCALL 4004 - (|-| (SPADCALL (QREFELT |$| 13)) 1) - (QREFELT |$| 14)) - 13301)) - |FPS-;digits;Pi;2|) - (|check-subtype| (|>| #1# 0) (QUOTE (|PositiveInteger|)) #1#))))) - -(DEFUN |FloatingPointSystem&| (|#1|) - (PROG (|DV$1| |dv$| |$| |pv$|) - (RETURN - (PROGN - (LETT |DV$1| (|devaluate| |#1|) . #1=(|FloatingPointSystem&|)) - (LETT |dv$| (LIST (QUOTE |FloatingPointSystem&|) |DV$1|) . #1#) - (LETT |$| (GETREFV 17) . #1#) - (QSETREFV |$| 0 |dv$|) - (QSETREFV |$| 3 - (LETT |pv$| - (|buildPredVector| 0 0 - (LIST - (|HasAttribute| |#1| (QUOTE |arbitraryExponent|)) - (|HasAttribute| |#1| (QUOTE |arbitraryPrecision|)))) . #1#)) - (|stuffDomainSlots| |$|) - (QSETREFV |$| 6 |#1|) - |$|)))) - -(MAKEPROP - (QUOTE |FloatingPointSystem&|) - (QUOTE |infovec|) - (LIST - (QUOTE - #(NIL NIL NIL NIL NIL NIL - (|local| |#1|) - (|PositiveInteger|) - (0 . |base|) - (|Integer|) - (4 . |float|) - |FPS-;float;2IS;1| - (11 . |One|) - (15 . |bits|) - (19 . |*|) - (25 . |max|) - |FPS-;digits;Pi;2|)) - (QUOTE #(|float| 29 |digits| 35)) - (QUOTE NIL) - (CONS - (|makeByteWordVec2| 1 (QUOTE NIL)) - (CONS - (QUOTE #()) - (CONS - (QUOTE #()) - (|makeByteWordVec2| 16 - (QUOTE - (0 6 7 8 3 6 0 9 9 7 10 0 6 0 12 0 6 7 13 2 9 0 7 0 14 0 6 0 15 - 2 0 0 9 9 11 0 0 7 16)))))) - (QUOTE |lookupComplete|))) - -@ \section{domain DFLOAT DoubleFloat} Greg Vanuxem has added some functionality to allow the user to modify the printed format of floating point numbers. The format of the numbers @@ -1644,10 +980,6 @@ Note that this code is not included in the generated catdef.spad file. <<*>>= <> -<> -<> -<> -<> <> @ \eject diff --git a/src/algebra/xlpoly.spad.pamphlet b/src/algebra/xlpoly.spad.pamphlet index 44358c0..43702dd 100644 --- a/src/algebra/xlpoly.spad.pamphlet +++ b/src/algebra/xlpoly.spad.pamphlet @@ -951,102 +951,6 @@ LyndonWord(VarSet:OrderedSet):Public == Private where "append"/ [v.i for i in 1..n] @ -\section{category LIECAT LieAlgebra} -<>= -)abbrev category LIECAT LieAlgebra -++ Author: Michel Petitot (petitot@lifl.fr). -++ Date Created: 91 -++ Date Last Updated: 7 Juillet 92 -++ Fix History: compilation v 2.1 le 13 dec 98 -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ References: -++ Description: -++ The category of Lie Algebras. -++ It is used by the following domains of non-commutative algebra: -++ \axiomType{LiePolynomial} and -++ \axiomType{XPBWPolynomial}. \newline Author : Michel Petitot (petitot@lifl.fr). -LieAlgebra(R: CommutativeRing): Category == Module(R) with - --attributes - NullSquare - ++ \axiom{NullSquare} means that \axiom{[x,x] = 0} holds. - JacobiIdentity - ++ \axiom{JacobiIdentity} means that \axiom{[x,[y,z]]+[y,[z,x]]+[z,[x,y]] = 0} holds. - --exports - construct: ($,$) -> $ - ++ \axiom{construct(x,y)} returns the Lie bracket of \axiom{x} and \axiom{y}. - if R has Field then - "/" : ($,R) -> $ - ++ \axiom{x/r} returns the division of \axiom{x} by \axiom{r}. - - - add - if R has Field then x / r == inv(r)$R * x - -@ -\section{category FLALG FreeLieAlgebra} -<>= -)abbrev category FLALG FreeLieAlgebra -++ Author: Michel Petitot (petitot@lifl.fr) -++ Date Created: 91 -++ Date Last Updated: 7 Juillet 92 -++ Fix History: compilation v 2.1 le 13 dec 98 -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ References: -++ Description: -++ The category of free Lie algebras. -++ It is used by domains of non-commutative algebra: -++ \spadtype{LiePolynomial} and -++ \spadtype{XPBWPolynomial}. \newline Author: Michel Petitot (petitot@lifl.fr) - -FreeLieAlgebra(VarSet:OrderedSet, R:CommutativeRing) :Category == CatDef where - XRPOLY ==> XRecursivePolynomial(VarSet,R) - XDPOLY ==> XDistributedPolynomial(VarSet,R) - RN ==> Fraction Integer - LWORD ==> LyndonWord(VarSet) - - CatDef == Join(LieAlgebra(R)) with - coef : (XRPOLY , $) -> R - ++ \axiom{coef(x,y)} returns the scalar product of \axiom{x} by \axiom{y}, - ++ the set of words being regarded as an orthogonal basis. - coerce : VarSet -> $ - ++ \axiom{coerce(x)} returns \axiom{x} as a Lie polynomial. - coerce : $ -> XDPOLY - ++ \axiom{coerce(x)} returns \axiom{x} as distributed polynomial. - coerce : $ -> XRPOLY - ++ \axiom{coerce(x)} returns \axiom{x} as a recursive polynomial. - degree : $ -> NonNegativeInteger - ++ \axiom{degree(x)} returns the greatest length of a word in the support of \axiom{x}. - --if R has Module(RN) then - -- Hausdorff : ($,$,PositiveInteger) -> $ - lquo : (XRPOLY , $) -> XRPOLY - ++ \axiom{lquo(x,y)} returns the left simplification of \axiom{x} by \axiom{y}. - rquo : (XRPOLY , $) -> XRPOLY - ++ \axiom{rquo(x,y)} returns the right simplification of \axiom{x} by \axiom{y}. - LiePoly : LWORD -> $ - ++ \axiom{LiePoly(l)} returns the bracketed form of \axiom{l} as a Lie polynomial. - mirror : $ -> $ - ++ \axiom{mirror(x)} returns \axiom{Sum(r_i mirror(w_i))} - ++ if \axiom{x} is \axiom{Sum(r_i w_i)}. - trunc : ($, NonNegativeInteger) -> $ - ++ \axiom{trunc(p,n)} returns the polynomial \axiom{p} - ++ truncated at order \axiom{n}. - varList : $ -> List VarSet - ++ \axiom{varList(x)} returns the list of distinct entries of \axiom{x}. - eval : ($, VarSet, $) -> $ - ++ \axiom{eval(p, x, v)} replaces \axiom{x} by \axiom{v} in \axiom{p}. - eval : ($, List VarSet, List $) -> $ - ++ \axiom{eval(p, [x1,...,xn], [v1,...,vn])} replaces \axiom{xi} by \axiom{vi} - ++ in \axiom{p}. - -@ \section{package XEXPPKG XExponentialPackage} <>= )abbrev package XEXPPKG XExponentialPackage @@ -3290,8 +3194,6 @@ LieExponentials(VarSet, R, Order): XDPcat == XDPdef where <> <> -<> -<> <> <> <> diff --git a/src/algebra/xpoly.spad.pamphlet b/src/algebra/xpoly.spad.pamphlet index 218c93f..3fb7b2b 100644 --- a/src/algebra/xpoly.spad.pamphlet +++ b/src/algebra/xpoly.spad.pamphlet @@ -162,79 +162,6 @@ OrderedFreeMonoid(S: OrderedSet): OFMcategory == OFMdefinition where mirror x == reverse(x)$Rep @ -\section{category FMCAT FreeModuleCat} -<>= -)abbrev category FMCAT FreeModuleCat -++ Author: Michel Petitot petitot@lifl.fr -++ Date Created: 91 -++ Date Last Updated: 7 Juillet 92 -++ Fix History: compilation v 2.1 le 13 dec 98 -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ References: -++ Description: -++ A domain of this category -++ implements formal linear combinations -++ of elements from a domain \spad{Basis} with coefficients -++ in a domain \spad{R}. The domain \spad{Basis} needs only -++ to belong to the category \spadtype{SetCategory} and \spad{R} -++ to the category \spadtype{Ring}. Thus the coefficient ring -++ may be non-commutative. -++ See the \spadtype{XDistributedPolynomial} constructor -++ for examples of domains built with the \spadtype{FreeModuleCat} -++ category constructor. -++ Author: Michel Petitot (petitot@lifl.fr) - -FreeModuleCat(R, Basis):Category == Exports where - R: Ring - Basis: SetCategory - TERM ==> Record(k: Basis, c: R) - - Exports == Join(BiModule(R,R), RetractableTo Basis) with - "*" : (R, Basis) -> % - ++ \spad{r*b} returns the product of \spad{r} by \spad{b}. - coefficient : (%, Basis) -> R - ++ \spad{coefficient(x,b)} returns the coefficient - ++ of \spad{b} in \spad{x}. - map : (R -> R, %) -> % - ++ \spad{map(fn,u)} maps function \spad{fn} onto the coefficients - ++ of the non-zero monomials of \spad{u}. - monom : (Basis, R) -> % - ++ \spad{monom(b,r)} returns the element with the single monomial - ++ \spad{b} and coefficient \spad{r}. - monomial? : % -> Boolean - ++ \spad{monomial?(x)} returns true if \spad{x} contains a single - ++ monomial. - ListOfTerms : % -> List TERM - ++ \spad{ListOfTerms(x)} returns a list \spad{lt} of terms with type - ++ \spad{Record(k: Basis, c: R)} such that \spad{x} equals - ++ \spad{reduce(+, map(x +-> monom(x.k, x.c), lt))}. - coefficients : % -> List R - ++ \spad{coefficients(x)} returns the list of coefficients of \spad{x}. - monomials : % -> List % - ++ \spad{monomials(x)} returns the list of \spad{r_i*b_i} - ++ whose sum is \spad{x}. - numberOfMonomials : % -> NonNegativeInteger - ++ \spad{numberOfMonomials(x)} returns the number of monomials of \spad{x}. - leadingMonomial : % -> Basis - ++ \spad{leadingMonomial(x)} returns the first element from \spad{Basis} - ++ which appears in \spad{ListOfTerms(x)}. - leadingCoefficient : % -> R - ++ \spad{leadingCoefficient(x)} returns the first coefficient - ++ which appears in \spad{ListOfTerms(x)}. - leadingTerm : % -> TERM - ++ \spad{leadingTerm(x)} returns the first term which - ++ appears in \spad{ListOfTerms(x)}. - reductum : % -> % - ++ \spad{reductum(x)} returns \spad{x} minus its leading term. - - -- attributs - if R has CommutativeRing then Module(R) - -@ \section{domain FM1 FreeModule1} <>= )abbrev domain FM1 FreeModule1 @@ -337,154 +264,6 @@ FreeModule1(R:Ring,S:OrderedSet): FMcat == FMdef where 0$R @ -\section{category XALG XAlgebra} -<>= -)abbrev category XALG XAlgebra -++ Author: Michel Petitot petitot@lifl.fr -++ Date Created: 91 -++ Date Last Updated: 7 Juillet 92 -++ Fix History: compilation v 2.1 le 13 dec 98 -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ References: -++ Description: -++ This is the category of algebras over non-commutative rings. -++ It is used by constructors of non-commutative algebras such as: -++ \spadtype{XPolynomialRing}. -++ \spadtype{XFreeAlgebra} -++ Author: Michel Petitot (petitot@lifl.fr) - -XAlgebra(R: Ring): Category == - Join(Ring, BiModule(R,R)) with - --operations - coerce: R -> % - ++ \spad{coerce(r)} equals \spad{r*1}. - -- attributs - if R has CommutativeRing then Algebra(R) - -- if R has CommutativeRing then Module(R) --- add --- coerce(x:R):% == x * 1$% - -@ -\section{category XFALG XFreeAlgebra} -<>= -)abbrev category XFALG XFreeAlgebra -++ Author: Michel Petitot petitot@lifl.fr -++ Date Created: 91 -++ Date Last Updated: 7 Juillet 92 -++ Fix History: compilation v 2.1 le 13 dec 98 -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ References: -++ Description: -++ This category specifies opeations for polynomials -++ and formal series with non-commutative variables. -++ Author: Michel Petitot (petitot@lifl.fr) - -XFreeAlgebra(vl:OrderedSet,R:Ring):Category == Catdef where - WORD ==> OrderedFreeMonoid(vl) -- monoide libre - NNI ==> NonNegativeInteger - I ==> Integer - TERM ==> Record(k: WORD, c: R) - - Catdef == Join(Ring, XAlgebra(R), RetractableTo WORD) - with - "*": (vl,%) -> % - ++ \spad{v * x} returns the product of a variable \spad{x} by \spad{x}. - "*": (%, R) -> % - ++ \spad{x * r} returns the product of \spad{x} by \spad{r}. - ++ Usefull if \spad{R} is a non-commutative Ring. - mindeg: % -> WORD - ++ \spad{mindeg(x)} returns the little word which appears in \spad{x}. - ++ Error if \spad{x=0}. - mindegTerm: % -> TERM - ++ \spad{mindegTerm(x)} returns the term whose word is \spad{mindeg(x)}. - coef : (%,WORD) -> R - ++ \spad{coef(x,w)} returns the coefficient of the word \spad{w} in \spad{x}. - coef : (%,%) -> R - ++ \spad{coef(x,y)} returns scalar product of \spad{x} by \spad{y}, - ++ the set of words being regarded as an orthogonal basis. - lquo : (%,vl) -> % - ++ \spad{lquo(x,v)} returns the left simplification of \spad{x} by the variable \spad{v}. - lquo : (%,WORD) -> % - ++ \spad{lquo(x,w)} returns the left simplification of \spad{x} by the word \spad{w}. - lquo : (%,%) -> % - ++ \spad{lquo(x,y)} returns the left simplification of \spad{x} by \spad{y}. - rquo : (%,vl) -> % - ++ \spad{rquo(x,v)} returns the right simplification of \spad{x} by the variable \spad{v}. - rquo : (%,WORD) -> % - ++ \spad{rquo(x,w)} returns the right simplification of \spad{x} by \spad{w}. - rquo : (%,%) -> % - ++ \spad{rquo(x,y)} returns the right simplification of \spad{x} by \spad{y}. - monom : (WORD , R) -> % - ++ \spad{monom(w,r)} returns the product of the word \spad{w} by the coefficient \spad{r}. - monomial? : % -> Boolean - ++ \spad{monomial?(x)} returns true if \spad{x} is a monomial - mirror: % -> % - ++ \spad{mirror(x)} returns \spad{Sum(r_i mirror(w_i))} if \spad{x} writes \spad{Sum(r_i w_i)}. - coerce : vl -> % - ++ \spad{coerce(v)} returns \spad{v}. - constant?:% -> Boolean - ++ \spad{constant?(x)} returns true if \spad{x} is constant. - constant: % -> R - ++ \spad{constant(x)} returns the constant term of \spad{x}. - quasiRegular? : % -> Boolean - ++ \spad{quasiRegular?(x)} return true if \spad{constant(x)} is zero. - quasiRegular : % -> % - ++ \spad{quasiRegular(x)} return \spad{x} minus its constant term. - if R has CommutativeRing then - sh :(%,%) -> % - ++ \spad{sh(x,y)} returns the shuffle-product of \spad{x} by \spad{y}. - ++ This multiplication is associative and commutative. - sh :(%,NNI) -> % - ++ \spad{sh(x,n)} returns the shuffle power of \spad{x} to the \spad{n}. - map : (R -> R, %) -> % - ++ \spad{map(fn,x)} returns \spad{Sum(fn(r_i) w_i)} if \spad{x} writes \spad{Sum(r_i w_i)}. - varList: % -> List vl - ++ \spad{varList(x)} returns the list of variables which appear in \spad{x}. - - -- Attributs - if R has noZeroDivisors then noZeroDivisors - -@ -\section{category XPOLYC XPolynomialsCat} -<>= -)abbrev category XPOLYC XPolynomialsCat -++ Author: Michel Petitot petitot@lifl.fr -++ Date Created: 91 -++ Date Last Updated: 7 Juillet 92 -++ Fix History: compilation v 2.1 le 13 dec 98 -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ References: -++ Description: -++ The Category of polynomial rings with non-commutative variables. -++ The coefficient ring may be non-commutative too. -++ However coefficients commute with vaiables. -++ Author: Michel Petitot (petitot@lifl.fr) - -XPolynomialsCat(vl:OrderedSet,R:Ring):Category == Export where - WORD ==> OrderedFreeMonoid(vl) - - Export == XFreeAlgebra(vl,R) with - maxdeg: % -> WORD - ++ \spad{maxdeg(p)} returns the greatest leading word in the support of \spad{p}. - degree: % -> NonNegativeInteger - ++ \spad{degree(p)} returns the degree of \spad{p}. - ++ Note that the degree of a word is its length. - trunc : (% , NonNegativeInteger) -> % - ++ \spad{trunc(p,n)} returns the polynomial \spad{p} truncated at order \spad{n}. - -@ \section{domain XPR XPolynomialRing} <>= -- xpoly.spad.pamphlet XPolynomialRing.input @@ -1750,11 +1529,7 @@ XPolynomial(R:Ring) == XRecursivePolynomial(Symbol, R) <> <> -<> <> -<> -<> -<> <> <> <>