diff --git a/books/bookvol10.2.pamphlet b/books/bookvol10.2.pamphlet index f0cea1d..35305df 100644 --- a/books/bookvol10.2.pamphlet +++ b/books/bookvol10.2.pamphlet @@ -302,6 +302,8 @@ This is the root of the category hierarchy and is not represented by code. \pageto{HyperbolicFunctionCategory}{HYPCAT} \pageto{InnerEvalable}{IEVALAB} \pageto{Logic}{LOGIC} +\pageto{OpenMath}{OM} +\pageto{Patternable}{PATAB} \pageto{PrimitiveFunctionCategory}{PRIMCAT} \pageto{RetractableTo}{RETRACT} \pageto{SpecialFunctionCategory}{SPFCAT} @@ -1275,6 +1277,147 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{OpenMath}{OM} +\pagepic{ps/v102openmath.ps}{OM}{1.00} + +{\bf See:}\\ +\pageto{StringCategory}{STRICAT} +\pagefrom{Category}{CATEGORY} + +{\bf Exports:}\\ +\begin{tabular}{l} +\cross{OM}{OMwrite} +\end{tabular} + +These are directly exported but not implemented: +\begin{verbatim} + OMwrite : % -> String + OMwrite : (%,Boolean) -> String + OMwrite : (OpenMathDevice,%) -> Void + OMwrite : (OpenMathDevice,%,Boolean) -> Void +\end{verbatim} + +<>= +)abbrev category OM OpenMath +++ Author: Mike Dewar & Vilya Harvey +++ Basic Functions: OMwrite +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: +++ \spadtype{OpenMath} provides operations for exporting an object +++ in OpenMath format. + +OpenMath(): Category == with + OMwrite : % -> String + ++ OMwrite(u) returns the OpenMath XML encoding of \axiom{u} as a + ++ complete OpenMath object. + OMwrite : (%, Boolean) -> String + ++ OMwrite(u, true) returns the OpenMath XML encoding of \axiom{u} + ++ as a complete OpenMath object; OMwrite(u, false) returns the + ++ OpenMath XML encoding of \axiom{u} as an OpenMath fragment. + OMwrite : (OpenMathDevice, %) -> Void + ++ OMwrite(dev, u) writes the OpenMath form of \axiom{u} to the + ++ OpenMath device \axiom{dev} as a complete OpenMath object. + OMwrite : (OpenMathDevice, %, Boolean) -> Void + ++ OMwrite(dev, u, true) writes the OpenMath form of \axiom{u} to + ++ the OpenMath device \axiom{dev} as a complete OpenMath object; + ++ OMwrite(dev, u, false) writes the object as an OpenMath fragment. + +@ +<>= +"OM" + [color=lightblue,href="bookvol10.2.pdf#nameddest=OM"]; +"OM" -> "CATEGORY" + +@ +<>= +"OpenMath()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=OM"]; +"OpenMath()" -> "Category" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"OpenMath()" [color=lightblue]; +"OpenMath()" -> "Category" + +"Category" [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{Patternable}{PATAB} +\pagepic{ps/v102patternable.ps}{PATAB}{1.00} + +{\bf See:}\\ +\pagefrom{Category}{CATEGORY} + +{\bf Exports:}\\ +\begin{tabular}{l} +\cross{PATAB}{convert} +\end{tabular} + +These exports come from \refto{ConvertibleTo}(Pattern(Integer)): +\begin{verbatim} + convert : % -> Pattern Integer if R has KONVERT PATTERN INT +\end{verbatim} + +These exports come from \refto{ConvertibleTo}(Pattern(Float)): +\begin{verbatim} + convert : % -> Pattern Float if R has KONVERT PATTERN FLOAT +\end{verbatim} + +<>= +)abbrev category PATAB Patternable +++ Category of sets that can be converted to useful patterns +++ Author: Manuel Bronstein +++ Date Created: 29 Nov 1989 +++ Date Last Updated: 29 Nov 1989 +++ Description: +++ An object S is Patternable over an object R if S can +++ lift the conversions from R into \spadtype{Pattern(Integer)} and +++ \spadtype{Pattern(Float)} to itself; +++ Keywords: pattern, matching. +Patternable(R:Type): Category == with + if R has ConvertibleTo Pattern Integer then + ConvertibleTo Pattern Integer + if R has ConvertibleTo Pattern Float then + ConvertibleTo Pattern Float + +@ +<>= +"PATAB" + [color=lightblue,href="bookvol10.2.pdf#nameddest=PATAB"]; +"PATAB" -> "CATEGORY" + +@ +<>= +"Patternable(a:Type)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=PATAB"]; +"Patternable(a:Type)" -> "Category" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"Patternable(a:Type)" [color=lightblue]; +"Patternable(a:Type)" -> "Category" + +"Category" [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{PrimitiveFunctionCategory}{PRIMCAT} \pagepic{ps/v102primitivefunctioncategory.ps}{PRIMCAT}{1.00} @@ -1632,10 +1775,6 @@ digraph pic { "Category" [color=lightblue]; } - - - - @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{Type}{TYPE} @@ -1643,6 +1782,7 @@ digraph pic { {\bf See:}\\ \pageto{Aggregate}{AGG} +\pageto{FullyPatternMatchable}{FPATMAB} \pagefrom{Category}{CATEGORY} <>= )abbrev category TYPE Type @@ -2013,6 +2153,7 @@ digraph pic { \pagepic{ps/v102fullyretractableto.ps}{FRETRCT}{1.00} {\bf See:}\\ +\pageto{FiniteAbelianMonoidRing}{FAMR} \pageto{MonogenicAlgebra}{MONOGEN} \pagefrom{RetractableTo}{RETRACT} @@ -2092,12 +2233,15 @@ FullyRetractableTo(S: Type): Category == RetractableTo(S) with [color=lightblue,href="bookvol10.2.pdf#nameddest=FRETRCT"]; "FullyRetractableTo(a:Type)" -> "RetractableTo(a:Type)" +"FullyRetractableTo(a:Ring)" [color=seagreen,href="bookvol10.2.pdf#nameddest=FRETRCT"]; "FullyRetractableTo(a:Ring)" -> "FullyRetractableTo(a:Type)" +"FullyRetractableTo(a:CommutativeRing)" [color=seagreen,href="bookvol10.2.pdf#nameddest=FRETRCT"]; "FullyRetractableTo(a:CommutativeRing)" -> "FullyRetractableTo(a:Type)" +"FullyRetractableTo(a:SetCategory)" [color=seagreen,href="bookvol10.2.pdf#nameddest=FRETRCT"]; "FullyRetractableTo(a:SetCategory)" -> "FullyRetractableTo(a:Type)" @@ -2119,6 +2263,106 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{FullyPatternMatchable}{FPATMAB} +\pagepic{ps/v102fullypatternmatchable.ps}{FPATMAB}{1.00} + +{\bf See:}\\ +\pagefrom{Type}{TYPE} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{FPATMAB}{coerce} & +\cross{FPATMAB}{hash} & +\cross{FPATMAB}{latex} & +\cross{FPATMAB}{patternMatch} & +\cross{FPATMAB}{?=?} \\ +\cross{FPATMAB}{?\~{}=?} &&&& +\end{tabular} + + coerce : % -> OutputForm if R has PATMAB INT or R has PATMAB FLOAT + hash : % -> SingleInteger if R has PATMAB INT or R has PATMAB FLOAT + latex : % -> String if R has PATMAB INT or R has PATMAB FLOAT + ?=? : (%,%) -> Boolean if R has PATMAB INT or R has PATMAB FLOAT + ?~=? : (%,%) -> Boolean if R has PATMAB INT or R has PATMAB FLOAT + +These exports come from \refto{PatternMatchable}(Integer): +\begin{verbatim} + coerce : % -> OutputForm + if R has PATMAB INT + or R has PATMAB FLOAT + hash : % -> SingleInteger + if R has PATMAB INT + or R has PATMAB FLOAT + latex : % -> String + if R has PATMAB INT + or R has PATMAB FLOAT + patternMatch : + (%,Pattern Integer,PatternMatchResult(Integer,%)) + -> PatternMatchResult(Integer,%) if R has PATMAB INT + ?=? : (%,%) -> Boolean + if R has PATMAB INT + or R has PATMAB FLOAT + ?~=? : (%,%) -> Boolean + if R has PATMAB INT + or R has PATMAB FLOAT +\end{verbatim} + +These exports come from \refto{PatternMatchable}(Float): +\begin{verbatim} + patternMatch : + (%,Pattern Float,PatternMatchResult(Float,%)) + -> PatternMatchResult(Float,%) if R has PATMAB FLOAT +\end{verbatim} + +These exports come from \refto{Type}(): +\begin{verbatim} +\end{verbatim} + +<>= +)abbrev category FPATMAB FullyPatternMatchable +++ Category of sets that can be pattern-matched on +++ Author: Manuel Bronstein +++ Date Created: 28 Nov 1989 +++ Date Last Updated: 29 Nov 1989 +++ Description: +++ A set S is PatternMatchable over R if S can lift the +++ pattern-matching functions of S over the integers and float +++ to itself (necessary for matching in towers). +++ Keywords: pattern, matching. +FullyPatternMatchable(R:Type): Category == Type with + if R has PatternMatchable Integer then PatternMatchable Integer + if R has PatternMatchable Float then PatternMatchable Float + +@ +<>= +"FPATMAB" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FPATMAB"]; +"FPATMAB" -> "TYPE" + +@ +<>= +"FullyPatternMatchable(a:Type)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FPATMAB"]; +"FullyPatternMatchable(a:Type)" -> "Type()" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"FullyPatternMatchable(a:Type)" [color=lightblue]; +"FullyPatternMatchable(a:Type)" -> "Type()" + +"Type()" [color=lightblue]; +"Type()" -> "Category" + +"Category" [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{Logic}{LOGIC} \pagepic{ps/v102logic.ps}{LOGIC}{1.00} @@ -2208,13 +2452,17 @@ digraph pic { {\bf See:}\\ \pageto{AbelianSemiGroup}{ABELSG} +\pageto{FileCategory}{FILECAT} +\pageto{FileNameCategory}{FNCAT} \pageto{Finite}{FINITE} \pageto{GradedModule}{GRMOD} \pageto{HomogeneousAggregate}{HOAGG} \pageto{OrderedSet}{ORDSET} +\pageto{PatternMatchable}{PATMAB} \pageto{SemiGroup}{SGROUP} \pageto{SetAggregate}{SETAGG} \pageto{StepThrough}{STEP} +\pageto{StringCategory}{STRICAT} \pagefrom{BasicType}{BASTYPE} \pagefrom{CoercibleTo}{KOERCE} @@ -2623,6 +2871,147 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{FileCategory}{FILECAT} +\pagepic{ps/v102filecategory.ps}{FILECAT}{1.00} + +{\bf See:}\\ +\pagefrom{SetCategory}{SETCAT} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{FILECAT}{close!} & +\cross{FILECAT}{coerce} & +\cross{FILECAT}{hash} & +\cross{FILECAT}{iomode} & +\cross{FILECAT}{latex} \\ +\cross{FILECAT}{name} & +\cross{FILECAT}{open} & +\cross{FILECAT}{open} & +\cross{FILECAT}{read!} & +\cross{FILECAT}{reopen!} \\ +\cross{FILECAT}{write!} & +\cross{FILECAT}{?=?} & +\cross{FILECAT}{?\~{}=?} && +\end{tabular} + +These are directly exported but not implemented: +\begin{verbatim} + close! : % -> % + iomode : % -> String + name : % -> Name + open : Name -> % + open : (Name,String) -> % + read! : % -> S + reopen! : (%,String) -> % + write! : (%,S) -> S +\end{verbatim} + +These exports come from SetCategory(): +\begin{verbatim} + coerce : % -> OutputForm + hash : % -> SingleInteger + latex : % -> String + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean +\end{verbatim} + +<>= +)abbrev category FILECAT FileCategory +++ Author: Stephen M. Watt, Victor Miller +++ Date Created: +++ Date Last Updated: June 4, 1991 +++ Basic Operations: +++ Related Domains: File +++ Also See: +++ AMS Classifications: +++ Keywords: +++ Examples: +++ References: +++ Description: +++ This category provides an interface to operate on files in the +++ computer's file system. The precise method of naming files +++ is determined by the Name parameter. The type of the contents +++ of the file is determined by S. + +FileCategory(Name, S): Category == FCdefinition where + Name: SetCategory + S: SetCategory + IOMode ==> String -- Union("input", "output", "closed") + + FCdefinition == SetCategory with + open: Name -> % + ++ open(s) returns the file s open for input. + + open: (Name, IOMode) -> % + ++ open(s,mode) returns a file s open for operation in the + ++ indicated mode: "input" or "output". + + reopen_!: (%, IOMode) -> % + ++ reopen!(f,mode) returns a file f reopened for operation in the + ++ indicated mode: "input" or "output". + ++ \spad{reopen!(f,"input")} will reopen the file f for input. + + close_!: % -> % + ++ close!(f) returns the file f closed to input and output. + + name: % -> Name + ++ name(f) returns the external name of the file f. + + iomode: % -> IOMode + ++ iomode(f) returns the status of the file f. The input/output + ++ status of f may be "input", "output" or "closed" mode. + + read_!: % -> S + ++ read!(f) extracts a value from file f. The state of f is + ++ modified so a subsequent call to \spadfun{read!} will return + ++ the next element. + + write_!: (%,S) -> S + ++ write!(f,s) puts the value s into the file f. + ++ The state of f is modified so subsequents call to \spad{write!} + ++ will append one after another. + +@ +<>= +"FILECAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FILECAT"]; +"FILECAT" -> "SETCAT" + +@ +<>= +"FileCategory(a:SetCategory,b:SetCategory)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FILECAT"]; +"FileCategory(a:SetCategory,b:SetCategory)" -> "SetCategory()" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"FileCategory(a:SetCategory,b:SetCategory)" [color=lightblue]; +"FileCategory(a:SetCategory,b:SetCategory)" -> "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{Finite}{FINITE} \pagepic{ps/v102finite.ps}{FINITE}{1.00} @@ -2738,6 +3127,143 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{FileNameCategory}{FNCAT} +\pagepic{ps/v102filenamecategory.ps}{FNCAT}{0.70} + +{\bf See:}\\ +\pagefrom{SetCategory}{SETCAT} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{FNCAT}{coerce} & +\cross{FNCAT}{coerce} & +\cross{FNCAT}{directory} & +\cross{FNCAT}{exists?} & +\cross{FNCAT}{extension} \\ +\cross{FNCAT}{filename} & +\cross{FNCAT}{hash} & +\cross{FNCAT}{latex} & +\cross{FNCAT}{name} & +\cross{FNCAT}{new} \\ +\cross{FNCAT}{readable?} & +\cross{FNCAT}{writable?} & +\cross{FNCAT}{?=?} & +\cross{FNCAT}{?\~{}=?} & +\end{tabular} + +These are directly exported but not implemented: +\begin{verbatim} + coerce : String -> % + coerce : % -> String + directory : % -> String + exists? : % -> Boolean + extension : % -> String + filename : (String,String,String) -> % + name : % -> String + new : (String,String,String) -> % + readable? : % -> Boolean + writable? : % -> Boolean +\end{verbatim} + +These exports come from \refto{SetCategory}(): +\begin{verbatim} + coerce : % -> OutputForm + hash : % -> SingleInteger + latex : % -> String + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean +\end{verbatim} + +<>= +)abbrev category FNCAT FileNameCategory +++ Author: Stephen M. Watt +++ Date Created: 1985 +++ Date Last Updated: June 20, 1991 +++ Basic Operations: +++ Related Domains: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ Examples: +++ References: +++ Description: +++ This category provides an interface to names in the file system. +FileNameCategory(): Category == SetCategory with + coerce: String -> % + ++ coerce(s) converts a string to a file name + ++ according to operating system-dependent conventions. + coerce: % -> String + ++ coerce(fn) produces a string for a file name + ++ according to operating system-dependent conventions. + filename: (String, String, String) -> % + ++ filename(d,n,e) creates a file name with + ++ d as its directory, n as its name and e as its extension. + ++ This is a portable way to create file names. + ++ When d or t is the empty string, a default is used. + directory: % -> String + ++ directory(f) returns the directory part of the file name. + name: % -> String + ++ name(f) returns the name part of the file name. + extension: % -> String + ++ extension(f) returns the type part of the file name. + exists?: % -> Boolean + ++ exists?(f) tests if the file exists in the file system. + readable?: % -> Boolean + ++ readable?(f) tests if the named file exist and can it be opened + ++ for reading. + writable?: % -> Boolean + ++ writable?(f) tests if the named file be opened for writing. + ++ The named file need not already exist. + new: (String, String, String) -> % + ++ new(d,pref,e) constructs the name of a new writable file with + ++ d as its directory, pref as a prefix of its name and + ++ e as its extension. + ++ When d or t is the empty string, a default is used. + ++ An error occurs if a new file cannot be written in the given + ++ directory. + +@ +<>= +"FNCAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FNCAT"]; +"FNCAT" -> "SETCAT" + +@ +<>= +"FileNameCategory()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FNCAT"]; +"FileNameCategory()" -> "SetCategory()" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"FileNameCategory()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FNCAT"]; +"FileNameCategory()" -> "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{GradedModule}{GRMOD} \pagepic{ps/v102gradedmodule.ps}{GRMOD}{1.00} @@ -3557,6 +4083,105 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{PatternMatchable}{PATMAB} +\pagepic{ps/v102patternmatchable.ps}{PATMAB}{1.00} + +{\bf See:}\\ +\pagefrom{SetCategory}{SETCAT} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{PATMAB}{coerce} & +\cross{PATMAB}{hash} & +\cross{PATMAB}{latex} & +\cross{PATMAB}{patternMatch} & +\cross{PATMAB}{?=?} \\ +\cross{PATMAB}{?\~{}=?} &&&& +\end{tabular} + +These are directly exported but not implemented: +\begin{verbatim} + patternMatch : + (%,Pattern S,PatternMatchResult(S,%)) + -> PatternMatchResult(S,%) +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{SetCategory}(): +\begin{verbatim} + coerce : % -> OutputForm + hash : % -> SingleInteger + latex : % -> String + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean +\end{verbatim} + +<>= +)abbrev category PATMAB PatternMatchable +++ Category of sets that can be pattern-matched on +++ Author: Manuel Bronstein +++ Date Created: 28 Nov 1989 +++ Date Last Updated: 15 Mar 1990 +++ Description: +++ A set R is PatternMatchable over S if elements of R can +++ be matched to patterns over S. +++ Keywords: pattern, matching. +PatternMatchable(S:SetCategory): Category == SetCategory with + patternMatch: (%, Pattern S, PatternMatchResult(S, %)) -> + PatternMatchResult(S, %) + ++ patternMatch(expr, pat, res) matches the pattern pat to the + ++ expression expr. res contains the variables of pat which + ++ are already matched and their matches (necessary for recursion). + ++ Initially, res is just the result of \spadfun{new} + ++ which is an empty list of matches. + +@ +<>= +"PATMAB" + [color=lightblue,href="bookvol10.2.pdf#nameddest=PATMAB"]; +"PATMAB" -> "SETCAT" + +@ +<>= +"PatternMatchable(a:SetCategory)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=PATMAB"]; +"PatternMatchable(a:SetCategory)" -> "SetCategory()" +"PatternMatchable(Integer)" -> "PatternMatchable(a:SetCategory)" +"PatternMatchable(Float)" -> "PatternMatchable(a:SetCategory)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"PatternMatchable(a:SetCategory)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=PATMAB"]; +"PatternMatchable(a:SetCategory)" -> "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{SemiGroup}{SGROUP} \pagepic{ps/v102semigroup.ps}{SGROUP}{0.75} @@ -3582,7 +4207,7 @@ operator ``*''. A Semigroup $G(S,*)$ is: \cross{SGROUP}{?**?} \\ \cross{SGROUP}{?=?} & \cross{SGROUP}{?\^{}?} & -\cross{SGROUP}{?~=?} && +\cross{SGROUP}{?\~{}=?} && \end{tabular} These are directly exported but not implemented: @@ -3701,7 +4326,7 @@ digraph pic { \cross{STEP}{init} & \cross{STEP}{latex} & \cross{STEP}{?=?} \\ -\cross{STEP}{?~=?} & +\cross{STEP}{?\~{}=?} & \cross{STEP}{nextItem} &&& \end{tabular} @@ -10822,7 +11447,7 @@ digraph pic { \cross{NARNG}{?-?} & \cross{NARNG}{-?} & \cross{NARNG}{?=?} & -\cross{NARNG}{?~=?} & +\cross{NARNG}{?\~{}=?} & \end{tabular} These are implemented by this category: @@ -12001,7 +12626,7 @@ digraph pic { \cross{LMODULE}{sample} \\ \cross{LMODULE}{subtractIfCan} & \cross{LMODULE}{zero?} & -\cross{LMODULE}{?~=?} & +\cross{LMODULE}{?\~{}=?} & \cross{LMODULE}{?*?} & \cross{LMODULE}{?+?} \\ \cross{LMODULE}{?-?} & @@ -13236,6 +13861,7 @@ digraph pic { \pagepic{ps/v102stringaggregate.ps}{SRAGG}{1.00} {\bf See:}\\ +\pageto{StringCategory}{STRICAT} \pagefrom{OneDimensionalArrayAggregate}{A1AGG} {\bf Exports:}\\ @@ -13358,12 +13984,12 @@ These exports come from \refto{OneDimensionalArrayAggregate}(Character): concat : (%,%) -> % concat : (Character,%) -> % concat : (%,Character) -> % - copy : % -> % - copyInto! : (%,%,Integer) -> % - if $ has shallowlyMutable construct : List Character -> % convert : % -> InputForm if Character has KONVERT INFORM + copy : % -> % + copyInto! : (%,%,Integer) -> % + if $ has shallowlyMutable count : (Character,%) -> NonNegativeInteger if Character has SETCAT and $ has finiteAggregate @@ -13630,6 +14256,7 @@ digraph pic { "CLAGG..." [color=lightblue]; "IXAGG..." [color=lightblue]; } + @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{TableAggregate}{TBAGG} @@ -14576,6 +15203,7 @@ digraph pic { \pagepic{ps/v102bimodule.ps}{BMODULE}{1.00} {\bf See:}\\ +\pageto{AbelianMonoidRing}{AMR} \pageto{CommutativeRing}{COMRING} \pageto{EntireRing}{ENTIRER} \pageto{Module}{MODULE} @@ -14591,7 +15219,7 @@ digraph pic { \cross{BMODULE}{sample} \\ \cross{BMODULE}{subtractIfCan} & \cross{BMODULE}{zero?} & -\cross{BMODULE}{?~=?} & +\cross{BMODULE}{?\~{}=?} & \cross{BMODULE}{?*?} & \cross{BMODULE}{?+?} \\ \cross{BMODULE}{?-?} & @@ -15084,7 +15712,7 @@ digraph pic { \cross{NASRING}{subtractIfCan} & \cross{NASRING}{zero?} & \cross{NASRING}{?*?} & -\cross{NASRING}{?~=?} \\ +\cross{NASRING}{?\~{}=?} \\ \cross{NASRING}{?**?} & \cross{NASRING}{?+?} & \cross{NASRING}{?-?} & @@ -15717,6 +16345,7 @@ digraph pic { {\bf See:}\\ \pageto{Algebra}{ALGEBRA} +\pageto{AbelianMonoidRing}{AMR} \pageto{CharacteristicNonZero}{CHARNZ} \pageto{CharacteristicZero}{CHARZ} \pageto{CommutativeRing}{COMRING} @@ -15895,8 +16524,612 @@ digraph pic { } @ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{StringCategory}{STRICAT} +\pagepic{ps/v102stringcategory.ps}{STRICAT}{1.00} + +{\bf See:}\\ +\pagefrom{OpenMath}{OM} +\pagefrom{SetCategory}{SETCAT} +\pagefrom{StringAggregate}{SRAGG} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{STRICAT}{any?} & +\cross{STRICAT}{coerce} & +\cross{STRICAT}{concat} & +\cross{STRICAT}{construct} & +\cross{STRICAT}{convert} \\ +\cross{STRICAT}{copy} & +\cross{STRICAT}{copyInto!} & +\cross{STRICAT}{count} & +\cross{STRICAT}{delete} & +\cross{STRICAT}{elt} \\ +\cross{STRICAT}{empty} & +\cross{STRICAT}{empty?} & +\cross{STRICAT}{entry?} & +\cross{STRICAT}{entries} & +\cross{STRICAT}{eq?} \\ +\cross{STRICAT}{eval} & +\cross{STRICAT}{every?} & +\cross{STRICAT}{fill!} & +\cross{STRICAT}{find} & +\cross{STRICAT}{first} \\ +\cross{STRICAT}{hash} & +\cross{STRICAT}{index?} & +\cross{STRICAT}{indices} & +\cross{STRICAT}{insert} & +\cross{STRICAT}{latex} \\ +\cross{STRICAT}{leftTrim} & +\cross{STRICAT}{less?} & +\cross{STRICAT}{lowerCase} & +\cross{STRICAT}{lowerCase!} & +\cross{STRICAT}{map} \\ +\cross{STRICAT}{map!} & +\cross{STRICAT}{match} & +\cross{STRICAT}{match?} & +\cross{STRICAT}{max} & +\cross{STRICAT}{maxIndex} \\ +\cross{STRICAT}{member?} & +\cross{STRICAT}{members} & +\cross{STRICAT}{merge} & +\cross{STRICAT}{min} & +\cross{STRICAT}{minIndex} \\ +\cross{STRICAT}{more?} & +\cross{STRICAT}{new} & +\cross{STRICAT}{OMwrite} & +\cross{STRICAT}{parts} & +\cross{STRICAT}{position} \\ +\cross{STRICAT}{prefix?} & +\cross{STRICAT}{qelt} & +\cross{STRICAT}{qsetelt!} & +\cross{STRICAT}{reduce} & +\cross{STRICAT}{remove} \\ +\cross{STRICAT}{removeDuplicates} & +\cross{STRICAT}{replace} & +\cross{STRICAT}{reverse} & +\cross{STRICAT}{reverse!} & +\cross{STRICAT}{rightTrim} \\ +\cross{STRICAT}{sample} & +\cross{STRICAT}{select} & +\cross{STRICAT}{setelt} & +\cross{STRICAT}{size?} & +\cross{STRICAT}{sort} \\ +\cross{STRICAT}{sort!} & +\cross{STRICAT}{sorted?} & +\cross{STRICAT}{sorted?} & +\cross{STRICAT}{split} & +\cross{STRICAT}{string} \\ +\cross{STRICAT}{substring?} & +\cross{STRICAT}{suffix?} & +\cross{STRICAT}{swap!} & +\cross{STRICAT}{trim} & +\cross{STRICAT}{upperCase} \\ +\cross{STRICAT}{upperCase!} & +\cross{STRICAT}{\#?} & +\cross{STRICAT}{?$<$?} & +\cross{STRICAT}{?$<=$?} & +\cross{STRICAT}{?$>$?} \\ +\cross{STRICAT}{?$>=$?} & +\cross{STRICAT}{?=?} & +\cross{STRICAT}{?.?} & +\cross{STRICAT}{?\~{}=?} & +\end{tabular} + + +These are directly exported but not implemented: +\begin{verbatim} + string : Integer -> % +\end{verbatim} + +These exports come from \refto{StringAggregate}(): +\begin{verbatim} + any? : ((Character -> Boolean),%) -> Boolean + if $ has finiteAggregate + coerce : % -> OutputForm + coerce : Character -> % + concat : List % -> % + concat : (%,%) -> % + concat : (Character,%) -> % + concat : (%,Character) -> % + construct : List Character -> % + convert : % -> InputForm + if Character has KONVERT INFORM + copy : % -> % + copyInto! : (%,%,Integer) -> % + if $ has shallowlyMutable + count : (Character,%) -> NonNegativeInteger + if Character has SETCAT + and $ has finiteAggregate + count : ((Character -> Boolean),%) -> NonNegativeInteger + if $ has finiteAggregate + delete : (%,UniversalSegment Integer) -> % + delete : (%,Integer) -> % + elt : (%,Integer,Character) -> Character + empty : () -> % + empty? : % -> Boolean + entry? : (Character,%) -> Boolean + if $ has finiteAggregate + and Character has SETCAT + entries : % -> List Character + eq? : (%,%) -> Boolean + eval : (%,List Character,List Character) -> % + if Character has EVALAB CHAR + and Character has SETCAT + eval : (%,Character,Character) -> % + if Character has EVALAB CHAR + and Character has SETCAT + eval : (%,Equation Character) -> % + if Character has EVALAB CHAR + and Character has SETCAT + eval : (%,List Equation Character) -> % + if Character has EVALAB CHAR + and Character has SETCAT + every? : ((Character -> Boolean),%) -> Boolean + if $ has finiteAggregate + fill! : (%,Character) -> % + if $ has shallowlyMutable + find : ((Character -> Boolean),%) -> Union(Character,"failed") + first : % -> Character + if Integer has ORDSET + hash : % -> SingleInteger + index? : (Integer,%) -> Boolean + indices : % -> List Integer + insert : (%,%,Integer) -> % + insert : (Character,%,Integer) -> % + latex : % -> String + leftTrim : (%,Character) -> % + leftTrim : (%,CharacterClass) -> % + less? : (%,NonNegativeInteger) -> Boolean + lowerCase : % -> % + lowerCase! : % -> % + map : (((Character,Character) -> Character),%,%) -> % + map : ((Character -> Character),%) -> % + map! : ((Character -> Character),%) -> % + if $ has shallowlyMutable + match : (%,%,Character) -> NonNegativeInteger + match? : (%,%,Character) -> Boolean + max : (%,%) -> % if Character has ORDSET + maxIndex : % -> Integer if Integer has ORDSET + member? : (Character,%) -> Boolean + if Character has SETCAT + and $ has finiteAggregate + members : % -> List Character + if $ has finiteAggregate + merge : (%,%) -> % if Character has ORDSET + merge : (((Character,Character) -> Boolean),%,%) -> % + min : (%,%) -> % if Character has ORDSET + minIndex : % -> Integer if Integer has ORDSET + more? : (%,NonNegativeInteger) -> Boolean + new : (NonNegativeInteger,Character) -> % + parts : % -> List Character if $ has finiteAggregate + position : (Character,%) -> Integer + if Character has SETCAT + position : ((Character -> Boolean),%) -> Integer + position : (Character,%,Integer) -> Integer + if Character has SETCAT + position : (CharacterClass,%,Integer) -> Integer + position : (%,%,Integer) -> Integer + prefix? : (%,%) -> Boolean + qelt : (%,Integer) -> Character + qsetelt! : (%,Integer,Character) -> Character + if $ has shallowlyMutable + reduce : (((Character,Character) -> Character),%) + -> Character + if $ has finiteAggregate + reduce : (((Character,Character) -> Character),%,Character) + -> Character + if $ has finiteAggregate + reduce : + (((Character,Character) -> Character),%,Character,Character) + -> Character + if Character has SETCAT + and $ has finiteAggregate + remove : ((Character -> Boolean),%) -> % + if $ has finiteAggregate + remove : (Character,%) -> % + if Character has SETCAT + and $ has finiteAggregate + removeDuplicates : % -> % + if Character has SETCAT + and $ has finiteAggregate + replace : (%,UniversalSegment Integer,%) -> % + reverse : % -> % + reverse! : % -> % if $ has shallowlyMutable + rightTrim : (%,CharacterClass) -> % + rightTrim : (%,Character) -> % + sample : () -> % + select : ((Character -> Boolean),%) -> % + if $ has finiteAggregate + setelt : + (%,UniversalSegment Integer,Character) -> Character + if $ has shallowlyMutable + setelt : (%,Integer,Character) -> Character + if $ has shallowlyMutable + size? : (%,NonNegativeInteger) -> Boolean + sort : % -> % if Character has ORDSET + sort : (((Character,Character) -> Boolean),%) -> % + sort! : % -> % + if Character has ORDSET + and $ has shallowlyMutable + sort! : (((Character,Character) -> Boolean),%) -> % + if $ has shallowlyMutable + sorted? : (((Character,Character) -> Boolean),%) -> Boolean + sorted? : % -> Boolean if Character has ORDSET + split : (%,CharacterClass) -> List % + split : (%,Character) -> List % + substring? : (%,%,Integer) -> Boolean + suffix? : (%,%) -> Boolean + swap! : (%,Integer,Integer) -> Void + if $ has shallowlyMutable + trim : (%,CharacterClass) -> % + trim : (%,Character) -> % + upperCase : % -> % + upperCase! : % -> % + #? : % -> NonNegativeInteger if $ has finiteAggregate + ? Boolean if Character has ORDSET + ?<=? : (%,%) -> Boolean if Character has ORDSET + ?>? : (%,%) -> Boolean if Character has ORDSET + ?>=? : (%,%) -> Boolean if Character has ORDSET + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?.? : (%,UniversalSegment Integer) -> % + ?.? : (%,Integer) -> Character + ?.? : (%,%) -> % +\end{verbatim} + +These exports come from \refto{SetCategory}(): +\begin{verbatim} +\end{verbatim} + +These exports come from \refto{OpenMath}(): +\begin{verbatim} + OMwrite : (%,Boolean) -> String + OMwrite : % -> String + OMwrite : (OpenMathDevice,%,Boolean) -> Void + OMwrite : (OpenMathDevice,%) -> Void +\end{verbatim} + +<>= +)abbrev category STRICAT StringCategory +-- Note that StringCategory is built into the old compiler +-- redundant SetCategory added to help A# compiler +++ Description: +++ A category for string-like objects + +StringCategory():Category == _ + Join(StringAggregate(), SetCategory, OpenMath) with + string: Integer -> % + ++ string(i) returns the decimal representation of i in a string + +@ +<>= +"STRICAT" + [color=lightblue,href="bookvol10.2.pdf#nameddest=STRICAT"]; +"STRICAT" -> "OM" +"STRICAT" -> "SETCAT" +"STRICAT" -> "SRAGG" + +@ +<>= +"StringCategory()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=STRICAT"]; +"StringCategory()" -> "OpenMath()" +"StringCategory()" -> "SetCategory()" +"StringCategory()" -> "StringAggregate()" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"StringCategory()" [color=lightblue]; +"StringCategory()" -> "OpenMath()" +"StringCategory()" -> "SetCategory()" +"StringCategory()" -> "StringAggregate()" + +"OpenMath()" [color=lightblue]; +"OpenMath()" -> "Category" + +"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" + +"StringAggregate()" [color=lightblue]; +"StringAggregate()" -> "A1AGG..." + +"A1AGG..." [color=lightblue]; + +"Category" [color=lightblue]; + +} + +@ \chapter{Category Layer 9} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{AbelianMonoidRing}{AMR} +\pagepic{ps/v102abelianmonoidring.ps}{AMR}{0.65} + +{\bf See:}\\ +\pageto{FiniteAbelianMonoidRing}{FAMR} +\pagefrom{BiModule}{BMODULE} +\pagefrom{Ring}{RING} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{AMR}{0} & +\cross{AMR}{1} & +\cross{AMR}{associates?} & +\cross{AMR}{characteristic} \\ +\cross{AMR}{charthRoot} & +\cross{AMR}{coefficient} & +\cross{AMR}{coerce} & +\cross{AMR}{degree} \\ +\cross{AMR}{exquo} & +\cross{AMR}{hash} & +\cross{AMR}{latex} & +\cross{AMR}{leadingCoefficient} \\ +\cross{AMR}{leadingMonomial} & +\cross{AMR}{map} & +\cross{AMR}{monomial} & +\cross{AMR}{monomial?} \\ +\cross{AMR}{one?} & +\cross{AMR}{recip} & +\cross{AMR}{reductum} & +\cross{AMR}{sample} \\ +\cross{AMR}{subtractIfCan} & +\cross{AMR}{unit?} & +\cross{AMR}{unitCanonical} & +\cross{AMR}{unitNormal} \\ +\cross{AMR}{zero?} & +\cross{AMR}{?*?} & +\cross{AMR}{?**?} & +\cross{AMR}{?+?} \\ +\cross{AMR}{?-?} & +\cross{AMR}{-?} & +\cross{AMR}{?=?} & +\cross{AMR}{?\^{}?} \\ +\cross{AMR}{?\~{}=?} & +\cross{AMR}{?/?} && +\end{tabular} + + +These are directly exported but not implemented: +\begin{verbatim} + coefficient : (%,E) -> R + degree : % -> E + leadingCoefficient : % -> R + leadingMonomial : % -> % + monomial : (R,E) -> % + reductum : % -> % + ?/? : (%,R) -> % if R has FIELD +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + map : ((R -> R),%) -> % + monomial? : % -> Boolean + ?*? : (Fraction Integer,%) -> % if R has ALGEBRA FRAC INT +\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 + ?**? : (%,NonNegativeInteger) -> % + ?^? : (%,NonNegativeInteger) -> % + ?+? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (NonNegativeInteger,%) -> % + ?*? : (PositiveInteger,%) -> % + ?*? : (Integer,%) -> % + ?*? : (%,%) -> % + ?-? : (%,%) -> % + -? : % -> % + ?**? : (%,PositiveInteger) -> % + ?^? : (%,PositiveInteger) -> % +\end{verbatim} + +These exports come from \refto{BiModule}(R:Ring,R:Ring): +\begin{verbatim} + ?*? : (R,%) -> % + ?*? : (%,R) -> % +\end{verbatim} + +These exports come from \refto{IntegralDomain}(): +\begin{verbatim} + associates? : (%,%) -> Boolean if R has INTDOM + coerce : % -> % if R has INTDOM + exquo : (%,%) -> Union(%,"failed") if R has INTDOM + unit? : % -> Boolean if R has INTDOM + unitCanonical : % -> % if R has INTDOM + unitNormal : % -> Record(unit: %,canonical: %,associate: %) if R has INTDOM +\end{verbatim} + +These exports come from \refto{CharacteristicNonZero}(): +\begin{verbatim} + charthRoot : % -> Union(%,"failed") if R has CHARNZ +\end{verbatim} + +These exports come from \refto{CommutativeRing}(): +\begin{verbatim} + coerce : R -> % if R has COMRING +\end{verbatim} + +These exports come from \refto{Algebra}(Fraction(Integer)): +\begin{verbatim} + coerce : Fraction Integer -> % if R has ALGEBRA FRAC INT + ?*? : (%,Fraction Integer) -> % if R has ALGEBRA FRAC INT +\end{verbatim} + +<>= +)abbrev category AMR AbelianMonoidRing +++ Author: +++ Date Created: +++ Date Last Updated: +++ Basic Functions: +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: +++ Abelian monoid ring elements (not necessarily of finite support) +++ of this ring are of the form formal SUM (r_i * e_i) +++ where the r_i are coefficents and the e_i, elements of the +++ ordered abelian monoid, are thought of as exponents or monomials. +++ The monomials commute with each other, and with +++ the coefficients (which themselves may or may not be commutative). +++ See \spadtype{FiniteAbelianMonoidRing} for the case of finite support +++ a useful common model for polynomials and power series. +++ Conceptually at least, only the non-zero terms are ever operated on. +AbelianMonoidRing(R:Ring, E:OrderedAbelianMonoid): Category == + Join(Ring,BiModule(R,R)) with + leadingCoefficient: % -> R + ++ leadingCoefficient(p) returns the coefficient highest + ++ degree term of p. + leadingMonomial: % -> % + ++ leadingMonomial(p) returns the monomial of p with the highest degree. + degree: % -> E + ++ degree(p) returns the maximum of the exponents of the terms of p. + map: (R -> R, %) -> % + ++ map(fn,u) maps function fn onto the coefficients + ++ of the non-zero monomials of u. + monomial?: % -> Boolean + ++ monomial?(p) tests if p is a single monomial. + monomial: (R,E) -> % + ++ monomial(r,e) makes a term from a coefficient r and an exponent e. + reductum: % -> % + ++ reductum(u) returns u minus its leading monomial + ++ returns zero if handed the zero element. + coefficient: (%,E) -> R + ++ coefficient(p,e) extracts the coefficient of the monomial with + ++ exponent e from polynomial p, or returns zero if exponent + ++ is not present. + if R has Field then "/": (%,R) -> % + ++ p/c divides p by the coefficient c. + if R has CommutativeRing then + CommutativeRing + Algebra R + if R has CharacteristicZero then CharacteristicZero + if R has CharacteristicNonZero then CharacteristicNonZero + if R has IntegralDomain then IntegralDomain + if R has Algebra Fraction Integer then Algebra Fraction Integer + add + monomial? x == zero? reductum x + + map(fn:R -> R, x: %) == + -- this default definition assumes that reductum is cheap + zero? x => 0 + r:=fn leadingCoefficient x + zero? r => map(fn,reductum x) + monomial(r, degree x) + map(fn,reductum x) + + if R has Algebra Fraction Integer then + q:Fraction(Integer) * p:% == map(q * #1, p) + +@ +<>= +"AMR" + [color=lightblue,href="bookvol10.2.pdf#nameddest=AMR"]; +"AMR" -> "RING" +"AMR" -> "BMODULE" +"AMR" -> "INTDOM" +"AMR" -> "CHARNZ" +"AMR" -> "COMRING" +"AMR" -> "ALGEBRA" + +@ +<>= +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=AMR"]; +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> "Ring()" +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "BiModule(a:Ring,b:OrderedAbelianMonoid)" +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "IntegralDomain()" +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "CharacteristicNonZero()" +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "CommutativeRing()" +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "Algebra(Fraction(Integer))" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" [color=lightblue]; +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> "RING..." +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "BIMODULE..." +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "IntegralDomain()" +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "CharacteristicNonZero()" +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "CommutativeRing()" +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "Algebra(Fraction(Integer))" + +"IntegralDomain()" [color=lightblue]; +"IntegralDomain()" -> "CommutativeRing()" +"IntegralDomain()" -> "Algebra(a:CommutativeRing)" +"IntegralDomain()" -> "EntireRing()" + +"EntireRing()" [color=lightblue]; +"EntireRing()" -> "RING..." +"EntireRing()" -> "BIMODULE..." + +"CharacteristicNonZero()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=CHARNZ"]; +"CharacteristicNonZero()" -> "RING..." + +"Algebra(Fraction(Integer))" + [color=seagreen,href="bookvol10.2.pdf#nameddest=ALGEBRA"]; +"Algebra(Fraction(Integer))" -> "Algebra(a:CommutativeRing)" + +"Algebra(a:CommutativeRing)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=ALGEBRA"]; +"Algebra(a:CommutativeRing)" -> "RING..." +"Algebra(a:CommutativeRing)" -> "MODULE..." + +"CommutativeRing()" [color=lightblue]; +"CommutativeRing()" -> "RING..." +"CommutativeRing()" -> "BIMODULE..." + +"BIMODULE..." [color=lightblue]; +"RING..." [color=lightblue]; +"MODULE..." [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{CharacteristicNonZero}{CHARNZ} \pagepic{ps/v102characteristicnonzero.ps}{CHARNZ}{0.90} @@ -17420,6 +18653,356 @@ digraph pic { @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\pagehead{FiniteAbelianMonoidRing}{FAMR} +\pagepic{ps/v102finiteabelianmonoidring.ps}{FAMR}{0.40} + +{\bf See:}\\ +\pagefrom{AbelianMonoidRing}{AMR} +\pagefrom{FullyRetractableTo}{FRETRCT} + +{\bf Exports:}\\ +\begin{tabular}{lllll} +\cross{FAMR}{0} & +\cross{FAMR}{1} & +\cross{FAMR}{associates?} & +\cross{FAMR}{binomThmExpt} \\ +\cross{FAMR}{characteristic} & +\cross{FAMR}{charthRoot} & +\cross{FAMR}{coefficient} & +\cross{FAMR}{coefficients} \\ +\cross{FAMR}{coerce} & +\cross{FAMR}{content} & +\cross{FAMR}{degree} & +\cross{FAMR}{exquo} \\ +\cross{FAMR}{ground} & +\cross{FAMR}{ground?} & +\cross{FAMR}{hash} & +\cross{FAMR}{latex} \\ +\cross{FAMR}{leadingCoefficient} & +\cross{FAMR}{leadingMonomial} & +\cross{FAMR}{map} & +\cross{FAMR}{mapExponents} \\ +\cross{FAMR}{minimumDegree} & +\cross{FAMR}{monomial} & +\cross{FAMR}{monomial?} & +\cross{FAMR}{numberOfMonomials} \\ +\cross{FAMR}{one?} & +\cross{FAMR}{pomopo!} & +\cross{FAMR}{primitivePart} & +\cross{FAMR}{recip} \\ +\cross{FAMR}{reductum} & +\cross{FAMR}{retract} & +\cross{FAMR}{retractIfCan} & +\cross{FAMR}{sample} \\ +\cross{FAMR}{subtractIfCan} & +\cross{FAMR}{unit?} & +\cross{FAMR}{unitCanonical} & +\cross{FAMR}{unitNormal} \\ +\cross{FAMR}{zero?} & +\cross{FAMR}{?*?} & +\cross{FAMR}{?**?} & +\cross{FAMR}{?+?} \\ +\cross{FAMR}{?-?} & +\cross{FAMR}{-?} & +\cross{FAMR}{?=?} & +\cross{FAMR}{?\^{}?} \\ +\cross{FAMR}{?\~{}=?} & +\cross{FAMR}{?/?} && +\end{tabular} + + +These are directly exported but not implemented: +\begin{verbatim} + minimumDegree : % -> E + numberOfMonomials : % -> NonNegativeInteger +\end{verbatim} + +These are implemented by this category: +\begin{verbatim} + binomThmExpt : (%,%,NonNegativeInteger) -> % + if R has COMRING + coefficients : % -> List R + content : % -> R if R has GCDDOM + exquo : (%,R) -> Union(%,"failed") if R has INTDOM + ground : % -> R + ground? : % -> Boolean + mapExponents : ((E -> E),%) -> % + pomopo! : (%,R,E,%) -> % + primitivePart : % -> % if R has GCDDOM + ?/? : (%,R) -> % if R has FIELD +\end{verbatim} + +These exports come from \refto{AbelianMonoidRing}(R,E)\\ +where R:Ring and E:OrderedAbelianMonoid: +\begin{verbatim} + 0 : () -> % + 1 : () -> % + associates? : (%,%) -> Boolean if R has INTDOM + characteristic : () -> NonNegativeInteger + charthRoot : % -> Union(%,"failed") if R has CHARNZ + coefficient : (%,E) -> R + coerce : R -> % + coerce : Fraction Integer -> % + if R has RETRACT FRAC INT + or R has ALGEBRA FRAC INT + coerce : % -> % if R has INTDOM + coerce : % -> OutputForm + coerce : Integer -> % + degree : % -> E + exquo : (%,%) -> Union(%,"failed") if R has INTDOM + hash : % -> SingleInteger + latex : % -> String + leadingCoefficient : % -> R + leadingMonomial : % -> % + map : ((R -> R),%) -> % + monomial : (R,E) -> % + monomial? : % -> Boolean + one? : % -> Boolean + recip : % -> Union(%,"failed") + reductum : % -> % + sample : () -> % + subtractIfCan : (%,%) -> Union(%,"failed") + unit? : % -> Boolean if R has INTDOM + unitCanonical : % -> % if R has INTDOM + unitNormal : + % -> Record(unit: %,canonical: %,associate: %) + if R has INTDOM + zero? : % -> Boolean + ?+? : (%,%) -> % + ?=? : (%,%) -> Boolean + ?~=? : (%,%) -> Boolean + ?*? : (R,%) -> % + ?*? : (%,R) -> % + ?*? : (Fraction Integer,%) -> % if R has ALGEBRA FRAC INT + ?*? : (NonNegativeInteger,%) -> % + ?*? : (PositiveInteger,%) -> % + ?*? : (Integer,%) -> % + ?*? : (%,%) -> % + ?*? : (%,Fraction Integer) -> % if R has ALGEBRA FRAC INT + ?**? : (%,NonNegativeInteger) -> % + ?^? : (%,NonNegativeInteger) -> % + ?-? : (%,%) -> % + -? : % -> % + ?**? : (%,PositiveInteger) -> % + ?^? : (%,PositiveInteger) -> % +\end{verbatim} + +These exports come from \refto{FullyRetractableTo}(R:Ring): +\begin{verbatim} + retract : % -> Fraction Integer + if R has RETRACT FRAC INT + retract : % -> Integer if R has RETRACT INT + retract : % -> R + retractIfCan : % -> Union(R,"failed") + retractIfCan : % -> Union(Integer,"failed") + if R has RETRACT INT + retractIfCan : % -> Union(Fraction Integer,"failed") + if R has RETRACT FRAC INT +\end{verbatim} + +<>= +)abbrev category FAMR FiniteAbelianMonoidRing +++ Author: +++ Date Created: +++ Date Last Updated: 14.08.2000 Exported pomopo! and binomThmExpt [MMM] +++ Basic Functions: +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: This category is +++ similar to AbelianMonoidRing, except that the sum is assumed to be finite. +++ It is a useful model for polynomials, +++ but is somewhat more general. + +FiniteAbelianMonoidRing(R:Ring, E:OrderedAbelianMonoid): Category == + Join(AbelianMonoidRing(R,E),FullyRetractableTo R) with + ground?: % -> Boolean + ++ ground?(p) tests if polynomial p is a member of the + ++ coefficient ring. + -- can't be defined earlier, since a power series + -- might not know if there were other terms or not + ground: % -> R + ++ ground(p) retracts polynomial p to the coefficient ring. + coefficients: % -> List R + ++ coefficients(p) gives the list of non-zero coefficients + ++ of polynomial p. + numberOfMonomials: % -> NonNegativeInteger + ++ numberOfMonomials(p) gives the number of non-zero monomials + ++ in polynomial p. + minimumDegree: % -> E + ++ minimumDegree(p) gives the least exponent of a non-zero term + ++ of polynomial p. Error: if applied to 0. + mapExponents: (E -> E, %) -> % + ++ mapExponents(fn,u) maps function fn onto the exponents + ++ of the non-zero monomials of polynomial u. + pomopo!: (%,R,E,%) -> % + ++ \spad{pomopo!(p1,r,e,p2)} returns \spad{p1 + monomial(e,r) * p2} + ++ and may use \spad{p1} as workspace. The constaant \spad{r} is + ++ assumed to be nonzero. + if R has CommutativeRing then + binomThmExpt: (%,%,NonNegativeInteger) -> % + ++ \spad{binomThmExpt(p,q,n)} returns \spad{(x+y)^n} + ++ by means of the binomial theorem trick. + if R has IntegralDomain then + "exquo": (%,R) -> Union(%,"failed") + ++ exquo(p,r) returns the exact quotient of polynomial p by r, + ++ or "failed" if none exists. + if R has GcdDomain then + content: % -> R + ++ content(p) gives the gcd of the coefficients of polynomial p. + primitivePart: % -> % + ++ primitivePart(p) returns the unit normalized form of polynomial p + ++ divided by the content of p. + add + pomopo!(p1,r,e,p2) == p1 + r * mapExponents(#1+e,p2) + + if R has CommutativeRing then + binomThmExpt(x,y,nn) == + nn = 0 => 1$% + ans,xn,yn: % + bincoef: Integer + powl: List(%):= [x] + for i in 2..nn repeat powl:=[x * powl.first, :powl] + yn:=y; ans:=powl.first; i:=1; bincoef:=nn + for xn in powl.rest repeat + ans:= bincoef * xn * yn + ans + bincoef:= (nn-i) * bincoef quo (i+1); i:= i+1 + -- last I and BINCOEF unused + yn:= y * yn + ans + yn + ground? x == + retractIfCan(x)@Union(R,"failed") case "failed" => false + true + + ground x == retract(x)@R + + mapExponents (fn:E -> E, x: %) == + -- this default definition assumes that reductum is cheap + zero? x => 0 + monomial(leadingCoefficient x,fn degree x)+mapExponents(fn,reductum x) + + coefficients x == + zero? x => empty() + concat(leadingCoefficient x, coefficients reductum x) + + if R has Field then + x/r == map(#1/r,x) + + if R has IntegralDomain then + x exquo r == + -- probably not a very good definition in most special cases + zero? x => 0 + ans:% :=0 + t:=leadingCoefficient x exquo r + while not (t case "failed") and not zero? x repeat + ans:=ans+monomial(t::R,degree x) + x:=reductum x + if not zero? x then t:=leadingCoefficient x exquo r + t case "failed" => "failed" + ans + + if R has GcdDomain then + content x == -- this assumes reductum is cheap + zero? x => 0 + r:=leadingCoefficient x + x:=reductum x +-- while not zero? x and not one? r repeat + while not zero? x and not (r = 1) repeat + r:=gcd(r,leadingCoefficient x) + x:=reductum x + r + + primitivePart x == + zero? x => x + c := content x + unitCanonical((x exquo c)::%) + +@ +<>= +"FAMR" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FAMR"]; +"FAMR" -> "AMR" +"FAMR" -> "FRETRCT" + +@ +<>= +"FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FAMR"]; +"FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" +"FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "FullyRetractableTo(a:Ring)" + +@ +<>= +digraph pic { + fontsize=10; + bgcolor="#FFFF66"; + node [shape=box, color=white, style=filled]; + +"FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" [color=lightblue]; +"FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" +"FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "FullyRetractableTo(a:Ring)" + +"FullyRetractableTo(a:Ring)" + [color=seagreen,href="bookvol10.2.pdf#nameddest=FRETRCT"]; +"FullyRetractableTo(a:Ring)" -> "FullyRetractableTo(a:Type)" + +"FullyRetractableTo(a:Type)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FRETRCT"]; +"FullyRetractableTo(a:Type)" -> "RETRACT..." + +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" [color=lightblue]; +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> "RING..." +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "BIMODULE..." +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "IntegralDomain()" +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "CharacteristicNonZero()" +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "CommutativeRing()" +"AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)" -> + "Algebra(Fraction(Integer))" + +"IntegralDomain()" [color=lightblue]; +"IntegralDomain()" -> "CommutativeRing()" +"IntegralDomain()" -> "Algebra(a:CommutativeRing)" +"IntegralDomain()" -> "EntireRing()" + +"EntireRing()" [color=lightblue]; +"EntireRing()" -> "RING..." +"EntireRing()" -> "BIMODULE..." + +"CharacteristicNonZero()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=CHARNZ"]; +"CharacteristicNonZero()" -> "RING..." + +"Algebra(Fraction(Integer))" + [color=seagreen,href="bookvol10.2.pdf#nameddest=ALGEBRA"]; +"Algebra(Fraction(Integer))" -> "Algebra(a:CommutativeRing)" + +"Algebra(a:CommutativeRing)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=ALGEBRA"]; +"Algebra(a:CommutativeRing)" -> "RING..." +"Algebra(a:CommutativeRing)" -> "MODULE..." + +"CommutativeRing()" [color=lightblue]; +"CommutativeRing()" -> "RING..." +"CommutativeRing()" -> "BIMODULE..." + +"RETRACT..." [color=lightblue]; +"BIMODULE..." [color=lightblue]; +"RING..." [color=lightblue]; +"MODULE..." [color=lightblue]; +} + +@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \pagehead{FullyLinearlyExplicitRingOver}{FLINEXP} \pagepic{ps/v102fullylinearlyexplicitringover.ps}{FLINEXP}{1.00} @@ -17605,7 +19188,7 @@ digraph pic { \cross{MODULE}{sample} \\ \cross{MODULE}{subtractIfCan} & \cross{MODULE}{zero?} & -\cross{MODULE}{?~=?} & +\cross{MODULE}{?\~{}=?} & \cross{MODULE}{?*?} & \cross{MODULE}{?+?} \\ \cross{MODULE}{?-?} & @@ -17921,7 +19504,7 @@ digraph pic { \cross{NAALG}{sample} & \cross{NAALG}{subtractIfCan} & \cross{NAALG}{zero?} & -\cross{NAALG}{?~=?} & +\cross{NAALG}{?\~{}=?} & \cross{NAALG}{?*?} \\ \cross{NAALG}{?**?} & \cross{NAALG}{?+?} & @@ -18078,7 +19661,7 @@ digraph pic { \cross{VSPACE}{sample} & \cross{VSPACE}{subtractIfCan} & \cross{VSPACE}{zero?} & -\cross{VSPACE}{?~=?} & +\cross{VSPACE}{?\~{}=?} & \cross{VSPACE}{?*?} \\ \cross{VSPACE}{?+?} & \cross{VSPACE}{?-?} & @@ -19556,7 +21139,7 @@ digraph pic { \cross{FRNAALG}{-?} & \cross{FRNAALG}{?=?} \\ \cross{FRNAALG}{?.?} & -\cross{FRNAALG}{?~=?} \\ +\cross{FRNAALG}{?\~{}=?} \\ \end{tabular} These are directly exported but not implemented: @@ -31394,6 +32977,7 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> @@ -31423,15 +33007,19 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> +<> +<> <> +<> <> <> <> -<> -<> <> <> +<> +<> <> <> <> @@ -31471,11 +33059,14 @@ Note that this code is not included in the generated catdef.spad file. <> <> <> +<> <> <> <> <> <> +<> +<> <> <> <> @@ -31518,6 +33109,7 @@ digraph dotabb { <> <> <> +<> <> <> <> @@ -31546,15 +33138,19 @@ digraph dotabb { <> <> <> +<> <> +<> +<> <> +<> <> <> <> -<> -<> <> <> +<> +<> <> <> <> @@ -31593,11 +33189,14 @@ digraph dotabb { <> <> <> +<> <> <> <> <> <> +<> +<> <> <> <> @@ -31643,6 +33242,7 @@ digraph dotfull { <> <> <> +<> <> <> <> @@ -31671,15 +33271,19 @@ digraph dotfull { <> <> <> +<> <> +<> +<> <> +<> <> <> <> -<> -<> <> <> +<> +<> <> <> <> @@ -31718,11 +33322,14 @@ digraph dotfull { <> <> <> +<> <> <> <> <> <> +<> +<> <> <> <> diff --git a/books/ps/v102abelianmonoidring.ps b/books/ps/v102abelianmonoidring.ps new file mode 100644 index 0000000..23b877a --- /dev/null +++ b/books/ps/v102abelianmonoidring.ps @@ -0,0 +1,837 @@ +%!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 643 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 643 296 +%%PageOrientation: Portrait +gsave +36 36 607 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 +605 258 lineto +605 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 258 lineto +605 258 lineto +605 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 372 252 moveto +46 252 lineto +46 216 lineto +372 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 372 252 moveto +46 252 lineto +46 216 lineto +372 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +53 229 moveto +(AbelianMonoidRing\(a:Ring,b:OrderedAbelianMonoid\)) +[9.84 6.96 6.24 3.84 3.84 6.24 6.96 12.48 6.96 6.96 6.96 3.84 6.96 9.36 3.84 6.96 6.96 4.56 6.24 3.84 9.36 3.84 6.96 6.96 3.6 6.96 3.84 10.08 4.56 6.96 6.24 4.8 6.24 6.96 9.84 6.96 6.24 3.84 3.84 6.24 6.96 12.48 6.96 6.96 6.96 3.84 6.96 4.56] +xshow +end grestore +end grestore +% RING... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 328 36 moveto +268 36 lineto +268 0 lineto +328 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 328 36 moveto +268 36 lineto +268 0 lineto +328 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +275 13 moveto +(RING...) +[9.36 4.56 9.84 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->RING... +newpath 290 216 moveto +325 206 360 194 371 180 curveto +402 136 358 77 325 43 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 328 41 moveto +318 36 lineto +323 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 328 41 moveto +318 36 lineto +323 46 lineto +closepath +stroke +end grestore +% BIMODULE... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 153 36 moveto +51 36 lineto +51 0 lineto +153 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 153 36 moveto +51 36 lineto +51 0 lineto +153 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +59 13 moveto +(BIMODULE...) +[9.36 4.56 12.48 10.08 10.08 10.08 8.64 8.64 3.6 3.6 3.6] +xshow +end grestore +end grestore +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->BIMODULE... +newpath 118 216 moveto +95 208 73 197 56 180 curveto +20 145 7 116 29 72 curveto +35 60 45 50 56 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 58 45 moveto +64 36 lineto +54 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 58 45 moveto +64 36 lineto +54 39 lineto +closepath +stroke +end grestore +% IntegralDomain() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 190 180 moveto +76 180 lineto +76 144 lineto +190 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 190 180 moveto +76 180 lineto +76 144 lineto +190 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +83 157 moveto +(IntegralDomain\(\)) +[4.56 6.96 3.84 6.24 7.2 4.8 6.24 3.84 10.08 6.96 10.8 6.24 3.84 6.96 4.56 4.56] +xshow +end grestore +end grestore +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->IntegralDomain() +newpath 190 216 moveto +180 207 169 197 159 187 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 162 185 moveto +152 180 lineto +157 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 162 185 moveto +152 180 lineto +157 190 lineto +closepath +stroke +end grestore +% CharacteristicNonZero() +[ /Rect [ 208 144 362 180 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=CHARNZ) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 362 180 moveto +208 180 lineto +208 144 lineto +362 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 362 180 moveto +208 180 lineto +208 144 lineto +362 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +216 157 moveto +(CharacteristicNonZero\(\)) +[9.36 6.96 6.24 4.8 6.24 6.24 3.84 6.24 5.04 3.84 5.28 3.84 3.84 6.24 9.84 6.96 6.96 8.64 6.24 4.8 6.96 4.56 4.56] +xshow +end grestore +end grestore +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->CharacteristicNonZero() +newpath 228 216 moveto +238 207 249 197 259 187 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 261 190 moveto +266 180 lineto +256 185 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 261 190 moveto +266 180 lineto +256 185 lineto +closepath +stroke +end grestore +% CommutativeRing() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 166 108 moveto +38 108 lineto +38 72 lineto +166 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 166 108 moveto +38 108 lineto +38 72 lineto +166 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +46 85 moveto +(CommutativeRing\(\)) +[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 4.56] +xshow +end grestore +end grestore +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->CommutativeRing() +newpath 141 216 moveto +109 206 76 193 67 180 curveto +53 160 65 135 79 116 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 82 118 moveto +85 108 lineto +76 114 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 82 118 moveto +85 108 lineto +76 114 lineto +closepath +stroke +end grestore +% Algebra(Fraction(Integer)) +[ /Rect [ 422 144 588 180 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=ALGEBRA) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 588 180 moveto +422 180 lineto +422 144 lineto +588 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 588 180 moveto +422 180 lineto +422 144 lineto +588 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +430 157 moveto +(Algebra\(Fraction\(Integer\)\)) +[10.08 3.84 6.72 6.24 6.96 4.8 6.24 4.56 7.44 4.8 6.24 6.24 3.84 3.84 6.96 6.96 4.56 4.56 6.96 3.84 6.24 6.72 6.24 4.8 4.56 4.56] +xshow +end grestore +end grestore +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->Algebra(Fraction(Integer)) +newpath 283 216 moveto +325 206 378 193 421 182 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 422 185 moveto +431 180 lineto +421 179 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 422 185 moveto +431 180 lineto +421 179 lineto +closepath +stroke +end grestore +% IntegralDomain()->CommutativeRing() +newpath 125 144 moveto +121 136 117 126 114 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 117 116 moveto +110 108 lineto +110 119 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 117 116 moveto +110 108 lineto +110 119 lineto +closepath +stroke +end grestore +% Algebra(a:CommutativeRing) +[ /Rect [ 415 72 599 108 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=ALGEBRA) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 599 108 moveto +415 108 lineto +415 72 lineto +599 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 599 108 moveto +415 108 lineto +415 72 lineto +599 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +423 85 moveto +(Algebra\(a:CommutativeRing\)) +[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 +% IntegralDomain()->Algebra(a:CommutativeRing) +newpath 190 146 moveto +193 145 196 145 199 144 curveto +267 129 344 115 405 105 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 405 108 moveto +415 104 lineto +405 102 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 405 108 moveto +415 104 lineto +405 102 lineto +closepath +stroke +end grestore +% EntireRing() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 270 108 moveto +184 108 lineto +184 72 lineto +270 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 270 108 moveto +184 108 lineto +184 72 lineto +270 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +191 85 moveto +(EntireRing\(\)) +[8.64 6.96 3.84 3.84 4.8 6.24 9.36 3.84 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% IntegralDomain()->EntireRing() +newpath 157 144 moveto +168 135 183 124 196 114 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 198 117 moveto +204 108 lineto +194 111 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 198 117 moveto +204 108 lineto +194 111 lineto +closepath +stroke +end grestore +% CharacteristicNonZero()->RING... +newpath 287 144 moveto +289 119 293 75 295 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 298 46 moveto +296 36 lineto +292 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 298 46 moveto +296 36 lineto +292 46 lineto +closepath +stroke +end grestore +% CommutativeRing()->RING... +newpath 151 72 moveto +184 60 228 44 258 33 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 260 36 moveto +268 29 lineto +257 29 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 260 36 moveto +268 29 lineto +257 29 lineto +closepath +stroke +end grestore +% CommutativeRing()->BIMODULE... +newpath 102 72 moveto +102 64 102 55 102 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 106 46 moveto +102 36 lineto +99 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 106 46 moveto +102 36 lineto +99 46 lineto +closepath +stroke +end grestore +% Algebra(Fraction(Integer))->Algebra(a:CommutativeRing) +newpath 506 144 moveto +506 136 506 127 506 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 509 118 moveto +507 108 lineto +503 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 509 118 moveto +507 108 lineto +503 118 lineto +closepath +stroke +end grestore +% Algebra(a:CommutativeRing)->RING... +newpath 455 72 moveto +419 59 371 43 338 32 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 339 28 moveto +328 28 lineto +336 35 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 339 28 moveto +328 28 lineto +336 35 lineto +closepath +stroke +end grestore +% MODULE... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 551 36 moveto +463 36 lineto +463 0 lineto +551 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 551 36 moveto +463 36 lineto +463 0 lineto +551 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +471 13 moveto +(MODULE...) +[12.48 10.08 10.08 10.08 8.64 8.64 3.6 3.6 3.6] +xshow +end grestore +end grestore +% Algebra(a:CommutativeRing)->MODULE... +newpath 507 72 moveto +507 64 507 55 507 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 511 46 moveto +507 36 lineto +504 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 511 46 moveto +507 36 lineto +504 46 lineto +closepath +stroke +end grestore +% EntireRing()->RING... +newpath 245 72 moveto +254 63 264 53 273 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 276 46 moveto +280 36 lineto +271 41 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 276 46 moveto +280 36 lineto +271 41 lineto +closepath +stroke +end grestore +% EntireRing()->BIMODULE... +newpath 195 72 moveto +179 63 159 51 142 41 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 143 38 moveto +133 36 lineto +140 44 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 143 38 moveto +133 36 lineto +140 44 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102filecategory.ps b/books/ps/v102filecategory.ps new file mode 100644 index 0000000..b4e428c --- /dev/null +++ b/books/ps/v102filecategory.ps @@ -0,0 +1,494 @@ +%!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 315 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 315 368 +%%PageOrientation: Portrait +gsave +36 36 279 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 +277 330 lineto +277 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 330 lineto +277 330 lineto +277 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% FileCategory(a:SetCategory,b:SetCategory) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 260 324 moveto +0 324 lineto +0 288 lineto +260 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 260 324 moveto +0 324 lineto +0 288 lineto +260 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 301 moveto +(FileCategory\(a:SetCategory,b:SetCategory\)) +[7.44 3.84 3.84 6.24 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 6.24 3.84 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6 3.6 6.96 3.84 7.68 6 3.84 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56] +xshow +end grestore +end grestore +% SetCategory() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 177 252 moveto +83 252 lineto +83 216 lineto +177 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 177 252 moveto +83 252 lineto +83 216 lineto +177 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +90 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 +% FileCategory(a:SetCategory,b:SetCategory)->SetCategory() +newpath 130 288 moveto +130 280 130 271 130 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 134 262 moveto +130 252 lineto +127 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 134 262 moveto +130 252 lineto +127 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 109 108 moveto +25 108 lineto +25 72 lineto +109 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 109 108 moveto +25 108 lineto +25 72 lineto +109 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +32 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 118 216 moveto +111 206 103 192 98 180 curveto +89 160 80 136 75 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 78 117 moveto +72 108 lineto +72 119 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 78 117 moveto +72 108 lineto +72 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 271 180 moveto +107 180 lineto +107 144 lineto +271 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 271 180 moveto +107 180 lineto +107 144 lineto +271 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +115 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 145 216 moveto +152 207 160 197 168 188 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 171 190 moveto +174 180 lineto +165 186 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 171 190 moveto +174 180 lineto +165 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 164 36 moveto +96 36 lineto +96 0 lineto +164 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 164 36 moveto +96 36 lineto +96 0 lineto +164 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +104 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 83 72 moveto +91 63 100 53 107 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 110 46 moveto +114 36 lineto +105 41 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 110 46 moveto +114 36 lineto +105 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 259 108 moveto +127 108 lineto +127 72 lineto +259 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 259 108 moveto +127 108 lineto +127 72 lineto +259 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +135 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 190 144 moveto +191 136 191 127 191 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 194 118 moveto +192 108 lineto +188 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 194 118 moveto +192 108 lineto +188 118 lineto +closepath +stroke +end grestore +% CoercibleTo(a:Type)->Category +newpath 177 72 moveto +169 63 160 53 153 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 155 41 moveto +146 36 lineto +150 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 155 41 moveto +146 36 lineto +150 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102filenamecategory.ps b/books/ps/v102filenamecategory.ps new file mode 100644 index 0000000..a79cdab --- /dev/null +++ b/books/ps/v102filenamecategory.ps @@ -0,0 +1,499 @@ +%!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 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 290 368 +%%PageOrientation: Portrait +gsave +36 36 254 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 +252 330 lineto +252 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 330 lineto +252 330 lineto +252 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% FileNameCategory() +[ /Rect [ 39 288 171 324 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=FNCAT) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 171 324 moveto +39 324 lineto +39 288 lineto +171 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 171 324 moveto +39 324 lineto +39 288 lineto +171 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +47 301 moveto +(FileNameCategory\(\)) +[7.44 3.84 3.84 6.24 9.6 6.24 10.8 6.24 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 +% 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 +% FileNameCategory()->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/v102finiteabelianmonoidring.ps b/books/ps/v102finiteabelianmonoidring.ps new file mode 100644 index 0000000..30c0897 --- /dev/null +++ b/books/ps/v102finiteabelianmonoidring.ps @@ -0,0 +1,1033 @@ +%!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 912 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 912 368 +%%PageOrientation: Portrait +gsave +36 36 876 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 +874 330 lineto +874 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 330 lineto +874 330 lineto +874 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 730 324 moveto +372 324 lineto +372 288 lineto +730 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 730 324 moveto +372 324 lineto +372 288 lineto +730 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +379 301 moveto +(FiniteAbelianMonoidRing\(a:Ring,b:OrderedAbelianMonoid\)) +[7.44 3.84 6.96 3.84 3.84 6.24 9.84 6.96 6.24 3.84 3.84 6.24 6.96 12.48 6.96 6.96 6.96 3.84 6.96 9.36 3.84 6.96 6.96 4.56 6.24 3.84 9.36 3.84 6.96 6.96 3.6 6.96 3.84 10.08 4.56 6.96 6.24 4.8 6.24 6.96 9.84 6.96 6.24 3.84 3.84 6.24 6.96 12.48 6.96 6.96 6.96 3.84 6.96 4.56] +xshow +end grestore +end grestore +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 548 252 moveto +222 252 lineto +222 216 lineto +548 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 548 252 moveto +222 252 lineto +222 216 lineto +548 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +229 229 moveto +(AbelianMonoidRing\(a:Ring,b:OrderedAbelianMonoid\)) +[9.84 6.96 6.24 3.84 3.84 6.24 6.96 12.48 6.96 6.96 6.96 3.84 6.96 9.36 3.84 6.96 6.96 4.56 6.24 3.84 9.36 3.84 6.96 6.96 3.6 6.96 3.84 10.08 4.56 6.96 6.24 4.8 6.24 6.96 9.84 6.96 6.24 3.84 3.84 6.24 6.96 12.48 6.96 6.96 6.96 3.84 6.96 4.56] +xshow +end grestore +end grestore +% FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid) +newpath 509 288 moveto +487 278 459 266 435 256 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 437 253 moveto +426 252 lineto +434 259 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 437 253 moveto +426 252 lineto +434 259 lineto +closepath +stroke +end grestore +% FullyRetractableTo(a:Ring) +[ /Rect [ 632 216 802 252 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=FRETRCT) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 802 252 moveto +632 252 lineto +632 216 lineto +802 216 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 802 252 moveto +632 252 lineto +632 216 lineto +802 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +640 229 moveto +(FullyRetractableTo\(a:Ring\)) +[7.44 6.96 3.84 3.6 6.96 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 9.36 3.84 6.96 6.96 4.56] +xshow +end grestore +end grestore +% FiniteAbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->FullyRetractableTo(a:Ring) +newpath 593 288 moveto +615 278 643 266 667 256 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 668 259 moveto +676 252 lineto +665 253 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 668 259 moveto +676 252 lineto +665 253 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 364 36 moveto +304 36 lineto +304 0 lineto +364 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 364 36 moveto +304 36 lineto +304 0 lineto +364 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +311 13 moveto +(RING...) +[9.36 4.56 9.84 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->RING... +newpath 434 216 moveto +451 208 467 196 477 180 curveto +502 138 509 110 481 72 curveto +453 32 424 51 374 35 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 375 32 moveto +364 32 lineto +373 38 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 375 32 moveto +364 32 lineto +373 38 lineto +closepath +stroke +end grestore +% BIMODULE... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 153 36 moveto +51 36 lineto +51 0 lineto +153 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 153 36 moveto +51 36 lineto +51 0 lineto +153 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +59 13 moveto +(BIMODULE...) +[9.36 4.56 12.48 10.08 10.08 10.08 8.64 8.64 3.6 3.6 3.6] +xshow +end grestore +end grestore +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->BIMODULE... +newpath 246 216 moveto +207 208 164 196 127 180 curveto +78 157 54 156 29 108 curveto +22 93 22 86 29 72 curveto +35 60 45 50 56 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 58 45 moveto +64 36 lineto +54 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 58 45 moveto +64 36 lineto +54 39 lineto +closepath +stroke +end grestore +% IntegralDomain() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 284 180 moveto +170 180 lineto +170 144 lineto +284 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 284 180 moveto +170 180 lineto +170 144 lineto +284 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +177 157 moveto +(IntegralDomain\(\)) +[4.56 6.96 3.84 6.24 7.2 4.8 6.24 3.84 10.08 6.96 10.8 6.24 3.84 6.96 4.56 4.56] +xshow +end grestore +end grestore +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->IntegralDomain() +newpath 345 216 moveto +324 206 298 194 275 184 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 277 181 moveto +266 180 lineto +274 187 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 277 181 moveto +266 180 lineto +274 187 lineto +closepath +stroke +end grestore +% CharacteristicNonZero() +[ /Rect [ 526 144 680 180 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=CHARNZ) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 680 180 moveto +526 180 lineto +526 144 lineto +680 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 680 180 moveto +526 180 lineto +526 144 lineto +680 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +534 157 moveto +(CharacteristicNonZero\(\)) +[9.36 6.96 6.24 4.8 6.24 6.24 3.84 6.24 5.04 3.84 5.28 3.84 3.84 6.24 9.84 6.96 6.96 8.64 6.24 4.8 6.96 4.56 4.56] +xshow +end grestore +end grestore +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->CharacteristicNonZero() +newpath 440 216 moveto +470 206 507 194 539 183 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 540 186 moveto +549 180 lineto +538 180 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 540 186 moveto +549 180 lineto +538 180 lineto +closepath +stroke +end grestore +% CommutativeRing() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 166 108 moveto +38 108 lineto +38 72 lineto +166 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 166 108 moveto +38 108 lineto +38 72 lineto +166 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +46 85 moveto +(CommutativeRing\(\)) +[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 4.56] +xshow +end grestore +end grestore +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->CommutativeRing() +newpath 279 216 moveto +231 206 180 194 161 180 curveto +139 164 123 138 113 117 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 116 116 moveto +109 108 lineto +110 119 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 116 116 moveto +109 108 lineto +110 119 lineto +closepath +stroke +end grestore +% Algebra(Fraction(Integer)) +[ /Rect [ 302 144 468 180 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=ALGEBRA) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 468 180 moveto +302 180 lineto +302 144 lineto +468 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 468 180 moveto +302 180 lineto +302 144 lineto +468 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +310 157 moveto +(Algebra\(Fraction\(Integer\)\)) +[10.08 3.84 6.72 6.24 6.96 4.8 6.24 4.56 7.44 4.8 6.24 6.24 3.84 3.84 6.96 6.96 4.56 4.56 6.96 3.84 6.24 6.72 6.24 4.8 4.56 4.56] +xshow +end grestore +end grestore +% AbelianMonoidRing(a:Ring,b:OrderedAbelianMonoid)->Algebra(Fraction(Integer)) +newpath 385 216 moveto +385 208 385 199 385 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 389 190 moveto +385 180 lineto +382 190 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 389 190 moveto +385 180 lineto +382 190 lineto +closepath +stroke +end grestore +% FullyRetractableTo(a:Type) +[ /Rect [ 698 144 868 180 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=FRETRCT) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 868 180 moveto +698 180 lineto +698 144 lineto +868 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 868 180 moveto +698 180 lineto +698 144 lineto +868 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +706 157 moveto +(FullyRetractableTo\(a:Type\)) +[7.44 6.96 3.84 3.6 6.96 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 +% FullyRetractableTo(a:Ring)->FullyRetractableTo(a:Type) +newpath 734 216 moveto +742 207 751 197 760 188 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 763 190 moveto +767 180 lineto +758 185 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 763 190 moveto +767 180 lineto +758 185 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 828 108 moveto +738 108 lineto +738 72 lineto +828 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 828 108 moveto +738 108 lineto +738 72 lineto +828 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +746 85 moveto +(RETRACT...) +[9.36 8.64 8.64 9.36 9.36 9.36 7.44 3.6 3.6 3.6] +xshow +end grestore +end grestore +% FullyRetractableTo(a:Type)->RETRACT... +newpath 783 144 moveto +783 136 783 127 783 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 787 118 moveto +783 108 lineto +780 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 787 118 moveto +783 108 lineto +780 118 lineto +closepath +stroke +end grestore +% IntegralDomain()->CommutativeRing() +newpath 195 144 moveto +179 135 159 123 142 113 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 143 110 moveto +133 108 lineto +140 116 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 143 110 moveto +133 108 lineto +140 116 lineto +closepath +stroke +end grestore +% Algebra(a:CommutativeRing) +[ /Rect [ 288 72 472 108 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=ALGEBRA) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 472 108 moveto +288 108 lineto +288 72 lineto +472 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 472 108 moveto +288 108 lineto +288 72 lineto +472 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +296 85 moveto +(Algebra\(a:CommutativeRing\)) +[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 +% IntegralDomain()->Algebra(a:CommutativeRing) +newpath 266 144 moveto +286 134 311 123 333 112 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 334 115 moveto +342 108 lineto +331 109 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 334 115 moveto +342 108 lineto +331 109 lineto +closepath +stroke +end grestore +% EntireRing() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 270 108 moveto +184 108 lineto +184 72 lineto +270 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 270 108 moveto +184 108 lineto +184 72 lineto +270 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +191 85 moveto +(EntireRing\(\)) +[8.64 6.96 3.84 3.84 4.8 6.24 9.36 3.84 6.96 6.96 4.56 4.56] +xshow +end grestore +end grestore +% IntegralDomain()->EntireRing() +newpath 227 144 moveto +227 136 227 127 227 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 231 118 moveto +227 108 lineto +224 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 231 118 moveto +227 108 lineto +224 118 lineto +closepath +stroke +end grestore +% CharacteristicNonZero()->RING... +newpath 590 144 moveto +574 123 546 90 514 72 curveto +460 41 435 55 374 35 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 375 32 moveto +364 32 lineto +373 38 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 375 32 moveto +364 32 lineto +373 38 lineto +closepath +stroke +end grestore +% CommutativeRing()->RING... +newpath 160 72 moveto +202 59 257 42 294 30 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 295 33 moveto +304 27 lineto +293 27 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 295 33 moveto +304 27 lineto +293 27 lineto +closepath +stroke +end grestore +% CommutativeRing()->BIMODULE... +newpath 102 72 moveto +102 64 102 55 102 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 106 46 moveto +102 36 lineto +99 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 106 46 moveto +102 36 lineto +99 46 lineto +closepath +stroke +end grestore +% Algebra(Fraction(Integer))->Algebra(a:CommutativeRing) +newpath 384 144 moveto +383 136 383 127 382 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 385 118 moveto +381 108 lineto +379 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 385 118 moveto +381 108 lineto +379 118 lineto +closepath +stroke +end grestore +% Algebra(a:CommutativeRing)->RING... +newpath 368 72 moveto +363 64 356 54 350 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 353 43 moveto +345 36 lineto +347 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 353 43 moveto +345 36 lineto +347 46 lineto +closepath +stroke +end grestore +% MODULE... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 470 36 moveto +382 36 lineto +382 0 lineto +470 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 470 36 moveto +382 36 lineto +382 0 lineto +470 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +390 13 moveto +(MODULE...) +[12.48 10.08 10.08 10.08 8.64 8.64 3.6 3.6 3.6] +xshow +end grestore +end grestore +% Algebra(a:CommutativeRing)->MODULE... +newpath 392 72 moveto +397 64 404 54 410 44 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 413 46 moveto +415 36 lineto +407 43 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 413 46 moveto +415 36 lineto +407 43 lineto +closepath +stroke +end grestore +% EntireRing()->RING... +newpath 254 72 moveto +268 63 284 52 298 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 301 44 moveto +307 36 lineto +297 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 301 44 moveto +307 36 lineto +297 39 lineto +closepath +stroke +end grestore +% EntireRing()->BIMODULE... +newpath 195 72 moveto +179 63 159 51 142 41 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 143 38 moveto +133 36 lineto +140 44 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 143 38 moveto +133 36 lineto +140 44 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102openmath.ps b/books/ps/v102openmath.ps new file mode 100644 index 0000000..079c330 --- /dev/null +++ b/books/ps/v102openmath.ps @@ -0,0 +1,289 @@ +%!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 130 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 130 152 +%%PageOrientation: Portrait +gsave +36 36 94 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 +92 114 lineto +92 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 114 lineto +92 114 lineto +92 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% OpenMath() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 86 108 moveto +0 108 lineto +0 72 lineto +86 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 86 108 moveto +0 108 lineto +0 72 lineto +86 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 85 moveto +(OpenMath\(\)) +[10.08 6.96 6.24 6.96 12.48 6.24 4.08 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 77 36 moveto +9 36 lineto +9 0 lineto +77 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 77 36 moveto +9 36 lineto +9 0 lineto +77 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +17 13 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% OpenMath()->Category +newpath 43 72 moveto +43 64 43 55 43 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 47 46 moveto +43 36 lineto +40 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 47 46 moveto +43 36 lineto +40 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102patternable.ps b/books/ps/v102patternable.ps new file mode 100644 index 0000000..7c5e1c9 --- /dev/null +++ b/books/ps/v102patternable.ps @@ -0,0 +1,289 @@ +%!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 170 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 170 152 +%%PageOrientation: Portrait +gsave +36 36 134 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 +132 114 lineto +132 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 114 lineto +132 114 lineto +132 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% Patternable(a:Type) +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 126 108 moveto +0 108 lineto +0 72 lineto +126 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 126 108 moveto +0 108 lineto +0 72 lineto +126 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +7 85 moveto +(Patternable\(a:Type\)) +[7.44 6.24 3.84 3.84 6.24 5.04 6.96 6.24 6.96 3.84 6.24 4.56 6.24 3.84 7.2 6.96 6.96 6.24 4.56] +xshow +end grestore +end grestore +% Category +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 97 36 moveto +29 36 lineto +29 0 lineto +97 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 97 36 moveto +29 36 lineto +29 0 lineto +97 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +37 13 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% Patternable(a:Type)->Category +newpath 63 72 moveto +63 64 63 55 63 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 67 46 moveto +63 36 lineto +60 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 67 46 moveto +63 36 lineto +60 46 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/books/ps/v102patternmatchable.ps b/books/ps/v102patternmatchable.ps new file mode 100644 index 0000000..7e1c661 --- /dev/null +++ b/books/ps/v102patternmatchable.ps @@ -0,0 +1,499 @@ +%!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 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 290 368 +%%PageOrientation: Portrait +gsave +36 36 254 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 +252 330 lineto +252 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 330 lineto +252 330 lineto +252 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% PatternMatchable(a:SetCategory) +[ /Rect [ 3 288 207 324 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=PATMAB) >> + /Subtype /Link +/ANN pdfmark +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 207 324 moveto +3 324 lineto +3 288 lineto +207 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 207 324 moveto +3 324 lineto +3 288 lineto +207 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +11 301 moveto +(PatternMatchable\(a:SetCategory\)) +[7.44 6.24 3.84 3.84 6.24 5.04 6.96 12.48 6.24 3.84 6 6.96 6.24 6.96 3.84 6.24 4.56 6.24 3.84 7.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 +% 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 +% PatternMatchable(a:SetCategory)->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/v102stringcategory.ps b/books/ps/v102stringcategory.ps new file mode 100644 index 0000000..54a6409 --- /dev/null +++ b/books/ps/v102stringcategory.ps @@ -0,0 +1,653 @@ +%!PS-Adobe-2.0 +%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006) +%%For: (root) root +%%Title: pic +%%Pages: (atend) +%%BoundingBox: 36 36 474 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 474 368 +%%PageOrientation: Portrait +gsave +36 36 438 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 +436 330 lineto +436 -6 lineto +closepath +fill +0.167 0.600 1.000 graphcolor +newpath -6 -6 moveto +-6 330 lineto +436 330 lineto +436 -6 lineto +closepath +stroke +0.000 0.000 0.000 graphcolor +14.00 /Times-Roman set_font +% StringCategory() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 232 324 moveto +122 324 lineto +122 288 lineto +232 288 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 232 324 moveto +122 324 lineto +122 288 lineto +232 288 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +129 301 moveto +(StringCategory\(\)) +[7.44 3.84 5.04 3.84 6.96 6.96 9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96 4.56 4.56] +xshow +end grestore +end grestore +% OpenMath() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 86 108 moveto +0 108 lineto +0 72 lineto +86 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 86 108 moveto +0 108 lineto +0 72 lineto +86 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +8 85 moveto +(OpenMath\(\)) +[10.08 6.96 6.24 6.96 12.48 6.24 4.08 6.96 4.56 4.56] +xshow +end grestore +end grestore +% StringCategory()->OpenMath() +newpath 155 288 moveto +144 278 131 265 121 252 curveto +90 209 66 151 53 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 56 116 moveto +49 108 lineto +49 119 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 56 116 moveto +49 108 lineto +49 119 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 224 252 moveto +130 252 lineto +130 216 lineto +224 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 224 252 moveto +130 252 lineto +130 216 lineto +224 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +137 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 +% StringCategory()->SetCategory() +newpath 177 288 moveto +177 280 177 271 177 262 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 181 262 moveto +177 252 lineto +174 262 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 181 262 moveto +177 252 lineto +174 262 lineto +closepath +stroke +end grestore +% StringAggregate() +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 421 252 moveto +303 252 lineto +303 216 lineto +421 216 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 421 252 moveto +303 252 lineto +303 216 lineto +421 216 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +311 229 moveto +(StringAggregate\(\)) +[7.44 3.84 5.04 3.84 6.96 6.96 9.84 6.96 7.2 4.8 6.24 6.72 6.24 3.84 6.24 4.56 4.56] +xshow +end grestore +end grestore +% StringCategory()->StringAggregate() +newpath 224 288 moveto +249 278 280 266 307 256 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 308 259 moveto +316 252 lineto +305 253 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 308 259 moveto +316 252 lineto +305 253 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 180 36 moveto +112 36 lineto +112 0 lineto +180 0 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 180 36 moveto +112 36 lineto +112 0 lineto +180 0 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +120 13 moveto +(Category) +[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96] +xshow +end grestore +end grestore +% OpenMath()->Category +newpath 69 72 moveto +82 63 98 52 112 42 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 115 44 moveto +121 36 lineto +111 39 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 115 44 moveto +121 36 lineto +111 39 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 188 108 moveto +104 108 lineto +104 72 lineto +188 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 188 108 moveto +104 108 lineto +104 72 lineto +188 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +111 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 173 216 moveto +171 206 168 192 165 180 curveto +161 159 156 136 152 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 155 117 moveto +150 108 lineto +149 118 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 155 117 moveto +150 108 lineto +149 118 lineto +closepath +stroke +end grestore +% CoercibleTo(OutputForm) +gsave 10 dict begin +filled +0.404 0.667 0.545 nodecolor +0.404 0.667 0.545 nodecolor +newpath 338 180 moveto +174 180 lineto +174 144 lineto +338 144 lineto +closepath +fill +0.404 0.667 0.545 nodecolor +newpath 338 180 moveto +174 180 lineto +174 144 lineto +338 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +182 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 197 216 moveto +207 207 218 197 228 187 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 231 189 moveto +236 180 lineto +226 184 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 231 189 moveto +236 180 lineto +226 184 lineto +closepath +stroke +end grestore +% A1AGG... +gsave 10 dict begin +filled +0.537 0.247 0.902 nodecolor +0.537 0.247 0.902 nodecolor +newpath 430 180 moveto +356 180 lineto +356 144 lineto +430 144 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 430 180 moveto +356 180 lineto +356 144 lineto +430 144 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +363 157 moveto +(A1AGG...) +[10.08 6.96 9.36 10.08 10.08 3.6 3.6 3.6] +xshow +end grestore +end grestore +% StringAggregate()->A1AGG... +newpath 370 216 moveto +374 208 378 198 381 190 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 385 191 moveto +385 180 lineto +378 188 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 385 191 moveto +385 180 lineto +378 188 lineto +closepath +stroke +end grestore +% BasicType()->Category +newpath 146 72 moveto +146 64 146 55 146 46 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 150 46 moveto +146 36 lineto +143 46 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 150 46 moveto +146 36 lineto +143 46 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 338 108 moveto +206 108 lineto +206 72 lineto +338 72 lineto +closepath +fill +0.537 0.247 0.902 nodecolor +newpath 338 108 moveto +206 108 lineto +206 72 lineto +338 72 lineto +closepath +stroke +gsave 10 dict begin +0.000 0.000 0.000 nodecolor +214 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 260 144 moveto +262 136 264 127 266 118 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 269 118 moveto +268 108 lineto +263 117 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 269 118 moveto +268 108 lineto +263 117 lineto +closepath +stroke +end grestore +% CoercibleTo(a:Type)->Category +newpath 240 72 moveto +224 63 204 51 186 41 curveto +stroke +gsave 10 dict begin +solid +1 setlinewidth +0.000 0.000 0.000 edgecolor +newpath 187 38 moveto +177 36 lineto +184 44 lineto +closepath +fill +0.000 0.000 0.000 edgecolor +newpath 187 38 moveto +177 36 lineto +184 44 lineto +closepath +stroke +end grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +%%Pages: 1 +end +restore +%%EOF diff --git a/changelog b/changelog index 0cb9bd1..7e6fde6 100644 --- a/changelog +++ b/changelog @@ -1,3 +1,26 @@ +20081002 tpd books/bookvol10.2 add categories +20081002 tpd books/ps/v102finiteabelianmonoidring.ps added +20081002 tpd src/algebra/polycat.spad move FAMR into bookvol10.2 +20081002 tpd books/ps/v102patternmatchable.ps added +20081002 tpd books/ps/v102fullypatternmatchable.ps added +20081002 tpd src/algebra/patmatch1.spad PATMAB, FPATMAB into bookvol10.2 +20081002 tpd books/ps/v102patternable.ps added +20081002 tpd src/algebra/pattern.spad move PATAB into bookvol10.2 +20081002 tpd books/ps/v102filenamecategory.ps added +20081002 tpd src/algebra/fname.spad move FNCAT into bookvol10.2 +20081002 tpd books/ps/v102abelianmonoidring.ps added +20081002 tpd src/algebra/polycat.spad move AMR into bookvol10.2 +20081002 tpd books/ps/v102stringcategory.ps added +20081002 tpd src/algebra/string.spad move STRICAT into bookvol10.2 +20081002 tpd books/ps/v102filecategory.ps added +20081002 tpd src/algebra/files.spad move FILECAT into bookvol10.2 +20081002 tpd src/algebra/Makefile remove omcat.spad +20081002 tpd books/ps/v102openmath.ps added +20081002 tpd src/algebra/omcat.spad absorbed into bookvol10.2 +20081001 tpd books/ps/v102finitefieldcategory.ps added +20081001 tpd books/ps/v102finitealgebraicextensionfield.ps added +20081001 tpd books/ps/v102setcategory.ps regenerate +20081001 tpd books/bookvol10.2 add more categories 20080930 tpd books/ps/v102fieldofprimecharacteristic.ps added 20080930 tpd books/ps/v102extensionfield.ps added 20080930 tpd books/bookvol10.2 add XF, FPC from ffcat diff --git a/src/algebra/Makefile.pamphlet b/src/algebra/Makefile.pamphlet index 4ab63a5..e3030a0 100644 --- a/src/algebra/Makefile.pamphlet +++ b/src/algebra/Makefile.pamphlet @@ -173,7 +173,6 @@ LAYER0COPY=\ \subsubsection{Completed spad files} \begin{verbatim} dhmatrix.spad.pamphlet (DHMATRIX) -omcat.spad.pamphlet (OM) print.spad.pamphlet (PRINT) ptranfn.spad.pamphlet (PTRANFN) system.spad.pamphlet (MSYSCMD) @@ -1259,7 +1258,7 @@ SPADFILES= \ ${OUTSRC}/numode.spad ${OUTSRC}/numquad.spad ${OUTSRC}/numsolve.spad \ ${OUTSRC}/numtheor.spad \ ${OUTSRC}/oct.spad ${OUTSRC}/odealg.spad ${OUTSRC}/odeef.spad \ - ${OUTSRC}/oderf.spad ${OUTSRC}/omcat.spad ${OUTSRC}/omdev.spad \ + ${OUTSRC}/oderf.spad ${OUTSRC}/omdev.spad \ ${OUTSRC}/omerror.spad ${OUTSRC}/omserver.spad ${OUTSRC}/opalg.spad \ ${OUTSRC}/openmath.spad ${OUTSRC}/op.spad ${OUTSRC}/ore.spad \ ${OUTSRC}/outform.spad ${OUTSRC}/out.spad \ @@ -1420,7 +1419,7 @@ DOCFILES= \ ${DOC}/numode.spad.dvi ${DOC}/numquad.spad.dvi ${DOC}/numsolve.spad.dvi \ ${DOC}/numtheor.spad.dvi \ ${DOC}/oct.spad.dvi ${DOC}/odealg.spad.dvi ${DOC}/odeef.spad.dvi \ - ${DOC}/oderf.spad.dvi ${DOC}/omcat.spad.dvi ${DOC}/omdev.spad.dvi \ + ${DOC}/oderf.spad.dvi ${DOC}/omdev.spad.dvi \ ${DOC}/omerror.spad.dvi ${DOC}/omserver.spad.dvi ${DOC}/opalg.spad.dvi \ ${DOC}/openmath.spad.dvi ${DOC}/op.spad.dvi ${DOC}/ore.spad.dvi \ ${DOC}/outform.spad.dvi ${DOC}/out.spad.dvi \ diff --git a/src/algebra/ffcat.spad.pamphlet b/src/algebra/ffcat.spad.pamphlet index 3872c81..c45858b 100644 --- a/src/algebra/ffcat.spad.pamphlet +++ b/src/algebra/ffcat.spad.pamphlet @@ -24,282 +24,6 @@ -- Fields with finite characteristic \end{verbatim} -\section{category FAXF FiniteAlgebraicExtensionField} -<>= -)abbrev category FAXF FiniteAlgebraicExtensionField -++ Author: J. Grabmeier, A. Scheerhorn -++ Date Created: 11 March 1991 -++ Date Last Updated: 31 March 1991 -++ Basic Operations: _+, _*, extensionDegree, -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: field, extension field, algebraic extension, finite extension -++ References: -++ R.Lidl, H.Niederreiter: Finite Field, Encycoldia of Mathematics and -++ Its Applications, Vol. 20, Cambridge Univ. Press, 1983, ISBN 0 521 30240 4 -++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. -++ AXIOM Technical Report Series, ATR/5 NP2522. -++ Description: -++ FiniteAlgebraicExtensionField {\em F} is the category of fields -++ which are finite algebraic extensions of the field {\em F}. -++ If {\em F} is finite then any finite algebraic extension of {\em F} is finite, too. -++ Let {\em K} be a finite algebraic extension of the finite field {\em F}. -++ The exponentiation of elements of {\em K} defines a Z-module structure -++ on the multiplicative group of {\em K}. The additive group of {\em K} -++ becomes a module over the ring of polynomials over {\em F} via the operation -++ \spadfun{linearAssociatedExp}(a:K,f:SparseUnivariatePolynomial F) -++ which is linear over {\em F}, i.e. for elements {\em a} from {\em K}, -++ {\em c,d} from {\em F} and {\em f,g} univariate polynomials over {\em F} -++ we have \spadfun{linearAssociatedExp}(a,cf+dg) equals {\em c} times -++ \spadfun{linearAssociatedExp}(a,f) plus {\em d} times -++ \spadfun{linearAssociatedExp}(a,g). -++ Therefore \spadfun{linearAssociatedExp} is defined completely by -++ its action on monomials from {\em F[X]}: -++ \spadfun{linearAssociatedExp}(a,monomial(1,k)\$SUP(F)) is defined to be -++ \spadfun{Frobenius}(a,k) which is {\em a**(q**k)} where {\em q=size()\$F}. -++ The operations order and discreteLog associated with the multiplicative -++ exponentiation have additive analogues associated to the operation -++ \spadfun{linearAssociatedExp}. These are the functions -++ \spadfun{linearAssociatedOrder} and \spadfun{linearAssociatedLog}, -++ respectively. - -FiniteAlgebraicExtensionField(F : Field) : Category == _ - Join(ExtensionField F, RetractableTo F) with - -- should be unified with algebras - -- Join(ExtensionField F, FramedAlgebra F, RetractableTo F) with - basis : () -> Vector $ - ++ basis() returns a fixed basis of \$ as \spad{F}-vectorspace. - basis : PositiveInteger -> Vector $ - ++ basis(n) returns a fixed basis of a subfield of \$ as - ++ \spad{F}-vectorspace. - coordinates : $ -> Vector F - ++ coordinates(a) returns the coordinates of \spad{a} with respect - ++ to the fixed \spad{F}-vectorspace basis. - coordinates : Vector $ -> Matrix F - ++ coordinates([v1,...,vm]) returns the coordinates of the - ++ vi's with to the fixed basis. The coordinates of vi are - ++ contained in the ith row of the matrix returned by this - ++ function. - represents: Vector F -> $ - ++ represents([a1,..,an]) returns \spad{a1*v1 + ... + an*vn}, where - ++ v1,...,vn are the elements of the fixed basis. - minimalPolynomial: $ -> SparseUnivariatePolynomial F - ++ minimalPolynomial(a) returns the minimal polynomial of an - ++ element \spad{a} over the ground field F. - definingPolynomial: () -> SparseUnivariatePolynomial F - ++ definingPolynomial() returns the polynomial used to define - ++ the field extension. - extensionDegree : () -> PositiveInteger - ++ extensionDegree() returns the degree of field extension. - degree : $ -> PositiveInteger - ++ degree(a) returns the degree of the minimal polynomial of an - ++ element \spad{a} over the ground field F. - norm: $ -> F - ++ norm(a) computes the norm of \spad{a} with respect to the - ++ field considered as an algebra with 1 over the ground field F. - trace: $ -> F - ++ trace(a) computes the trace of \spad{a} with respect to - ++ the field considered as an algebra with 1 over the ground field F. - if F has Finite then - FiniteFieldCategory - minimalPolynomial: ($,PositiveInteger) -> SparseUnivariatePolynomial $ - ++ minimalPolynomial(x,n) computes the minimal polynomial of x over - ++ the field of extension degree n over the ground field F. - norm: ($,PositiveInteger) -> $ - ++ norm(a,d) computes the norm of \spad{a} with respect to the field of - ++ extension degree d over the ground field of size. - ++ Error: if d does not divide the extension degree of \spad{a}. - ++ Note: norm(a,d) = reduce(*,[a**(q**(d*i)) for i in 0..n/d]) - trace: ($,PositiveInteger) -> $ - ++ trace(a,d) computes the trace of \spad{a} with respect to the - ++ field of extension degree d over the ground field of size q. - ++ Error: if d does not divide the extension degree of \spad{a}. - ++ Note: \spad{trace(a,d) = reduce(+,[a**(q**(d*i)) for i in 0..n/d])}. - createNormalElement: () -> $ - ++ createNormalElement() computes a normal element over the ground - ++ field F, that is, - ++ \spad{a**(q**i), 0 <= i < extensionDegree()} is an F-basis, - ++ where \spad{q = size()\$F}. - ++ Reference: Such an element exists Lidl/Niederreiter: Theorem 2.35. - normalElement: () -> $ - ++ normalElement() returns a element, normal over the ground field F, - ++ i.e. \spad{a**(q**i), 0 <= i < extensionDegree()} is an F-basis, - ++ where \spad{q = size()\$F}. - ++ At the first call, the element is computed by - ++ \spadfunFrom{createNormalElement}{FiniteAlgebraicExtensionField} - ++ then cached in a global variable. - ++ On subsequent calls, the element is retrieved by referencing the - ++ global variable. - normal?: $ -> Boolean - ++ normal?(a) tests whether the element \spad{a} is normal over the - ++ ground field F, i.e. - ++ \spad{a**(q**i), 0 <= i <= extensionDegree()-1} is an F-basis, - ++ where \spad{q = size()\$F}. - ++ Implementation according to Lidl/Niederreiter: Theorem 2.39. - generator: () -> $ - ++ generator() returns a root of the defining polynomial. - ++ This element generates the field as an algebra over the ground field. - linearAssociatedExp:($,SparseUnivariatePolynomial F) -> $ - ++ linearAssociatedExp(a,f) is linear over {\em F}, i.e. - ++ for elements {\em a} from {\em \$}, {\em c,d} form {\em F} and - ++ {\em f,g} univariate polynomials over {\em F} we have - ++ \spadfun{linearAssociatedExp}(a,cf+dg) equals {\em c} times - ++ \spadfun{linearAssociatedExp}(a,f) plus {\em d} times - ++ \spadfun{linearAssociatedExp}(a,g). Therefore - ++ \spadfun{linearAssociatedExp} is defined completely by its action on - ++ monomials from {\em F[X]}: - ++ \spadfun{linearAssociatedExp}(a,monomial(1,k)\$SUP(F)) is defined to - ++ be \spadfun{Frobenius}(a,k) which is {\em a**(q**k)}, - ++ where {\em q=size()\$F}. - linearAssociatedOrder: $ -> SparseUnivariatePolynomial F - ++ linearAssociatedOrder(a) retruns the monic polynomial {\em g} of - ++ least degree, such that \spadfun{linearAssociatedExp}(a,g) is 0. - linearAssociatedLog: $ -> SparseUnivariatePolynomial F - ++ linearAssociatedLog(a) returns a polynomial {\em g}, such that - ++ \spadfun{linearAssociatedExp}(normalElement(),g) equals {\em a}. - linearAssociatedLog: ($,$) -> Union(SparseUnivariatePolynomial F,"failed") - ++ linearAssociatedLog(b,a) returns a polynomial {\em g}, such that the - ++ \spadfun{linearAssociatedExp}(b,g) equals {\em a}. - ++ If there is no such polynomial {\em g}, then - ++ \spadfun{linearAssociatedLog} fails. - add - I ==> Integer - PI ==> PositiveInteger - NNI ==> NonNegativeInteger - SUP ==> SparseUnivariatePolynomial - DLP ==> DiscreteLogarithmPackage - - represents(v) == - a:$:=0 - b:=basis() - for i in 1..extensionDegree()@PI repeat - a:=a+(v.i)*(b.i) - a - transcendenceDegree() == 0$NNI - dimension() == (#basis()) ::NonNegativeInteger::CardinalNumber - extensionDegree():OnePointCompletion(PositiveInteger) == - (#basis()) :: PositiveInteger::OnePointCompletion(PositiveInteger) - degree(a):OnePointCompletion(PositiveInteger) == - degree(a)@PI::OnePointCompletion(PositiveInteger) - - coordinates(v:Vector $) == - m := new(#v, extensionDegree(), 0)$Matrix(F) - for i in minIndex v .. maxIndex v for j in minRowIndex m .. repeat - setRow_!(m, j, coordinates qelt(v, i)) - m - algebraic? a == true - transcendent? a == false - extensionDegree() == (#basis()) :: PositiveInteger - -- degree a == degree(minimalPolynomial a)$SUP(F) :: PI - trace a == - b := basis() - abs : F := 0 - for i in 1..#b repeat - abs := abs + coordinates(a*b.i).i - abs - norm a == - b := basis() - m := new(#b,#b, 0)$Matrix(F) - for i in 1..#b repeat - setRow_!(m,i, coordinates(a*b.i)) - determinant(m) - if F has Finite then - linearAssociatedExp(x,f) == - erg:$:=0 - y:=x - for i in 0..degree(f) repeat - erg:=erg + coefficient(f,i) * y - y:=Frobenius(y) - erg - linearAssociatedLog(b,x) == - x=0 => 0 - l:List List F:=[entries coordinates b] - a:$:=b - extdeg:NNI:=extensionDegree()@PI - for i in 2..extdeg repeat - a:=Frobenius(a) - l:=concat(l,entries coordinates a)$(List List F) - l:=concat(l,entries coordinates x)$(List List F) - m1:=rowEchelon transpose matrix(l)$(Matrix F) - v:=zero(extdeg)$(Vector F) - rown:I:=1 - for i in 1..extdeg repeat - if qelt(m1,rown,i) = 1$F then - v.i:=qelt(m1,rown,extdeg+1) - rown:=rown+1 - p:=+/[monomial(v.(i+1),i::NNI) for i in 0..(#v-1)] - p=0 => - messagePrint("linearAssociatedLog: second argument not in_ - group generated by first argument")$OutputForm - "failed" - p - linearAssociatedLog(x) == linearAssociatedLog(normalElement(),x) :: - SparseUnivariatePolynomial(F) - linearAssociatedOrder(x) == - x=0 => 0 - l:List List F:=[entries coordinates x] - a:$:=x - for i in 1..extensionDegree()@PI repeat - a:=Frobenius(a) - l:=concat(l,entries coordinates a)$(List List F) - v:=first nullSpace transpose matrix(l)$(Matrix F) - +/[monomial(v.(i+1),i::NNI) for i in 0..(#v-1)] - - charthRoot(x):Union($,"failed") == - (charthRoot(x)@$)::Union($,"failed") - -- norm(e) == norm(e,1) pretend F - -- trace(e) == trace(e,1) pretend F - minimalPolynomial(a,n) == - extensionDegree()@PI rem n ^= 0 => - error "minimalPolynomial: 2. argument must divide extension degree" - f:SUP $:=monomial(1,1)$(SUP $) - monomial(a,0)$(SUP $) - u:$:=Frobenius(a,n) - while not(u = a) repeat - f:=f * (monomial(1,1)$(SUP $) - monomial(u,0)$(SUP $)) - u:=Frobenius(u,n) - f - norm(e,s) == - qr := divide(extensionDegree(), s) - zero?(qr.remainder) => - pow := (size()-1) quo (size()$F ** s - 1) - e ** (pow::NonNegativeInteger) - error "norm: second argument must divide degree of extension" - trace(e,s) == - qr:=divide(extensionDegree(),s) - q:=size()$F - zero?(qr.remainder) => - a:$:=0 - for i in 0..qr.quotient-1 repeat - a:=a + e**(q**(s*i)) - a - error "trace: second argument must divide degree of extension" - size() == size()$F ** extensionDegree() - createNormalElement() == - characteristic() = size() => 1 - res : $ - for i in 1.. repeat - res := index(i :: PI) - not inGroundField? res => - normal? res => return res - -- theorem: there exists a normal element, this theorem is - -- unknown to the compiler - res - normal?(x:$) == - p:SUP $:=(monomial(1,extensionDegree()) - monomial(1,0))@(SUP $) - f:SUP $:= +/[monomial(Frobenius(x,i),i)$(SUP $) _ - for i in 0..extensionDegree()-1] - gcd(p,f) = 1 => true - false - degree a == - y:$:=Frobenius a - deg:PI:=1 - while y^=a repeat - y := Frobenius(y) - deg:=deg+1 - deg - -@ \section{package DLP DiscreteLogarithmPackage} <>= )abbrev package DLP DiscreteLogarithmPackage @@ -382,304 +106,6 @@ DiscreteLogarithmPackage(M): public == private where disclog pretend NonNegativeInteger @ -\section{category FFIELDC FiniteFieldCategory} -<>= -)abbrev category FFIELDC FiniteFieldCategory -++ Author: J. Grabmeier, A. Scheerhorn -++ Date Created: 11 March 1991 -++ Date Last Updated: 31 March 1991 -++ Basic Operations: _+, _*, extensionDegree, order, primitiveElement -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: field, extension field, algebraic extension, finite field -++ Galois field -++ References: -++ D.Lipson, Elements of Algebra and Algebraic Computing, The -++ Benjamin/Cummings Publishing Company, Inc.-Menlo Park, California, 1981. -++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. -++ AXIOM Technical Report Series, ATR/5 NP2522. -++ Description: -++ FiniteFieldCategory is the category of finite fields - -FiniteFieldCategory() : Category ==_ - Join(FieldOfPrimeCharacteristic,Finite,StepThrough,DifferentialRing) with --- ,PolynomialFactorizationExplicit) with - charthRoot: $ -> $ - ++ charthRoot(a) takes the characteristic'th root of {\em a}. - ++ Note: such a root is alway defined in finite fields. - conditionP: Matrix $ -> Union(Vector $,"failed") - ++ conditionP(mat), given a matrix representing a homogeneous system - ++ of equations, returns a vector whose characteristic'th powers - ++ is a non-trivial solution, or "failed" if no such vector exists. - -- the reason for implementing the following function is that we - -- can implement the functions order, getGenerator and primitive? on - -- category level without computing the, may be time intensive, - -- factorization of size()-1 at every function call again. - factorsOfCyclicGroupSize:_ - () -> List Record(factor:Integer,exponent:Integer) - ++ factorsOfCyclicGroupSize() returns the factorization of size()-1 - -- the reason for implementing the function tableForDiscreteLogarithm - -- is that we can implement the functions discreteLog and - -- shanksDiscLogAlgorithm on category level - -- computing the necessary exponentiation tables in the respective - -- domains once and for all - -- absoluteDegree : $ -> PositiveInteger - -- ++ degree of minimal polynomial, if algebraic with respect - -- ++ to the prime subfield - tableForDiscreteLogarithm: Integer -> _ - Table(PositiveInteger,NonNegativeInteger) - ++ tableForDiscreteLogarithm(a,n) returns a table of the discrete - ++ logarithms of \spad{a**0} up to \spad{a**(n-1)} which, called with - ++ key \spad{lookup(a**i)} returns i for i in \spad{0..n-1}. - ++ Error: if not called for prime divisors of order of - ++ multiplicative group. - createPrimitiveElement: () -> $ - ++ createPrimitiveElement() computes a generator of the (cyclic) - ++ multiplicative group of the field. - -- RDJ: Are these next lines to be included? - -- we run through the field and test, algorithms which construct - -- elements of larger order were found to be too slow - primitiveElement: () -> $ - ++ primitiveElement() returns a primitive element stored in a global - ++ variable in the domain. - ++ At first call, the primitive element is computed - ++ by calling \spadfun{createPrimitiveElement}. - primitive?: $ -> Boolean - ++ primitive?(b) tests whether the element b is a generator of the - ++ (cyclic) multiplicative group of the field, i.e. is a primitive - ++ element. - ++ Implementation Note: see ch.IX.1.3, th.2 in D. Lipson. - discreteLog: $ -> NonNegativeInteger - ++ discreteLog(a) computes the discrete logarithm of \spad{a} - ++ with respect to \spad{primitiveElement()} of the field. - order: $ -> PositiveInteger - ++ order(b) computes the order of an element b in the multiplicative - ++ group of the field. - ++ Error: if b equals 0. - representationType: () -> Union("prime","polynomial","normal","cyclic") - ++ representationType() returns the type of the representation, one of: - ++ \spad{prime}, \spad{polynomial}, \spad{normal}, or \spad{cyclic}. - add - I ==> Integer - PI ==> PositiveInteger - NNI ==> NonNegativeInteger - SUP ==> SparseUnivariatePolynomial - DLP ==> DiscreteLogarithmPackage - - -- exported functions - - differentiate x == 0 - init() == 0 - nextItem(a) == - zero?(a:=index(lookup(a)+1)) => "failed" - a - order(e):OnePointCompletion(PositiveInteger) == - (order(e)@PI)::OnePointCompletion(PositiveInteger) - - conditionP(mat:Matrix $) == - l:=nullSpace mat - empty? l or every?(zero?, first l) => "failed" - map(charthRoot,first l) - charthRoot(x:$):$ == x**(size() quo characteristic()) - charthRoot(x:%):Union($,"failed") == - (charthRoot(x)@$)::Union($,"failed") - createPrimitiveElement() == - sm1 : PositiveInteger := (size()$$-1) pretend PositiveInteger - start : Integer := - -- in the polynomial case, index from 1 to characteristic-1 - -- gives prime field elements - representationType = "polynomial" => characteristic()::Integer - 1 - found : Boolean := false - for i in start.. while not found repeat - e : $ := index(i::PositiveInteger) - found := (order(e) = sm1) - e - primitive? a == - -- add special implementation for prime field case - zero?(a) => false - explist := factorsOfCyclicGroupSize() - q:=(size()-1)@Integer - equalone : Boolean := false - for exp in explist while not equalone repeat --- equalone := one?(a**(q quo exp.factor)) - equalone := ((a**(q quo exp.factor)) = 1) - not equalone - order e == - e = 0 => error "order(0) is not defined " - ord:Integer:= size()-1 -- order e divides ord - a:Integer:= 0 - lof:=factorsOfCyclicGroupSize() - for rec in lof repeat -- run through prime divisors - a := ord quo (primeDivisor := rec.factor) --- goon := one?(e**a) - goon := ((e**a) = 1) - -- run through exponents of the prime divisors - for j in 0..(rec.exponent)-2 while goon repeat - -- as long as we get (e**ord = 1) we - -- continue dividing by primeDivisor - ord := a - a := ord quo primeDivisor --- goon := one?(e**a) - goon := ((e**a) = 1) - if goon then ord := a - -- as we do a top down search we have found the - -- correct exponent of primeDivisor in order e - -- and continue with next prime divisor - ord pretend PositiveInteger - discreteLog(b) == - zero?(b) => error "discreteLog: logarithm of zero" - faclist:=factorsOfCyclicGroupSize() - a:=b - gen:=primitiveElement() - -- in GF(2) its necessary to have discreteLog(1) = 1 - b = gen => 1 - disclog:Integer:=0 - mult:Integer:=1 - groupord := (size() - 1)@Integer - exp:Integer:=groupord - for f in faclist repeat - fac:=f.factor - for t in 0..f.exponent-1 repeat - exp:=exp quo fac - -- shanks discrete logarithm algorithm - exptable:=tableForDiscreteLogarithm(fac) - n:=#exptable - c:=a**exp - end:=(fac - 1) quo n - found:=false - disc1:Integer:=0 - for i in 0..end while not found repeat - rho:= search(lookup(c),exptable)_ - $Table(PositiveInteger,NNI) - rho case NNI => - found := true - disc1:=((n * i + rho)@Integer) * mult - c:=c* gen**((groupord quo fac) * (-n)) - not found => error "discreteLog: ?? discrete logarithm" - -- end of shanks discrete logarithm algorithm - mult := mult * fac - disclog:=disclog+disc1 - a:=a * (gen ** (-disc1)) - disclog pretend NonNegativeInteger - - discreteLog(logbase,b) == - zero?(b) => - messagePrint("discreteLog: logarithm of zero")$OutputForm - "failed" - zero?(logbase) => - messagePrint("discreteLog: logarithm to base zero")$OutputForm - "failed" - b = logbase => 1 - not zero?((groupord:=order(logbase)@PI) rem order(b)@PI) => - messagePrint("discreteLog: second argument not in cyclic group _ -generated by first argument")$OutputForm - "failed" - faclist:=factors factor groupord - a:=b - disclog:Integer:=0 - mult:Integer:=1 - exp:Integer:= groupord - for f in faclist repeat - fac:=f.factor - primroot:= logbase ** (groupord quo fac) - for t in 0..f.exponent-1 repeat - exp:=exp quo fac - rhoHelp:= shanksDiscLogAlgorithm(primroot,_ - a**exp,fac pretend NonNegativeInteger)$DLP($) - rhoHelp case "failed" => return "failed" - rho := (rhoHelp :: NNI) * mult - disclog := disclog + rho - mult := mult * fac - a:=a * (logbase ** (-rho)) - disclog pretend NonNegativeInteger - - FP ==> SparseUnivariatePolynomial($) - FRP ==> Factored FP - f,g:FP - squareFreePolynomial(f:FP):FRP == - squareFree(f)$UnivariatePolynomialSquareFree($,FP) - factorPolynomial(f:FP):FRP == factor(f)$DistinctDegreeFactorize($,FP) - factorSquareFreePolynomial(f:FP):FRP == - f = 0 => 0 - flist := distdfact(f,true)$DistinctDegreeFactorize($,FP) - (flist.cont :: FP) * - (*/[primeFactor(u.irr,u.pow) for u in flist.factors]) - gcdPolynomial(f:FP,g:FP):FP == - gcd(f,g)$EuclideanDomain_&(FP) - -@ -\section{FFIELDC.lsp BOOTSTRAP} -{\bf FFIELDC} 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 FFIELDC} -category which we can write into the {\bf MID} directory. We compile -the lisp code and copy the {\bf FFIELDC.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 |FiniteFieldCategory;AL| (QUOTE NIL)) - -(DEFUN |FiniteFieldCategory| NIL (LET (#:G83129) (COND (|FiniteFieldCategory;AL|) (T (SETQ |FiniteFieldCategory;AL| (|FiniteFieldCategory;|)))))) - -(DEFUN |FiniteFieldCategory;| NIL (PROG (#1=#:G83127) (RETURN (PROG1 (LETT #1# (|Join| (|FieldOfPrimeCharacteristic|) (|Finite|) (|StepThrough|) (|DifferentialRing|) (|mkCategory| (QUOTE |domain|) (QUOTE (((|charthRoot| (|$| |$|)) T) ((|conditionP| ((|Union| (|Vector| |$|) "failed") (|Matrix| |$|))) T) ((|factorsOfCyclicGroupSize| ((|List| (|Record| (|:| |factor| (|Integer|)) (|:| |exponent| (|Integer|)))))) T) ((|tableForDiscreteLogarithm| ((|Table| (|PositiveInteger|) (|NonNegativeInteger|)) (|Integer|))) T) ((|createPrimitiveElement| (|$|)) T) ((|primitiveElement| (|$|)) T) ((|primitive?| ((|Boolean|) |$|)) T) ((|discreteLog| ((|NonNegativeInteger|) |$|)) T) ((|order| ((|PositiveInteger|) |$|)) T) ((|representationType| ((|Union| "prime" "polynomial" "normal" "cyclic"))) T))) NIL (QUOTE ((|PositiveInteger|) (|NonNegativeInteger|) (|Boolean|) (|Table| (|PositiveInteger|) (|NonNegativeInteger|)) (|Integer|) (|List| (|Record| (|:| |factor| (|Integer|)) (|:| |exponent| (|Integer|)))) (|Matrix| |$|))) NIL)) |FiniteFieldCategory|) (SETELT #1# 0 (QUOTE (|FiniteFieldCategory|))))))) - -(MAKEPROP (QUOTE |FiniteFieldCategory|) (QUOTE NILADIC) T) -@ -\section{FFIELDC-.lsp BOOTSTRAP} -{\bf FFIELDC-} depends on {\bf FFIELDC}. We need to break this cycle to build -the algebra. So we keep a cached copy of the translated {\bf FFIELDC-} -category which we can write into the {\bf MID} directory. We compile -the lisp code and copy the {\bf FFIELDC-.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 |FFIELDC-;differentiate;2S;1| (|x| |$|) (|spadConstant| |$| 7)) - -(DEFUN |FFIELDC-;init;S;2| (|$|) (|spadConstant| |$| 7)) - -(DEFUN |FFIELDC-;nextItem;SU;3| (|a| |$|) (COND ((SPADCALL (LETT |a| (SPADCALL (|+| (SPADCALL |a| (QREFELT |$| 11)) 1) (QREFELT |$| 12)) |FFIELDC-;nextItem;SU;3|) (QREFELT |$| 14)) (CONS 1 "failed")) ((QUOTE T) (CONS 0 |a|)))) - -(DEFUN |FFIELDC-;order;SOpc;4| (|e| |$|) (SPADCALL (SPADCALL |e| (QREFELT |$| 17)) (QREFELT |$| 20))) - -(DEFUN |FFIELDC-;conditionP;MU;5| (|mat| |$|) (PROG (|l|) (RETURN (SEQ (LETT |l| (SPADCALL |mat| (QREFELT |$| 24)) |FFIELDC-;conditionP;MU;5|) (COND ((OR (NULL |l|) (SPADCALL (ELT |$| 14) (|SPADfirst| |l|) (QREFELT |$| 27))) (EXIT (CONS 1 "failed")))) (EXIT (CONS 0 (SPADCALL (ELT |$| 28) (|SPADfirst| |l|) (QREFELT |$| 30)))))))) - -(DEFUN |FFIELDC-;charthRoot;2S;6| (|x| |$|) (SPADCALL |x| (QUOTIENT2 (SPADCALL (QREFELT |$| 35)) (SPADCALL (QREFELT |$| 36))) (QREFELT |$| 37))) - -(DEFUN |FFIELDC-;charthRoot;SU;7| (|x| |$|) (CONS 0 (SPADCALL |x| (QREFELT |$| 28)))) - -(DEFUN |FFIELDC-;createPrimitiveElement;S;8| (|$|) (PROG (|sm1| |start| |i| #1=#:G83175 |e| |found|) (RETURN (SEQ (LETT |sm1| (|-| (SPADCALL (QREFELT |$| 35)) 1) |FFIELDC-;createPrimitiveElement;S;8|) (LETT |start| (COND ((SPADCALL (SPADCALL (QREFELT |$| 42)) (CONS 1 "polynomial") (QREFELT |$| 43)) (SPADCALL (QREFELT |$| 36))) ((QUOTE T) 1)) |FFIELDC-;createPrimitiveElement;S;8|) (LETT |found| (QUOTE NIL) |FFIELDC-;createPrimitiveElement;S;8|) (SEQ (LETT |i| |start| |FFIELDC-;createPrimitiveElement;S;8|) G190 (COND ((NULL (COND (|found| (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |e| (SPADCALL (PROG1 (LETT #1# |i| |FFIELDC-;createPrimitiveElement;S;8|) (|check-subtype| (|>| #1# 0) (QUOTE (|PositiveInteger|)) #1#)) (QREFELT |$| 12)) |FFIELDC-;createPrimitiveElement;S;8|) (EXIT (LETT |found| (EQL (SPADCALL |e| (QREFELT |$| 17)) |sm1|) |FFIELDC-;createPrimitiveElement;S;8|))) (LETT |i| (|+| |i| 1) |FFIELDC-;createPrimitiveElement;S;8|) (GO G190) G191 (EXIT NIL)) (EXIT |e|))))) - -(DEFUN |FFIELDC-;primitive?;SB;9| (|a| |$|) (PROG (|explist| |q| |exp| #1=#:G83187 |equalone|) (RETURN (SEQ (COND ((SPADCALL |a| (QREFELT |$| 14)) (QUOTE NIL)) ((QUOTE T) (SEQ (LETT |explist| (SPADCALL (QREFELT |$| 47)) |FFIELDC-;primitive?;SB;9|) (LETT |q| (|-| (SPADCALL (QREFELT |$| 35)) 1) |FFIELDC-;primitive?;SB;9|) (LETT |equalone| (QUOTE NIL) |FFIELDC-;primitive?;SB;9|) (SEQ (LETT |exp| NIL |FFIELDC-;primitive?;SB;9|) (LETT #1# |explist| |FFIELDC-;primitive?;SB;9|) G190 (COND ((OR (ATOM #1#) (PROGN (LETT |exp| (CAR #1#) |FFIELDC-;primitive?;SB;9|) NIL) (NULL (COND (|equalone| (QUOTE NIL)) ((QUOTE T) (QUOTE T))))) (GO G191))) (SEQ (EXIT (LETT |equalone| (SPADCALL (SPADCALL |a| (QUOTIENT2 |q| (QCAR |exp|)) (QREFELT |$| 48)) (QREFELT |$| 49)) |FFIELDC-;primitive?;SB;9|))) (LETT #1# (CDR #1#) |FFIELDC-;primitive?;SB;9|) (GO G190) G191 (EXIT NIL)) (EXIT (COND (|equalone| (QUOTE NIL)) ((QUOTE T) (QUOTE T))))))))))) - -(DEFUN |FFIELDC-;order;SPi;10| (|e| |$|) (PROG (|lof| |rec| #1=#:G83195 |primeDivisor| |j| #2=#:G83196 |a| |goon| |ord|) (RETURN (SEQ (COND ((SPADCALL |e| (|spadConstant| |$| 7) (QREFELT |$| 51)) (|error| "order(0) is not defined ")) ((QUOTE T) (SEQ (LETT |ord| (|-| (SPADCALL (QREFELT |$| 35)) 1) |FFIELDC-;order;SPi;10|) (LETT |a| 0 |FFIELDC-;order;SPi;10|) (LETT |lof| (SPADCALL (QREFELT |$| 47)) |FFIELDC-;order;SPi;10|) (SEQ (LETT |rec| NIL |FFIELDC-;order;SPi;10|) (LETT #1# |lof| |FFIELDC-;order;SPi;10|) G190 (COND ((OR (ATOM #1#) (PROGN (LETT |rec| (CAR #1#) |FFIELDC-;order;SPi;10|) NIL)) (GO G191))) (SEQ (LETT |a| (QUOTIENT2 |ord| (LETT |primeDivisor| (QCAR |rec|) |FFIELDC-;order;SPi;10|)) |FFIELDC-;order;SPi;10|) (LETT |goon| (SPADCALL (SPADCALL |e| |a| (QREFELT |$| 48)) (QREFELT |$| 49)) |FFIELDC-;order;SPi;10|) (SEQ (LETT |j| 0 |FFIELDC-;order;SPi;10|) (LETT #2# (|-| (QCDR |rec|) 2) |FFIELDC-;order;SPi;10|) G190 (COND ((OR (QSGREATERP |j| #2#) (NULL |goon|)) (GO G191))) (SEQ (LETT |ord| |a| |FFIELDC-;order;SPi;10|) (LETT |a| (QUOTIENT2 |ord| |primeDivisor|) |FFIELDC-;order;SPi;10|) (EXIT (LETT |goon| (SPADCALL (SPADCALL |e| |a| (QREFELT |$| 48)) (QREFELT |$| 49)) |FFIELDC-;order;SPi;10|))) (LETT |j| (QSADD1 |j|) |FFIELDC-;order;SPi;10|) (GO G190) G191 (EXIT NIL)) (EXIT (COND (|goon| (LETT |ord| |a| |FFIELDC-;order;SPi;10|))))) (LETT #1# (CDR #1#) |FFIELDC-;order;SPi;10|) (GO G190) G191 (EXIT NIL)) (EXIT |ord|)))))))) - -(DEFUN |FFIELDC-;discreteLog;SNni;11| (|b| |$|) (PROG (|faclist| |gen| |groupord| |f| #1=#:G83216 |fac| |t| #2=#:G83217 |exp| |exptable| |n| |end| |i| |rho| |found| |disc1| |c| |mult| |disclog| |a|) (RETURN (SEQ (COND ((SPADCALL |b| (QREFELT |$| 14)) (|error| "discreteLog: logarithm of zero")) ((QUOTE T) (SEQ (LETT |faclist| (SPADCALL (QREFELT |$| 47)) |FFIELDC-;discreteLog;SNni;11|) (LETT |a| |b| |FFIELDC-;discreteLog;SNni;11|) (LETT |gen| (SPADCALL (QREFELT |$| 53)) |FFIELDC-;discreteLog;SNni;11|) (EXIT (COND ((SPADCALL |b| |gen| (QREFELT |$| 51)) 1) ((QUOTE T) (SEQ (LETT |disclog| 0 |FFIELDC-;discreteLog;SNni;11|) (LETT |mult| 1 |FFIELDC-;discreteLog;SNni;11|) (LETT |groupord| (|-| (SPADCALL (QREFELT |$| 35)) 1) |FFIELDC-;discreteLog;SNni;11|) (LETT |exp| |groupord| |FFIELDC-;discreteLog;SNni;11|) (SEQ (LETT |f| NIL |FFIELDC-;discreteLog;SNni;11|) (LETT #1# |faclist| |FFIELDC-;discreteLog;SNni;11|) G190 (COND ((OR (ATOM #1#) (PROGN (LETT |f| (CAR #1#) |FFIELDC-;discreteLog;SNni;11|) NIL)) (GO G191))) (SEQ (LETT |fac| (QCAR |f|) |FFIELDC-;discreteLog;SNni;11|) (EXIT (SEQ (LETT |t| 0 |FFIELDC-;discreteLog;SNni;11|) (LETT #2# (|-| (QCDR |f|) 1) |FFIELDC-;discreteLog;SNni;11|) G190 (COND ((QSGREATERP |t| #2#) (GO G191))) (SEQ (LETT |exp| (QUOTIENT2 |exp| |fac|) |FFIELDC-;discreteLog;SNni;11|) (LETT |exptable| (SPADCALL |fac| (QREFELT |$| 55)) |FFIELDC-;discreteLog;SNni;11|) (LETT |n| (SPADCALL |exptable| (QREFELT |$| 56)) |FFIELDC-;discreteLog;SNni;11|) (LETT |c| (SPADCALL |a| |exp| (QREFELT |$| 48)) |FFIELDC-;discreteLog;SNni;11|) (LETT |end| (QUOTIENT2 (|-| |fac| 1) |n|) |FFIELDC-;discreteLog;SNni;11|) (LETT |found| (QUOTE NIL) |FFIELDC-;discreteLog;SNni;11|) (LETT |disc1| 0 |FFIELDC-;discreteLog;SNni;11|) (SEQ (LETT |i| 0 |FFIELDC-;discreteLog;SNni;11|) G190 (COND ((OR (QSGREATERP |i| |end|) (NULL (COND (|found| (QUOTE NIL)) ((QUOTE T) (QUOTE T))))) (GO G191))) (SEQ (LETT |rho| (SPADCALL (SPADCALL |c| (QREFELT |$| 11)) |exptable| (QREFELT |$| 58)) |FFIELDC-;discreteLog;SNni;11|) (EXIT (COND ((QEQCAR |rho| 0) (SEQ (LETT |found| (QUOTE T) |FFIELDC-;discreteLog;SNni;11|) (EXIT (LETT |disc1| (|*| (|+| (|*| |n| |i|) (QCDR |rho|)) |mult|) |FFIELDC-;discreteLog;SNni;11|)))) ((QUOTE T) (LETT |c| (SPADCALL |c| (SPADCALL |gen| (|*| (QUOTIENT2 |groupord| |fac|) (|-| |n|)) (QREFELT |$| 48)) (QREFELT |$| 59)) |FFIELDC-;discreteLog;SNni;11|))))) (LETT |i| (QSADD1 |i|) |FFIELDC-;discreteLog;SNni;11|) (GO G190) G191 (EXIT NIL)) (EXIT (COND (|found| (SEQ (LETT |mult| (|*| |mult| |fac|) |FFIELDC-;discreteLog;SNni;11|) (LETT |disclog| (|+| |disclog| |disc1|) |FFIELDC-;discreteLog;SNni;11|) (EXIT (LETT |a| (SPADCALL |a| (SPADCALL |gen| (|-| |disc1|) (QREFELT |$| 48)) (QREFELT |$| 59)) |FFIELDC-;discreteLog;SNni;11|)))) ((QUOTE T) (|error| "discreteLog: ?? discrete logarithm"))))) (LETT |t| (QSADD1 |t|) |FFIELDC-;discreteLog;SNni;11|) (GO G190) G191 (EXIT NIL)))) (LETT #1# (CDR #1#) |FFIELDC-;discreteLog;SNni;11|) (GO G190) G191 (EXIT NIL)) (EXIT |disclog|)))))))))))) - -(DEFUN |FFIELDC-;discreteLog;2SU;12| (|logbase| |b| |$|) (PROG (|groupord| |faclist| |f| #1=#:G83235 |fac| |primroot| |t| #2=#:G83236 |exp| |rhoHelp| #3=#:G83234 |rho| |disclog| |mult| |a|) (RETURN (SEQ (EXIT (COND ((SPADCALL |b| (QREFELT |$| 14)) (SEQ (SPADCALL "discreteLog: logarithm of zero" (QREFELT |$| 64)) (EXIT (CONS 1 "failed")))) ((SPADCALL |logbase| (QREFELT |$| 14)) (SEQ (SPADCALL "discreteLog: logarithm to base zero" (QREFELT |$| 64)) (EXIT (CONS 1 "failed")))) ((SPADCALL |b| |logbase| (QREFELT |$| 51)) (CONS 0 1)) ((QUOTE T) (COND ((NULL (ZEROP (REMAINDER2 (LETT |groupord| (SPADCALL |logbase| (QREFELT |$| 17)) |FFIELDC-;discreteLog;2SU;12|) (SPADCALL |b| (QREFELT |$| 17))))) (SEQ (SPADCALL "discreteLog: second argument not in cyclic group generated by first argument" (QREFELT |$| 64)) (EXIT (CONS 1 "failed")))) ((QUOTE T) (SEQ (LETT |faclist| (SPADCALL (SPADCALL |groupord| (QREFELT |$| 66)) (QREFELT |$| 68)) |FFIELDC-;discreteLog;2SU;12|) (LETT |a| |b| |FFIELDC-;discreteLog;2SU;12|) (LETT |disclog| 0 |FFIELDC-;discreteLog;2SU;12|) (LETT |mult| 1 |FFIELDC-;discreteLog;2SU;12|) (LETT |exp| |groupord| |FFIELDC-;discreteLog;2SU;12|) (SEQ (LETT |f| NIL |FFIELDC-;discreteLog;2SU;12|) (LETT #1# |faclist| |FFIELDC-;discreteLog;2SU;12|) G190 (COND ((OR (ATOM #1#) (PROGN (LETT |f| (CAR #1#) |FFIELDC-;discreteLog;2SU;12|) NIL)) (GO G191))) (SEQ (LETT |fac| (QCAR |f|) |FFIELDC-;discreteLog;2SU;12|) (LETT |primroot| (SPADCALL |logbase| (QUOTIENT2 |groupord| |fac|) (QREFELT |$| 48)) |FFIELDC-;discreteLog;2SU;12|) (EXIT (SEQ (LETT |t| 0 |FFIELDC-;discreteLog;2SU;12|) (LETT #2# (|-| (QCDR |f|) 1) |FFIELDC-;discreteLog;2SU;12|) G190 (COND ((QSGREATERP |t| #2#) (GO G191))) (SEQ (LETT |exp| (QUOTIENT2 |exp| |fac|) |FFIELDC-;discreteLog;2SU;12|) (LETT |rhoHelp| (SPADCALL |primroot| (SPADCALL |a| |exp| (QREFELT |$| 48)) |fac| (QREFELT |$| 70)) |FFIELDC-;discreteLog;2SU;12|) (EXIT (COND ((QEQCAR |rhoHelp| 1) (PROGN (LETT #3# (CONS 1 "failed") |FFIELDC-;discreteLog;2SU;12|) (GO #3#))) ((QUOTE T) (SEQ (LETT |rho| (|*| (QCDR |rhoHelp|) |mult|) |FFIELDC-;discreteLog;2SU;12|) (LETT |disclog| (|+| |disclog| |rho|) |FFIELDC-;discreteLog;2SU;12|) (LETT |mult| (|*| |mult| |fac|) |FFIELDC-;discreteLog;2SU;12|) (EXIT (LETT |a| (SPADCALL |a| (SPADCALL |logbase| (|-| |rho|) (QREFELT |$| 48)) (QREFELT |$| 59)) |FFIELDC-;discreteLog;2SU;12|))))))) (LETT |t| (QSADD1 |t|) |FFIELDC-;discreteLog;2SU;12|) (GO G190) G191 (EXIT NIL)))) (LETT #1# (CDR #1#) |FFIELDC-;discreteLog;2SU;12|) (GO G190) G191 (EXIT NIL)) (EXIT (CONS 0 |disclog|)))))))) #3# (EXIT #3#))))) - -(DEFUN |FFIELDC-;squareFreePolynomial| (|f| |$|) (SPADCALL |f| (QREFELT |$| 75))) - -(DEFUN |FFIELDC-;factorPolynomial| (|f| |$|) (SPADCALL |f| (QREFELT |$| 77))) - -(DEFUN |FFIELDC-;factorSquareFreePolynomial| (|f| |$|) (PROG (|flist| |u| #1=#:G83248 #2=#:G83245 #3=#:G83243 #4=#:G83244) (RETURN (SEQ (COND ((SPADCALL |f| (|spadConstant| |$| 78) (QREFELT |$| 79)) (|spadConstant| |$| 80)) ((QUOTE T) (SEQ (LETT |flist| (SPADCALL |f| (QUOTE T) (QREFELT |$| 83)) |FFIELDC-;factorSquareFreePolynomial|) (EXIT (SPADCALL (SPADCALL (QCAR |flist|) (QREFELT |$| 84)) (PROGN (LETT #4# NIL |FFIELDC-;factorSquareFreePolynomial|) (SEQ (LETT |u| NIL |FFIELDC-;factorSquareFreePolynomial|) (LETT #1# (QCDR |flist|) |FFIELDC-;factorSquareFreePolynomial|) G190 (COND ((OR (ATOM #1#) (PROGN (LETT |u| (CAR #1#) |FFIELDC-;factorSquareFreePolynomial|) NIL)) (GO G191))) (SEQ (EXIT (PROGN (LETT #2# (SPADCALL (QCAR |u|) (QCDR |u|) (QREFELT |$| 85)) |FFIELDC-;factorSquareFreePolynomial|) (COND (#4# (LETT #3# (SPADCALL #3# #2# (QREFELT |$| 86)) |FFIELDC-;factorSquareFreePolynomial|)) ((QUOTE T) (PROGN (LETT #3# #2# |FFIELDC-;factorSquareFreePolynomial|) (LETT #4# (QUOTE T) |FFIELDC-;factorSquareFreePolynomial|))))))) (LETT #1# (CDR #1#) |FFIELDC-;factorSquareFreePolynomial|) (GO G190) G191 (EXIT NIL)) (COND (#4# #3#) ((QUOTE T) (|spadConstant| |$| 87)))) (QREFELT |$| 88)))))))))) - -(DEFUN |FFIELDC-;gcdPolynomial;3Sup;16| (|f| |g| |$|) (SPADCALL |f| |g| (QREFELT |$| 90))) - -(DEFUN |FiniteFieldCategory&| (|#1|) (PROG (|DV$1| |dv$| |$| |pv$|) (RETURN (PROGN (LETT |DV$1| (|devaluate| |#1|) . #1=(|FiniteFieldCategory&|)) (LETT |dv$| (LIST (QUOTE |FiniteFieldCategory&|) |DV$1|) . #1#) (LETT |$| (GETREFV 93) . #1#) (QSETREFV |$| 0 |dv$|) (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#)) (|stuffDomainSlots| |$|) (QSETREFV |$| 6 |#1|) |$|)))) - -(MAKEPROP (QUOTE |FiniteFieldCategory&|) (QUOTE |infovec|) (LIST (QUOTE #(NIL NIL NIL NIL NIL NIL (|local| |#1|) (0 . |Zero|) |FFIELDC-;differentiate;2S;1| |FFIELDC-;init;S;2| (|PositiveInteger|) (4 . |lookup|) (9 . |index|) (|Boolean|) (14 . |zero?|) (|Union| |$| (QUOTE "failed")) |FFIELDC-;nextItem;SU;3| (19 . |order|) (|Integer|) (|OnePointCompletion| 10) (24 . |coerce|) |FFIELDC-;order;SOpc;4| (|List| 26) (|Matrix| 6) (29 . |nullSpace|) (|Mapping| 13 6) (|Vector| 6) (34 . |every?|) (40 . |charthRoot|) (|Mapping| 6 6) (45 . |map|) (|Union| (|Vector| |$|) (QUOTE "failed")) (|Matrix| |$|) |FFIELDC-;conditionP;MU;5| (|NonNegativeInteger|) (51 . |size|) (55 . |characteristic|) (59 . |**|) |FFIELDC-;charthRoot;2S;6| |FFIELDC-;charthRoot;SU;7| (65 . |One|) (|Union| (QUOTE "prime") (QUOTE "polynomial") (QUOTE "normal") (QUOTE "cyclic")) (69 . |representationType|) (73 . |=|) |FFIELDC-;createPrimitiveElement;S;8| (|Record| (|:| |factor| 18) (|:| |exponent| 18)) (|List| 45) (79 . |factorsOfCyclicGroupSize|) (83 . |**|) (89 . |one?|) |FFIELDC-;primitive?;SB;9| (94 . |=|) |FFIELDC-;order;SPi;10| (100 . |primitiveElement|) (|Table| 10 34) (104 . |tableForDiscreteLogarithm|) (109 . |#|) (|Union| 34 (QUOTE "failed")) (114 . |search|) (120 . |*|) |FFIELDC-;discreteLog;SNni;11| (|Void|) (|String|) (|OutputForm|) (126 . |messagePrint|) (|Factored| |$|) (131 . |factor|) (|Factored| 18) (136 . |factors|) (|DiscreteLogarithmPackage| 6) (141 . |shanksDiscLogAlgorithm|) |FFIELDC-;discreteLog;2SU;12| (|Factored| 73) (|SparseUnivariatePolynomial| 6) (|UnivariatePolynomialSquareFree| 6 73) (148 . |squareFree|) (|DistinctDegreeFactorize| 6 73) (153 . |factor|) (158 . |Zero|) (162 . |=|) (168 . |Zero|) (|Record| (|:| |irr| 73) (|:| |pow| 18)) (|Record| (|:| |cont| 6) (|:| |factors| (|List| 81))) (172 . |distdfact|) (178 . |coerce|) (183 . |primeFactor|) (189 . |*|) (195 . |One|) (199 . |*|) (|EuclideanDomain&| 73) (205 . |gcd|) (|SparseUnivariatePolynomial| |$|) |FFIELDC-;gcdPolynomial;3Sup;16|)) (QUOTE #(|primitive?| 211 |order| 216 |nextItem| 226 |init| 231 |gcdPolynomial| 235 |discreteLog| 241 |differentiate| 252 |createPrimitiveElement| 257 |conditionP| 261 |charthRoot| 266)) (QUOTE NIL) (CONS (|makeByteWordVec2| 1 (QUOTE NIL)) (CONS (QUOTE #()) (CONS (QUOTE #()) (|makeByteWordVec2| 92 (QUOTE (0 6 0 7 1 6 10 0 11 1 6 0 10 12 1 6 13 0 14 1 6 10 0 17 1 19 0 18 20 1 23 22 0 24 2 26 13 25 0 27 1 6 0 0 28 2 26 0 29 0 30 0 6 34 35 0 6 34 36 2 6 0 0 34 37 0 6 0 40 0 6 41 42 2 41 13 0 0 43 0 6 46 47 2 6 0 0 18 48 1 6 13 0 49 2 6 13 0 0 51 0 6 0 53 1 6 54 18 55 1 54 34 0 56 2 54 57 10 0 58 2 6 0 0 0 59 1 63 61 62 64 1 18 65 0 66 1 67 46 0 68 3 69 57 6 6 34 70 1 74 72 73 75 1 76 72 73 77 0 73 0 78 2 73 13 0 0 79 0 72 0 80 2 76 82 73 13 83 1 73 0 6 84 2 72 0 73 18 85 2 72 0 0 0 86 0 72 0 87 2 72 0 73 0 88 2 89 0 0 0 90 1 0 13 0 50 1 0 10 0 52 1 0 19 0 21 1 0 15 0 16 0 0 0 9 2 0 91 91 91 92 1 0 34 0 60 2 0 57 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{package FFSLPE FiniteFieldSolveLinearPolynomialEquation} <>= )abbrev package FFSLPE FiniteFieldSolveLinearPolynomialEquation @@ -767,8 +193,6 @@ FiniteFieldSolveLinearPolynomialEquation(F:FiniteFieldCategory, <> <> -<> -<> <> @ \eject diff --git a/src/algebra/files.spad.pamphlet b/src/algebra/files.spad.pamphlet index e13ed79..f896b96 100644 --- a/src/algebra/files.spad.pamphlet +++ b/src/algebra/files.spad.pamphlet @@ -9,64 +9,6 @@ \eject \tableofcontents \eject -\section{category FILECAT FileCategory} -<>= -)abbrev category FILECAT FileCategory -++ Author: Stephen M. Watt, Victor Miller -++ Date Created: -++ Date Last Updated: June 4, 1991 -++ Basic Operations: -++ Related Domains: File -++ Also See: -++ AMS Classifications: -++ Keywords: -++ Examples: -++ References: -++ Description: -++ This category provides an interface to operate on files in the -++ computer's file system. The precise method of naming files -++ is determined by the Name parameter. The type of the contents -++ of the file is determined by S. - -FileCategory(Name, S): Category == FCdefinition where - Name: SetCategory - S: SetCategory - IOMode ==> String -- Union("input", "output", "closed") - - FCdefinition == SetCategory with - open: Name -> % - ++ open(s) returns the file s open for input. - - open: (Name, IOMode) -> % - ++ open(s,mode) returns a file s open for operation in the - ++ indicated mode: "input" or "output". - - reopen_!: (%, IOMode) -> % - ++ reopen!(f,mode) returns a file f reopened for operation in the - ++ indicated mode: "input" or "output". - ++ \spad{reopen!(f,"input")} will reopen the file f for input. - - close_!: % -> % - ++ close!(f) returns the file f closed to input and output. - - name: % -> Name - ++ name(f) returns the external name of the file f. - - iomode: % -> IOMode - ++ iomode(f) returns the status of the file f. The input/output - ++ status of f may be "input", "output" or "closed" mode. - - read_!: % -> S - ++ read!(f) extracts a value from file f. The state of f is - ++ modified so a subsequent call to \spadfun{read!} will return - ++ the next element. - - write_!: (%,S) -> S - ++ write!(f,s) puts the value s into the file f. - ++ The state of f is modified so subsequents call to \spad{write!} - ++ will append one after another. - -@ \section{domain FILE File} <>= -- files.spad.pamphlet File.input @@ -1106,7 +1048,6 @@ Library(): TableAggregate(String, Any) with <<*>>= <> -<> <> <> <> diff --git a/src/algebra/fname.spad.pamphlet b/src/algebra/fname.spad.pamphlet index 4c44625..8468638 100644 --- a/src/algebra/fname.spad.pamphlet +++ b/src/algebra/fname.spad.pamphlet @@ -9,62 +9,6 @@ \eject \tableofcontents \eject -\section{category FNCAT FileNameCategory} -<>= -)abbrev category FNCAT FileNameCategory -++ Author: Stephen M. Watt -++ Date Created: 1985 -++ Date Last Updated: June 20, 1991 -++ Basic Operations: -++ Related Domains: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ Examples: -++ References: -++ Description: -++ This category provides an interface to names in the file system. - -FileNameCategory(): Category == SetCategory with - - coerce: String -> % - ++ coerce(s) converts a string to a file name - ++ according to operating system-dependent conventions. - coerce: % -> String - ++ coerce(fn) produces a string for a file name - ++ according to operating system-dependent conventions. - - filename: (String, String, String) -> % - ++ filename(d,n,e) creates a file name with - ++ d as its directory, n as its name and e as its extension. - ++ This is a portable way to create file names. - ++ When d or t is the empty string, a default is used. - - directory: % -> String - ++ directory(f) returns the directory part of the file name. - name: % -> String - ++ name(f) returns the name part of the file name. - extension: % -> String - ++ extension(f) returns the type part of the file name. - - exists?: % -> Boolean - ++ exists?(f) tests if the file exists in the file system. - readable?: % -> Boolean - ++ readable?(f) tests if the named file exist and can it be opened - ++ for reading. - writable?: % -> Boolean - ++ writable?(f) tests if the named file be opened for writing. - ++ The named file need not already exist. - - new: (String, String, String) -> % - ++ new(d,pref,e) constructs the name of a new writable file with - ++ d as its directory, pref as a prefix of its name and - ++ e as its extension. - ++ When d or t is the empty string, a default is used. - ++ An error occurs if a new file cannot be written in the given - ++ directory. - -@ \section{domain FNAME FileName} <>= -- fname.spad.pamphlet FileName.input @@ -417,7 +361,6 @@ FileName(): FileNameCategory == add <<*>>= <> -<> <> @ \eject diff --git a/src/algebra/omcat.spad.pamphlet b/src/algebra/omcat.spad.pamphlet deleted file mode 100644 index ca6b74f..0000000 --- a/src/algebra/omcat.spad.pamphlet +++ /dev/null @@ -1,89 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/algebra omcat.spad} -\author{Mike Dewar, Vilya Harvey} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -\section{category OM OpenMath} -<>= -"OM" -> "CATEGORY" -"OpenMath()" -> "Category" -@ -<>= -)abbrev category OM OpenMath -++ Author: Mike Dewar & Vilya Harvey -++ Basic Functions: OMwrite -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ References: -++ Description: -++ \spadtype{OpenMath} provides operations for exporting an object -++ in OpenMath format. - -OpenMath(): Category == with - OMwrite : % -> String - ++ OMwrite(u) returns the OpenMath XML encoding of \axiom{u} as a - ++ complete OpenMath object. - OMwrite : (%, Boolean) -> String - ++ OMwrite(u, true) returns the OpenMath XML encoding of \axiom{u} - ++ as a complete OpenMath object; OMwrite(u, false) returns the - ++ OpenMath XML encoding of \axiom{u} as an OpenMath fragment. - OMwrite : (OpenMathDevice, %) -> Void - ++ OMwrite(dev, u) writes the OpenMath form of \axiom{u} to the - ++ OpenMath device \axiom{dev} as a complete OpenMath object. - OMwrite : (OpenMathDevice, %, Boolean) -> Void - ++ OMwrite(dev, u, true) writes the OpenMath form of \axiom{u} to - ++ the OpenMath device \axiom{dev} as a complete OpenMath object; - ++ OMwrite(dev, u, false) writes the object as an OpenMath fragment. - -@ -\section{License} -<>= ---Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. ---All rights reserved. --- ---Redistribution and use in source and binary forms, with or without ---modification, are permitted provided that the following conditions are ---met: --- --- - Redistributions of source code must retain the above copyright --- notice, this list of conditions and the following disclaimer. --- --- - Redistributions in binary form must reproduce the above copyright --- notice, this list of conditions and the following disclaimer in --- the documentation and/or other materials provided with the --- distribution. --- --- - Neither the name of The Numerical ALgorithms Group Ltd. nor the --- names of its contributors may be used to endorse or promote products --- derived from this software without specific prior written permission. --- ---THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS ---IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED ---TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A ---PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER ---OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, ---EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, ---PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR ---PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF ---LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING ---NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS ---SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -@ -<<*>>= -<> - -<> -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/algebra/patmatch1.spad.pamphlet b/src/algebra/patmatch1.spad.pamphlet index 1225137..5d4f0ca 100644 --- a/src/algebra/patmatch1.spad.pamphlet +++ b/src/algebra/patmatch1.spad.pamphlet @@ -199,54 +199,6 @@ PatternMatchListResult(R:SetCategory, S:SetCategory, L:ListAggregate S): RecordPrint(r, Rep)$Lisp @ -\section{category PATMAB PatternMatchable} -<>= -"PATMAB" -> "SETCAT" -"PatternMatchable(a:SetCategory)" -> "SetCategory()" -"PatternMatchable(Integer)" -> "PatternMatchable(a:SetCategory)" -"PatternMatchable(Float)" -> "PatternMatchable(a:SetCategory)" -@ -<>= -)abbrev category PATMAB PatternMatchable -++ Category of sets that can be pattern-matched on -++ Author: Manuel Bronstein -++ Date Created: 28 Nov 1989 -++ Date Last Updated: 15 Mar 1990 -++ Description: -++ A set R is PatternMatchable over S if elements of R can -++ be matched to patterns over S. -++ Keywords: pattern, matching. -PatternMatchable(S:SetCategory): Category == SetCategory with - patternMatch: (%, Pattern S, PatternMatchResult(S, %)) -> - PatternMatchResult(S, %) - ++ patternMatch(expr, pat, res) matches the pattern pat to the - ++ expression expr. res contains the variables of pat which - ++ are already matched and their matches (necessary for recursion). - ++ Initially, res is just the result of \spadfun{new} - ++ which is an empty list of matches. - -@ -\section{category FPATMAB FullyPatternMatchable} -<>= -"FPATMAB" -> "TYPE" -"FullyPatternMatchable(a:Type)" -> "Type()" -@ -<>= -)abbrev category FPATMAB FullyPatternMatchable -++ Category of sets that can be pattern-matched on -++ Author: Manuel Bronstein -++ Date Created: 28 Nov 1989 -++ Date Last Updated: 29 Nov 1989 -++ Description: -++ A set S is PatternMatchable over R if S can lift the -++ pattern-matching functions of S over the integers and float -++ to itself (necessary for matching in towers). -++ Keywords: pattern, matching. -FullyPatternMatchable(R:Type): Category == Type with - if R has PatternMatchable Integer then PatternMatchable Integer - if R has PatternMatchable Float then PatternMatchable Float - -@ \section{package PMSYM PatternMatchSymbol} <>= "PMSYM" -> "PACKAGE" @@ -743,8 +695,6 @@ PatternMatchListAggregate(S, R, L): Exports == Implementation where <> <> <> -<> -<> <> <> <> diff --git a/src/algebra/pattern.spad.pamphlet b/src/algebra/pattern.spad.pamphlet index 4d3d0a2..751e4dd 100644 --- a/src/algebra/pattern.spad.pamphlet +++ b/src/algebra/pattern.spad.pamphlet @@ -502,29 +502,6 @@ PatternFunctions2(R:SetCategory, S:SetCategory): with setPredicates(sy::Pattern(S), copy predicates p) @ -\section{category PATAB Patternable} -<>= -"PATAB" -> "CATEGORY" -"Patternable(a:Type)" -> "Category" -@ -<>= -)abbrev category PATAB Patternable -++ Category of sets that can be converted to useful patterns -++ Author: Manuel Bronstein -++ Date Created: 29 Nov 1989 -++ Date Last Updated: 29 Nov 1989 -++ Description: -++ An object S is Patternable over an object R if S can -++ lift the conversions from R into \spadtype{Pattern(Integer)} and -++ \spadtype{Pattern(Float)} to itself; -++ Keywords: pattern, matching. -Patternable(R:Type): Category == with - if R has ConvertibleTo Pattern Integer then - ConvertibleTo Pattern Integer - if R has ConvertibleTo Pattern Float then - ConvertibleTo Pattern Float - -@ \section{License} <>= --Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. @@ -564,7 +541,6 @@ Patternable(R:Type): Category == with <> <> <> -<> @ \eject \begin{thebibliography}{99} diff --git a/src/algebra/polycat.spad.pamphlet b/src/algebra/polycat.spad.pamphlet index d1e38b7..7645806 100644 --- a/src/algebra/polycat.spad.pamphlet +++ b/src/algebra/polycat.spad.pamphlet @@ -9,185 +9,6 @@ \eject \tableofcontents \eject -\section{category AMR AbelianMonoidRing} -<>= -)abbrev category AMR AbelianMonoidRing -++ Author: -++ Date Created: -++ Date Last Updated: -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ References: -++ Description: -++ Abelian monoid ring elements (not necessarily of finite support) -++ of this ring are of the form formal SUM (r_i * e_i) -++ where the r_i are coefficents and the e_i, elements of the -++ ordered abelian monoid, are thought of as exponents or monomials. -++ The monomials commute with each other, and with -++ the coefficients (which themselves may or may not be commutative). -++ See \spadtype{FiniteAbelianMonoidRing} for the case of finite support -++ a useful common model for polynomials and power series. -++ Conceptually at least, only the non-zero terms are ever operated on. - -AbelianMonoidRing(R:Ring, E:OrderedAbelianMonoid): Category == - Join(Ring,BiModule(R,R)) with - leadingCoefficient: % -> R - ++ leadingCoefficient(p) returns the coefficient highest degree term of p. - leadingMonomial: % -> % - ++ leadingMonomial(p) returns the monomial of p with the highest degree. - degree: % -> E - ++ degree(p) returns the maximum of the exponents of the terms of p. - map: (R -> R, %) -> % - ++ map(fn,u) maps function fn onto the coefficients - ++ of the non-zero monomials of u. - monomial?: % -> Boolean - ++ monomial?(p) tests if p is a single monomial. - monomial: (R,E) -> % - ++ monomial(r,e) makes a term from a coefficient r and an exponent e. - reductum: % -> % - ++ reductum(u) returns u minus its leading monomial - ++ returns zero if handed the zero element. - coefficient: (%,E) -> R - ++ coefficient(p,e) extracts the coefficient of the monomial with - ++ exponent e from polynomial p, or returns zero if exponent is not present. - if R has Field then "/": (%,R) -> % - ++ p/c divides p by the coefficient c. - if R has CommutativeRing then - CommutativeRing - Algebra R - if R has CharacteristicZero then CharacteristicZero - if R has CharacteristicNonZero then CharacteristicNonZero - if R has IntegralDomain then IntegralDomain - if R has Algebra Fraction Integer then Algebra Fraction Integer - add - monomial? x == zero? reductum x - - map(fn:R -> R, x: %) == - -- this default definition assumes that reductum is cheap - zero? x => 0 - r:=fn leadingCoefficient x - zero? r => map(fn,reductum x) - monomial(r, degree x) + map(fn,reductum x) - - if R has Algebra Fraction Integer then - q:Fraction(Integer) * p:% == map(q * #1, p) - -@ -\section{category FAMR FiniteAbelianMonoidRing} -<>= -)abbrev category FAMR FiniteAbelianMonoidRing -++ Author: -++ Date Created: -++ Date Last Updated: 14.08.2000 Exported pomopo! and binomThmExpt [MMM] -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: -++ Keywords: -++ References: -++ Description: This category is -++ similar to AbelianMonoidRing, except that the sum is assumed to be finite. -++ It is a useful model for polynomials, -++ but is somewhat more general. - -FiniteAbelianMonoidRing(R:Ring, E:OrderedAbelianMonoid): Category == - Join(AbelianMonoidRing(R,E),FullyRetractableTo R) with - ground?: % -> Boolean - ++ ground?(p) tests if polynomial p is a member of the coefficient ring. - -- can't be defined earlier, since a power series - -- might not know if there were other terms or not - ground: % -> R - ++ ground(p) retracts polynomial p to the coefficient ring. - coefficients: % -> List R - ++ coefficients(p) gives the list of non-zero coefficients of polynomial p. - numberOfMonomials: % -> NonNegativeInteger - ++ numberOfMonomials(p) gives the number of non-zero monomials in polynomial p. - minimumDegree: % -> E - ++ minimumDegree(p) gives the least exponent of a non-zero term of polynomial p. - ++ Error: if applied to 0. - mapExponents: (E -> E, %) -> % - ++ mapExponents(fn,u) maps function fn onto the exponents - ++ of the non-zero monomials of polynomial u. - pomopo!: (%,R,E,%) -> % - ++ \spad{pomopo!(p1,r,e,p2)} returns \spad{p1 + monomial(e,r) * p2} - ++ and may use \spad{p1} as workspace. The constaant \spad{r} is - ++ assumed to be nonzero. - if R has CommutativeRing then - binomThmExpt: (%,%,NonNegativeInteger) -> % - ++ \spad{binomThmExpt(p,q,n)} returns \spad{(x+y)^n} - ++ by means of the binomial theorem trick. - if R has IntegralDomain then - "exquo": (%,R) -> Union(%,"failed") - ++ exquo(p,r) returns the exact quotient of polynomial p by r, or "failed" - ++ if none exists. - if R has GcdDomain then - content: % -> R - ++ content(p) gives the gcd of the coefficients of polynomial p. - primitivePart: % -> % - ++ primitivePart(p) returns the unit normalized form of polynomial p - ++ divided by the content of p. - add - pomopo!(p1,r,e,p2) == p1 + r * mapExponents(#1+e,p2) - - if R has CommutativeRing then - binomThmExpt(x,y,nn) == - nn = 0 => 1$% - ans,xn,yn: % - bincoef: Integer - powl: List(%):= [x] - for i in 2..nn repeat powl:=[x * powl.first, :powl] - yn:=y; ans:=powl.first; i:=1; bincoef:=nn - for xn in powl.rest repeat - ans:= bincoef * xn * yn + ans - bincoef:= (nn-i) * bincoef quo (i+1); i:= i+1 - -- last I and BINCOEF unused - yn:= y * yn - ans + yn - ground? x == - retractIfCan(x)@Union(R,"failed") case "failed" => false - true - ground x == retract(x)@R - mapExponents (fn:E -> E, x: %) == - -- this default definition assumes that reductum is cheap - zero? x => 0 - monomial(leadingCoefficient x,fn degree x)+mapExponents(fn,reductum x) - coefficients x == - zero? x => empty() - concat(leadingCoefficient x, coefficients reductum x) - - if R has Field then - x/r == map(#1/r,x) - if R has IntegralDomain then - x exquo r == - -- probably not a very good definition in most special cases - zero? x => 0 - ans:% :=0 - t:=leadingCoefficient x exquo r - while not (t case "failed") and not zero? x repeat - ans:=ans+monomial(t::R,degree x) - x:=reductum x - if not zero? x then t:=leadingCoefficient x exquo r - t case "failed" => "failed" - ans - if R has GcdDomain then - content x == -- this assumes reductum is cheap - zero? x => 0 - r:=leadingCoefficient x - x:=reductum x --- while not zero? x and not one? r repeat - while not zero? x and not (r = 1) repeat - r:=gcd(r,leadingCoefficient x) - x:=reductum x - r - primitivePart x == - zero? x => x - c := content x - unitCanonical((x exquo c)::%) - -@ \section{category POLYCAT PolynomialCategory} <>= )abbrev category POLYCAT PolynomialCategory @@ -2271,6 +2092,11 @@ Note that this code is not included in the generated catdef.spad file. @ \section{package POLYLIFT PolynomialCategoryLifting} +<>= +"POLYLIFT" -> "PACKAGE" +"PolynomialCategoryLifting(a:OAMONS,b:ORDSET,c:RING,d:POLYCAT(c,a,b),e:SETCAT)" + -> "Package" +@ <>= )abbrev package POLYLIFT PolynomialCategoryLifting ++ Author: Manuel Bronstein @@ -4323,8 +4149,6 @@ CommuteUnivariatePolynomialCategory(R, UP, UPUP): Exports == Impl where <<*>>= <> -<> -<> <> <> <> diff --git a/src/algebra/string.spad.pamphlet b/src/algebra/string.spad.pamphlet index 8ee1e1b..a704234 100644 --- a/src/algebra/string.spad.pamphlet +++ b/src/algebra/string.spad.pamphlet @@ -1742,20 +1742,6 @@ String(): StringCategory == IndexedString(MINSTRINGINDEX) add OMputEndObject(dev) @ -\section{category STRICAT StringCategory} -<>= -)abbrev category STRICAT StringCategory --- Note that StringCategory is built into the old compiler --- redundant SetCategory added to help A# compiler -++ Description: -++ A category for string-like objects - -StringCategory():Category == _ - Join(StringAggregate(), SetCategory, OpenMath) with - string: Integer -> % - ++ string(i) returns the decimal representation of i in a string - -@ \section{License} <>= --Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. @@ -1795,7 +1781,6 @@ StringCategory():Category == _ <> <> <> -<> <> @ \eject