[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Axiom-developer] 20081001.01.tpd.patch (bookvol10.2 add more categories
|
From: |
daly |
|
Subject: |
[Axiom-developer] 20081001.01.tpd.patch (bookvol10.2 add more categories) |
|
Date: |
Fri, 3 Oct 2008 03:03:24 -0500 |
add FiniteAlgebraicExtensionField, FiniteFieldCategory
======================================================================
diff --git a/books/bookvol10.2.pamphlet b/books/bookvol10.2.pamphlet
index 940e136..f0cea1d 100644
--- a/books/bookvol10.2.pamphlet
+++ b/books/bookvol10.2.pamphlet
@@ -1339,6 +1339,7 @@ digraph pic {
{\bf See:}\\
\pageto{ExtensionField}{XF}
+\pageto{FiniteAlgebraicExtensionField}{FAXF}
\pageto{FullyRetractableTo}{FRETRCT}
\pageto{GradedAlgebra}{GRALG}
\pagefrom{Category}{CATEGORY}
@@ -2626,6 +2627,7 @@ digraph pic {
\pagepic{ps/v102finite.ps}{FINITE}{1.00}
{\bf See:}\\
+\pageto{FiniteFieldCategory}{FFIELDC}
\pageto{OrderedFinite}{ORDFIN}
\pagefrom{SetCategory}{SETCAT}
@@ -3689,6 +3691,7 @@ digraph pic {
\pagepic{ps/v102stepthrough.ps}{STEP}{1.00}
{\bf See:}\\
+\pageto{FiniteFieldCategory}{FFIELDC}
\pagefrom{SetCategory}{SETCAT}
{\bf Exports:}\\
@@ -16328,6 +16331,7 @@ digraph pic {
\pagepic{ps/v102differentialring.ps}{DIFRING}{0.90}
{\bf See:}\\
+\pageto{FiniteFieldCategory}{FFIELDC}
\pagefrom{Ring}{RING}
{\bf Exports:}\\
@@ -19066,16 +19070,16 @@ FiniteRankNonAssociativeAlgebra(R:CommutativeRing):
b := someBasis()
n := rank()
recip(2 * 1$R) case "failed" =>
- messagePrint("this is not a noncommutative Jordan algebra,")$OutputForm
- messagePrint(" as 2 is not invertible in the ground ring")$OutputForm
+ messagePrint("this is not a noncommutative Jordan algebra,_
+ as 2 is not invertible in the ground ring")$OutputForm
false
not flexible?()$% =>
- messagePrint("this is not a noncommutative Jordan algebra,")$OutputForm
- messagePrint(" as it is not flexible")$OutputForm
+ messagePrint("this is not a noncommutative Jordan algebra,_
+ as it is not flexible")$OutputForm
false
not jordanAdmissible?()$% =>
- messagePrint("this is not a noncommutative Jordan algebra,")$OutputForm
- messagePrint(" as it is not Jordan admissible")$OutputForm
+ messagePrint("this is not a noncommutative Jordan algebra,_
+ as it is not Jordan admissible")$OutputForm
false
messagePrint("this is a noncommutative Jordan algebra")$OutputForm
true
@@ -21599,6 +21603,7 @@ digraph pic {
\pagepic{ps/v102fieldofprimecharacteristic.ps}{FPC}{1.00}
{\bf See:}\\
+\pageto{FiniteFieldCategory}{FFIELDC}
\pagefrom{CharacteristicNonZero}{CHARNZ}
\pagefrom{Field}{FIELD}
@@ -21721,6 +21726,7 @@ These exports come from \refto{Field}():
?**? : (%,NonNegativeInteger) -> %
?^? : (%,PositiveInteger) -> %
?^? : (%,NonNegativeInteger) -> %
+ ?^? : (%,Integer) -> %
?/? : (%,%) -> %
?quo? : (%,%) -> %
?rem? : (%,%) -> %
@@ -21905,9 +21911,9 @@ These exports come from
\refto{Algebra}(R:CommutativeRing):
These exports come from \refto{Field}():
\begin{verbatim}
+ coerce : R -> %
?*? : (R,%) -> %
?*? : (%,R) -> %
- coerce : R -> %
\end{verbatim}
These exports come from \refto{CharacteristicNonZero}():
@@ -22209,6 +22215,7 @@ digraph pic {
\pagepic{ps/v102extensionfield.ps}{XF}{0.75}
{\bf See:}\\
+\pageto{FiniteAlgebraicExtensionField}{FAXF}
\pagefrom{Field}{FIELD}
\pagefrom{RetractableTo}{RETRACT}
\pagefrom{VectorSpace}{VSPACE}
@@ -22505,6 +22512,482 @@ digraph pic {
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\pagehead{FiniteFieldCategory}{FFIELDC}
+\pagepic{ps/v102finitefieldcategory.ps}{FFIELDC}{1.00}
+
+{\bf See:}\\
+\pagefrom{DifferentialRing}{DIFRING}
+\pagefrom{FieldOfPrimeCharacteristic}{FPC}
+\pagefrom{Finite}{FINITE}
+\pagefrom{StepThrough}{STEP}
+
+{\bf Exports:}\\
+\begin{tabular}{lllll}
+\cross{FFIELDC}{0} &
+\cross{FFIELDC}{1} &
+\cross{FFIELDC}{associates?} &
+\cross{FFIELDC}{characteristic} &
+\cross{FFIELDC}{charthRoot} \\
+\cross{FFIELDC}{coerce} &
+\cross{FFIELDC}{conditionP} &
+\cross{FFIELDC}{createPrimitiveElement} &
+\cross{FFIELDC}{D} &
+\cross{FFIELDC}{differentiate} \\
+\cross{FFIELDC}{discreteLog} &
+\cross{FFIELDC}{divide} &
+\cross{FFIELDC}{euclideanSize} &
+\cross{FFIELDC}{expressIdealMember} &
+\cross{FFIELDC}{exquo} \\
+\cross{FFIELDC}{extendedEuclidean} &
+\cross{FFIELDC}{factor} &
+\cross{FFIELDC}{factorsOfCyclicGroupSize} &
+\cross{FFIELDC}{gcd} &
+\cross{FFIELDC}{gcdPolynomial} \\
+\cross{FFIELDC}{hash} &
+\cross{FFIELDC}{index} &
+\cross{FFIELDC}{init} &
+\cross{FFIELDC}{inv} &
+\cross{FFIELDC}{latex} \\
+\cross{FFIELDC}{lcm} &
+\cross{FFIELDC}{lookup} &
+\cross{FFIELDC}{multiEuclidean} &
+\cross{FFIELDC}{nextItem} &
+\cross{FFIELDC}{one?} \\
+\cross{FFIELDC}{order} &
+\cross{FFIELDC}{prime?} &
+\cross{FFIELDC}{primeFrobenius} &
+\cross{FFIELDC}{primitive?} &
+\cross{FFIELDC}{primitiveElement} \\
+\cross{FFIELDC}{principalIdeal} &
+\cross{FFIELDC}{random} &
+\cross{FFIELDC}{recip} &
+\cross{FFIELDC}{representationType} &
+\cross{FFIELDC}{sample} \\
+\cross{FFIELDC}{size} &
+\cross{FFIELDC}{sizeLess?} &
+\cross{FFIELDC}{squareFree} &
+\cross{FFIELDC}{squareFreePart} &
+\cross{FFIELDC}{subtractIfCan} \\
+\cross{FFIELDC}{tableForDiscreteLogarithm} &
+\cross{FFIELDC}{unit?} &
+\cross{FFIELDC}{unitCanonical} &
+\cross{FFIELDC}{unitNormal} &
+\cross{FFIELDC}{zero?} \\
+\cross{FFIELDC}{?*?} &
+\cross{FFIELDC}{?**?} &
+\cross{FFIELDC}{?+?} &
+\cross{FFIELDC}{?-?} &
+\cross{FFIELDC}{-?} \\
+\cross{FFIELDC}{?/?} &
+\cross{FFIELDC}{?=?} &
+\cross{FFIELDC}{?\^{}?} &
+\cross{FFIELDC}{?quo?} &
+\cross{FFIELDC}{?rem?} \\
+\cross{FFIELDC}{?\~{}=?} &&&&
+\end{tabular}
+
+These are directly exported but not implemented:
+\begin{verbatim}
+ factorsOfCyclicGroupSize : () ->
+ List Record(factor: Integer,exponent: Integer)
+ tableForDiscreteLogarithm : Integer ->
+ Table(PositiveInteger,NonNegativeInteger)
+ primitiveElement : () -> %
+ representationType : () -> Union("prime",polynomial,normal,cyclic)
+\end{verbatim}
+
+These are implemented by this category:
+\begin{verbatim}
+ charthRoot : % -> %
+ charthRoot : % -> Union(%,"failed")
+ conditionP : Matrix % -> Union(Vector %,"failed")
+ createPrimitiveElement : () -> %
+ differentiate : % -> %
+ discreteLog : % -> NonNegativeInteger
+ discreteLog : (%,%) -> Union(NonNegativeInteger,"failed")
+ gcdPolynomial : (SparseUnivariatePolynomial %,
+ SparseUnivariatePolynomial %) ->
+ SparseUnivariatePolynomial %
+ init : () -> %
+ nextItem : % -> Union(%,"failed")
+ order : % -> OnePointCompletion PositiveInteger
+ order : % -> PositiveInteger
+ primitive? : % -> Boolean
+\end{verbatim}
+
+These exports come from \refto{FieldOfPrimeCharacteristic}():
+\begin{verbatim}
+ 0 : () -> %
+ 1 : () -> %
+ associates? : (%,%) -> Boolean
+ characteristic : () -> NonNegativeInteger
+ coerce : % -> %
+ coerce : Integer -> %
+ coerce : % -> OutputForm
+ coerce : Fraction Integer -> %
+ divide : (%,%) -> Record(quotient: %,remainder: %)
+ euclideanSize : % -> NonNegativeInteger
+ expressIdealMember : (List %,%) -> Union(List %,"failed")
+ extendedEuclidean : (%,%,%) -> Union(Record(coef1: %,coef2: %),"failed")
+ extendedEuclidean : (%,%) -> Record(coef1: %,coef2: %,generator: %)
+ exquo : (%,%) -> Union(%,"failed")
+ factor : % -> Factored %
+ gcd : List % -> %
+ gcd : (%,%) -> %
+ hash : % -> SingleInteger
+ inv : % -> %
+ latex : % -> String
+ lcm : List % -> %
+ lcm : (%,%) -> %
+ multiEuclidean : (List %,%) -> Union(List %,"failed")
+ one? : % -> Boolean
+ prime? : % -> Boolean
+ primeFrobenius : % -> %
+ primeFrobenius : (%,NonNegativeInteger) -> %
+ principalIdeal : List % -> Record(coef: List %,generator: %)
+ recip : % -> Union(%,"failed")
+ sample : () -> %
+ sizeLess? : (%,%) -> Boolean
+ squareFree : % -> Factored %
+ squareFreePart : % -> %
+ subtractIfCan : (%,%) -> Union(%,"failed")
+ unit? : % -> Boolean
+ unitCanonical : % -> %
+ unitNormal : % -> Record(unit: %,canonical: %,associate: %)
+ zero? : % -> Boolean
+ ?+? : (%,%) -> %
+ ?=? : (%,%) -> Boolean
+ ?~=? : (%,%) -> Boolean
+ ?*? : (Fraction Integer,%) -> %
+ ?*? : (%,Fraction Integer) -> %
+ ?*? : (%,%) -> %
+ ?*? : (Integer,%) -> %
+ ?*? : (PositiveInteger,%) -> %
+ ?*? : (NonNegativeInteger,%) -> %
+ ?-? : (%,%) -> %
+ -? : % -> %
+ ?**? : (%,Integer) -> %
+ ?**? : (%,PositiveInteger) -> %
+ ?**? : (%,NonNegativeInteger) -> %
+ ?^? : (%,PositiveInteger) -> %
+ ?^? : (%,NonNegativeInteger) -> %
+ ?^? : (%,Integer) -> %
+ ?/? : (%,%) -> %
+ ?quo? : (%,%) -> %
+ ?rem? : (%,%) -> %
+\end{verbatim}
+
+These exports come from \refto{Finite}():
+\begin{verbatim}
+ index : PositiveInteger -> %
+ lookup : % -> PositiveInteger
+ random : () -> %
+ size : () -> NonNegativeInteger
+\end{verbatim}
+
+These exports come from \refto{StepThrough}():
+\begin{verbatim}
+\end{verbatim}
+
+These exports come from \refto{DifferentialRing}():
+\begin{verbatim}
+ D : % -> %
+ D : (%,NonNegativeInteger) -> %
+ differentiate : (%,NonNegativeInteger) -> %
+\end{verbatim}
+
+<<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)
+
+@
+<<FFIELDC.dotabb>>=
+"FFIELDC"
+ [color=lightblue,href="bookvol10.2.pdf#nameddest=FFIELDC"];
+"FFIELDC" -> "FPC"
+"FFIELDC" -> "FINITE"
+"FFIELDC" -> "STEP"
+"FFIELDC" -> "DIFRING"
+
+@
+<<FFIELDC.dotfull>>=
+"FiniteFieldCategory()"
+ [color=lightblue,href="bookvol10.2.pdf#nameddest=FFIELDC"];
+"FiniteFieldCategory()" -> "FieldOfPrimeCharacteristic()"
+"FiniteFieldCategory()" -> "Finite()"
+"FiniteFieldCategory()" -> "StepThrough()"
+"FiniteFieldCategory()" -> "DifferentialRing()"
+
+@
+<<FFIELDC.dotpic>>=
+digraph pic {
+ fontsize=10;
+ bgcolor="#FFFF66";
+ node [shape=box, color=white, style=filled];
+
+"FiniteFieldCategory()" [color=lightblue];
+"FiniteFieldCategory()" -> "FieldOfPrimeCharacteristic()"
+"FiniteFieldCategory()" -> "Finite()"
+"FiniteFieldCategory()" -> "StepThrough()"
+"FiniteFieldCategory()" -> "DifferentialRing()"
+
+"FieldOfPrimeCharacteristic()" [color=lightblue];
+"FieldOfPrimeCharacteristic()" -> "CHARNZ..."
+"FieldOfPrimeCharacteristic()" -> "FIELD..."
+
+"Finite()" [color=lightblue];
+"Finite()" -> "SETCAT..."
+
+"StepThrough()" [color=lightblue];
+"StepThrough()" -> "SETCAT..."
+
+"DifferentialRing()" [color=lightblue];
+"DifferentialRing()" -> "RING..."
+
+"RING..." [color=lightblue];
+"FIELD..." [color=lightblue];
+"CHARNZ..." [color=lightblue];
+"SETCAT..." [color=lightblue];
+
+}
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\pagehead{FunctionFieldCategory}{FFCAT}
\pagepic{ps/v102functionfieldcategory.ps}{FFCAT}{0.70}
@@ -23720,6 +24203,629 @@ digraph pic {
}
@
+\chapter{Category Layer 19}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\pagehead{FiniteAlgebraicExtensionField}{FAXF}
+\pagepic{ps/v102finitealgebraicextensionfield.ps}{FAXF}{0.75}
+
+{\bf See:}\\
+\pagefrom{ExtensionField}{XF}
+\pagefrom{RetractableTo}{RETRACT}
+
+{\bf Exports:}\\
+\begin{tabular}{lllll}
+\cross{FAXF}{0} &
+\cross{FAXF}{1} &
+\cross{FAXF}{algebraic?} \\
+\cross{FAXF}{associates?} &
+\cross{FAXF}{basis} &
+\cross{FAXF}{characteristic} \\
+\cross{FAXF}{charthRoot} &
+\cross{FAXF}{coerce} &
+\cross{FAXF}{conditionP} \\
+\cross{FAXF}{coordinates} &
+\cross{FAXF}{createNormalElement} &
+\cross{FAXF}{createPrimitiveElement} \\
+\cross{FAXF}{D} &
+\cross{FAXF}{definingPolynomial} &
+\cross{FAXF}{degree} \\
+\cross{FAXF}{differentiate} &
+\cross{FAXF}{dimension} &
+\cross{FAXF}{discreteLog} \\
+\cross{FAXF}{divide} &
+\cross{FAXF}{euclideanSize} &
+\cross{FAXF}{expressIdealMember} \\
+\cross{FAXF}{exquo} &
+\cross{FAXF}{extendedEuclidean} &
+\cross{FAXF}{extensionDegree} \\
+\cross{FAXF}{factor} &
+\cross{FAXF}{factorsOfCyclicGroupSize} &
+\cross{FAXF}{Frobenius} \\
+\cross{FAXF}{gcd} &
+\cross{FAXF}{gcdPolynomial} &
+\cross{FAXF}{generator} \\
+\cross{FAXF}{hash} &
+\cross{FAXF}{index} &
+\cross{FAXF}{inGroundField?} \\
+\cross{FAXF}{init} &
+\cross{FAXF}{inv} &
+\cross{FAXF}{latex} \\
+\cross{FAXF}{lcm} &
+\cross{FAXF}{linearAssociatedExp} &
+\cross{FAXF}{linearAssociatedLog} \\
+\cross{FAXF}{linearAssociatedOrder} &
+\cross{FAXF}{lookup} &
+\cross{FAXF}{minimalPolynomial} \\
+\cross{FAXF}{multiEuclidean} &
+\cross{FAXF}{nextItem} &
+\cross{FAXF}{norm} \\
+\cross{FAXF}{normal?} &
+\cross{FAXF}{normalElement} &
+\cross{FAXF}{one?} \\
+\cross{FAXF}{order} &
+\cross{FAXF}{prime?} &
+\cross{FAXF}{primeFrobenius} \\
+\cross{FAXF}{primitive?} &
+\cross{FAXF}{primitiveElement} &
+\cross{FAXF}{principalIdeal} \\
+\cross{FAXF}{random} &
+\cross{FAXF}{recip} &
+\cross{FAXF}{representationType} \\
+\cross{FAXF}{represents} &
+\cross{FAXF}{retract} &
+\cross{FAXF}{retractIfCan} \\
+\cross{FAXF}{sample} &
+\cross{FAXF}{size} &
+\cross{FAXF}{sizeLess?} \\
+\cross{FAXF}{squareFree} &
+\cross{FAXF}{squareFreePart} &
+\cross{FAXF}{subtractIfCan} \\
+\cross{FAXF}{tableForDiscreteLogarithm} &
+\cross{FAXF}{trace} &
+\cross{FAXF}{transcendenceDegree} \\
+\cross{FAXF}{transcendent?} &
+\cross{FAXF}{unit?} &
+\cross{FAXF}{unitCanonical} \\
+\cross{FAXF}{unitNormal} &
+\cross{FAXF}{zero?} &
+\cross{FAXF}{?*?} \\
+\cross{FAXF}{?**?} &
+\cross{FAXF}{?+?} &
+\cross{FAXF}{?-?} \\
+\cross{FAXF}{-?} &
+\cross{FAXF}{?/?} &
+\cross{FAXF}{?/?} \\
+\cross{FAXF}{?=?} &
+\cross{FAXF}{?\^{}?} &
+\cross{FAXF}{?quo?} \\
+\cross{FAXF}{?rem?} &
+\cross{FAXF}{?\~{}=?} &
+\end{tabular}
+
+These are directly exported but not implemented:
+\begin{verbatim}
+ basis : () -> Vector %
+ basis : PositiveInteger -> Vector %
+ coordinates : % -> Vector F
+ definingPolynomial : () -> SparseUnivariatePolynomial F
+ generator : () -> % if F has FINITE
+ minimalPolynomial : (%,PositiveInteger) ->
+ SparseUnivariatePolynomial %
+ if F has FINITE
+ normalElement : () -> % if F has FINITE
+\end{verbatim}
+
+These are implemented by this category:
+\begin{verbatim}
+ algebraic? : % -> Boolean
+ charthRoot : % -> Union(%,"failed")
+ if F has CHARNZ or F has FINITE
+ coordinates : Vector % -> Matrix F
+ createNormalElement : () -> % if F has FINITE
+ degree : % -> PositiveInteger
+ dimension : () -> CardinalNumber
+ extensionDegree : () -> PositiveInteger
+ linearAssociatedExp : (%,SparseUnivariatePolynomial F) -> %
+ if F has FINITE
+ linearAssociatedLog : (%,%) ->
+ Union(SparseUnivariatePolynomial F,"failed")
+ if F has FINITE
+ linearAssociatedLog : % -> SparseUnivariatePolynomial F
+ if F has FINITE
+ linearAssociatedOrder : % -> SparseUnivariatePolynomial F
+ if F has FINITE
+ minimalPolynomial : % -> SparseUnivariatePolynomial F
+ norm : % -> F
+ norm : (%,PositiveInteger) -> % if F has FINITE
+ normal? : % -> Boolean if F has FINITE
+ represents : Vector F -> %
+ size : () -> NonNegativeInteger if F has FINITE
+ trace : % -> F
+ trace : (%,PositiveInteger) -> % if F has FINITE
+ transcendenceDegree : () -> NonNegativeInteger
+ transcendent? : % -> Boolean
+\end{verbatim}
+
+These exports come from \refto{ExtensionField}(F:Field):
+\begin{verbatim}
+ 0 : () -> %
+ 1 : () -> %
+ associates? : (%,%) -> Boolean
+ characteristic : () -> NonNegativeInteger
+ coerce : F -> %
+ coerce : % -> %
+ coerce : Integer -> %
+ coerce : % -> OutputForm
+ coerce : Fraction Integer -> %
+ discreteLog : (%,%) ->
+ Union(NonNegativeInteger,"failed")
+ if F has CHARNZ or F has FINITE
+ divide : (%,%) -> Record(quotient: %,remainder: %)
+ euclideanSize : % -> NonNegativeInteger
+ expressIdealMember : (List %,%) -> Union(List %,"failed")
+ exquo : (%,%) -> Union(%,"failed")
+ extendedEuclidean : (%,%,%) ->
+ Union(Record(coef1: %,coef2: %),"failed")
+ extendedEuclidean : (%,%) ->
+ Record(coef1: %,coef2: %,generator: %)
+ factor : % -> Factored %
+ Frobenius : (%,NonNegativeInteger) -> % if F has FINITE
+ Frobenius : % -> % if F has FINITE
+ gcd : List % -> %
+ gcd : (%,%) -> %
+ gcdPolynomial : (SparseUnivariatePolynomial %,
+ SparseUnivariatePolynomial %) ->
+ SparseUnivariatePolynomial %
+ hash : % -> SingleInteger
+ inGroundField? : % -> Boolean
+ inv : % -> %
+ latex : % -> String
+ lcm : List % -> %
+ lcm : (%,%) -> %
+ multiEuclidean : (List %,%) -> Union(List %,"failed")
+ one? : % -> Boolean
+ order : % -> OnePointCompletion PositiveInteger
+ if F has CHARNZ or F has FINITE
+ prime? : % -> Boolean
+ primeFrobenius : % -> %
+ if F has CHARNZ or F has FINITE
+ primeFrobenius : (%,NonNegativeInteger) -> %
+ if F has CHARNZ or F has FINITE
+ principalIdeal : List % -> Record(coef: List %,generator: %)
+ recip : % -> Union(%,"failed")
+ retract : % -> F
+ retractIfCan : % -> Union(F,"failed")
+ sample : () -> %
+ squareFree : % -> Factored %
+ squareFreePart : % -> %
+ sizeLess? : (%,%) -> Boolean
+ subtractIfCan : (%,%) -> Union(%,"failed")
+ unit? : % -> Boolean
+ unitCanonical : % -> %
+ unitNormal : % -> Record(unit: %,canonical: %,associate: %)
+ zero? : % -> Boolean
+ ?/? : (%,%) -> %
+ ?+? : (%,%) -> %
+ ?=? : (%,%) -> Boolean
+ ?~=? : (%,%) -> Boolean
+ ?*? : (%,%) -> %
+ ?*? : (Integer,%) -> %
+ ?*? : (PositiveInteger,%) -> %
+ ?*? : (NonNegativeInteger,%) -> %
+ ?*? : (Fraction Integer,%) -> %
+ ?*? : (%,Fraction Integer) -> %
+ ?*? : (F,%) -> %
+ ?*? : (%,F) -> %
+ ?-? : (%,%) -> %
+ -? : % -> %
+ ?**? : (%,NonNegativeInteger) -> %
+ ?**? : (%,PositiveInteger) -> %
+ ?**? : (%,Integer) -> %
+ ?^? : (%,Integer) -> %
+ ?^? : (%,PositiveInteger) -> %
+ ?^? : (%,NonNegativeInteger) -> %
+ ?quo? : (%,%) -> %
+ ?rem? : (%,%) -> %
+ ?/? : (%,F) -> %
+\end{verbatim}
+
+These exports come from \refto{RetractableTo}(F:Field):
+\begin{verbatim}
+\end{verbatim}
+
+These exports come from \refto{FiniteFieldCategory}():
+\begin{verbatim}
+ charthRoot : % -> % if F has FINITE
+ conditionP : Matrix % -> Union(Vector %,"failed")
+ if F has FINITE
+ createPrimitiveElement : () -> % if F has FINITE
+ D : % -> % if F has FINITE
+ D : (%,NonNegativeInteger) -> % if F has FINITE
+ differentiate : % -> % if F has FINITE
+ differentiate : (%,NonNegativeInteger) -> %
+ if F has FINITE
+ discreteLog : % -> NonNegativeInteger if F has FINITE
+ factorsOfCyclicGroupSize : () ->
+ List Record(factor: Integer,exponent: Integer)
+ if F has FINITE
+ index : PositiveInteger -> % if F has FINITE
+ init : () -> % if F has FINITE
+ lookup : % -> PositiveInteger if F has FINITE
+ nextItem : % -> Union(%,"failed") if F has FINITE
+ order : % -> PositiveInteger if F has FINITE
+ primitive? : % -> Boolean if F has FINITE
+ primitiveElement : () -> % if F has FINITE
+ random : () -> % if F has FINITE
+ representationType : () ->
+ Union("prime",polynomial,normal,cyclic)
+ if F has FINITE
+ tableForDiscreteLogarithm : Integer ->
+ Table(PositiveInteger,NonNegativeInteger)
+ if F has FINITE
+\end{verbatim}
+
+
+<<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
+
+ 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
+
+-- This definition is a duplicate and has been removed
+-- extensionDegree():OnePointCompletion(PositiveInteger) ==
+-- (#basis()) :: PositiveInteger::OnePointCompletion(PositiveInteger)
+
+ extensionDegree() == (#basis()) :: PositiveInteger
+
+-- These definitions are duplicates and have been removed
+-- degree(a):OnePointCompletion(PositiveInteger) ==
+-- degree(a)@PI::OnePointCompletion(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
+
+@
+<<FAXF.dotabb>>=
+"FAXF"
+ [color=lightblue,href="bookvol10.2.pdf#nameddest=FAXF"];
+"FAXF" -> "XF"
+"FAXF" -> "RETRACT"
+
+@
+<<FAXF.dotfull>>=
+"FiniteAlgebraicExtensionField(a:Field)"
+ [color=lightblue,href="bookvol10.2.pdf#nameddest=FAXF"];
+"FiniteAlgebraicExtensionField(a:Field)" -> "ExtensionField(a:Field)"
+"FiniteAlgebraicExtensionField(a:Field)" -> "RetractableTo(a:Field)"
+
+@
+<<FAXF.dotpic>>=
+digraph pic {
+ fontsize=10;
+ bgcolor="#FFFF66";
+ node [shape=box, color=white, style=filled];
+
+"FiniteAlgebraicExtensionField(a:Field)"
+ [color=lightblue,href="bookvol10.2.pdf#nameddest=FAXF"];
+"FiniteAlgebraicExtensionField(a:Field)" -> "ExtensionField(a:Field)"
+"FiniteAlgebraicExtensionField(a:Field)" -> "RetractableTo(Field)"
+
+"ExtensionField(a:Field)" [color=lightblue];
+"ExtensionField(a:Field)" -> "Field()"
+"ExtensionField(a:Field)" -> "RetractableTo(Field)"
+"ExtensionField(a:Field)" -> "VectorSpace(a:Field)"
+
+"Field()" [color=lightblue];
+"Field()" -> "EuclideanDomain()"
+"Field()" -> "UniqueFactorizationDomain()"
+"Field()" -> "DIVRING..."
+
+"EuclideanDomain()" [color=lightblue];
+"EuclideanDomain()" -> "PrincipalIdealDomain()"
+
+"UniqueFactorizationDomain()" [color=lightblue];
+"UniqueFactorizationDomain()" -> "GCDDOM..."
+
+"PrincipalIdealDomain()" [color=lightblue];
+"PrincipalIdealDomain()" -> "GCDDOM..."
+
+"RetractableTo(Field)" [color=seagreen];
+"RetractableTo(Field)" -> "RetractableTo(a:Type)"
+
+"RetractableTo(a:Type)" [color=lightblue];
+"RetractableTo(a:Type)" -> "Category"
+
+"VectorSpace(a:Field)" [color=lightblue];
+"VectorSpace(a:Field)" -> "MODULE..."
+
+"MODULE..." [color=lightblue];
+"DIVRING..." [color=lightblue];
+"GCDDOM..." [color=lightblue];
+"Category" [color=lightblue];
+}
+
+@
\chapter{The bootstrap code}
\section{ABELGRP.lsp BOOTSTRAP}
{\bf ABELGRP} depends on a chain of
@@ -25558,6 +26664,639 @@ Note that this code is not included in the generated
catdef.spad file.
(MAKEPROP (QUOTE |EntireRing|) (QUOTE NILADIC) T)
@
+\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.
+
+<<FFIELDC.lsp BOOTSTRAP>>=
+
+(|/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.
+
+<<FFIELDC-.lsp BOOTSTRAP>>=
+
+(|/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{GCDDOM.lsp BOOTSTRAP}
{\bf GCDDOM} needs
{\bf COMRING} which needs
@@ -29684,11 +31423,13 @@ Note that this code is not included in the generated
catdef.spad file.
<<category ENTIRER EntireRing>>
<<category EUCDOM EuclideanDomain>>
<<category EVALAB Evalable>>
+<<category FAXF FiniteAlgebraicExtensionField>>
<<category FIELD Field>>
<<category FINAALG FiniteRankNonAssociativeAlgebra>>
<<category FINITE Finite>>
<<category FINRALG FiniteRankAlgebra>>
<<category FFCAT FunctionFieldCategory>>
+<<category FFIELDC FiniteFieldCategory>>
<<category FLAGG FiniteLinearAggregate>>
<<category FLINEXP FullyLinearlyExplicitRingOver>>
<<category FPC FieldOfPrimeCharacteristic>>
@@ -29805,11 +31546,13 @@ digraph dotabb {
<<ENTIRER.dotabb>>
<<EUCDOM.dotabb>>
<<EVALAB.dotabb>>
+<<FAXF.dotabb>>
<<FIELD.dotabb>>
<<FINAALG.dotabb>>
<<FINITE.dotabb>>
<<FINRALG.dotabb>>
<<FFCAT.dotabb>>
+<<FFIELDC.dotabb>>
<<FLAGG.dotabb>>
<<FLINEXP.dotabb>>
<<FPC.dotabb>>
@@ -29928,11 +31671,13 @@ digraph dotfull {
<<ENTIRER.dotfull>>
<<EUCDOM.dotfull>>
<<EVALAB.dotfull>>
+<<FAXF.dotfull>>
<<FIELD.dotfull>>
<<FINAALG.dotfull>>
<<FINITE.dotfull>>
<<FINRALG.dotfull>>
<<FFCAT.dotfull>>
+<<FFIELDC.dotfull>>
<<FLAGG.dotfull>>
<<FLINEXP.dotfull>>
<<FPC.dotfull>>
diff --git a/books/ps/v102finitealgebraicextensionfield.ps
b/books/ps/v102finitealgebraicextensionfield.ps
new file mode 100644
index 0000000..eb86f1a
--- /dev/null
+++ b/books/ps/v102finitealgebraicextensionfield.ps
@@ -0,0 +1,842 @@
+%!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 576 440
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+ dup dup findfont dup length dict begin
+ { 1 index /FID ne { def }{ pop pop } ifelse
+ } forall
+ /Encoding EncodingVector def
+ currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+ dup 1 exch div /InvScaleFactor exch def
+ dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def}
bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage { % i j npages
+ /npages exch def
+ /j exch def
+ /i exch def
+ /str 10 string def
+ npages 1 gt {
+ gsave
+ coordfont setfont
+ 0 0 moveto
+ (\() show i str cvs show (,) show j str cvs show (\))
show
+ grestore
+ } if
+} bind def
+
+/set_font {
+ findfont exch
+ scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext { % width adj text
+ /text exch def
+ /adj exch def
+ /width exch def
+ gsave
+ width 0 gt {
+ text stringwidth pop adj mul 0 rmoveto
+ } if
+ [] 0 setdash
+ text show
+ grestore
+} def
+
+/boxprim { % xcorner ycorner xsize ysize
+ 4 2 roll
+ moveto
+ 2 copy
+ exch 0 rlineto
+ 0 exch rlineto
+ pop neg 0 rlineto
+ closepath
+} bind def
+
+/ellipse_path {
+ /ry exch def
+ /rx exch def
+ /y exch def
+ /x exch def
+ matrix currentmatrix
+ newpath
+ x y translate
+ rx ry scale
+ 0 0 1 0 360 arc
+ setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+ [ % layer color sequence - darkest to lightest
+ [0 0 0]
+ [.2 .8 .8]
+ [.4 .8 .8]
+ [.6 .8 .8]
+ [.8 .8 .8]
+ ]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+ layercolorseq curlayer 1 sub layerlen mod get
+ aload pop sethsbcolor
+ /nodecolor {nopcolor} def
+ /edgecolor {nopcolor} def
+ /graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+ /myupper exch def
+ /mylower exch def
+ curlayer mylower lt
+ curlayer myupper gt
+ or
+ {invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+ userdict (<<) cvn ([) cvn load put
+ userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 576 440
+%%PageOrientation: Portrait
+gsave
+36 36 540 404 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 402 lineto
+538 402 lineto
+538 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 402 lineto
+538 402 lineto
+538 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% FiniteAlgebraicExtensionField(a:Field)
+[ /Rect [ 139 360 375 396 ]
+ /Border [ 0 0 0 ]
+ /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=FAXF) >>
+ /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 375 396 moveto
+139 396 lineto
+139 360 lineto
+375 360 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 375 396 moveto
+139 396 lineto
+139 360 lineto
+375 360 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+147 373 moveto
+(FiniteAlgebraicExtensionField\(a:Field\))
+[7.44 3.84 6.96 3.84 3.84 6.24 10.08 3.84 6.72 6.24 6.96 4.8 6.24 3.84 6.24
8.64 6.96 3.84 6.24 6.96 5.52 3.84 6.96 6.96 7.44 3.84 6.24 3.84 6.96 4.56 6.24
3.84 7.44 3.84 6.24 3.84 6.96 4.56]
+xshow
+end grestore
+end grestore
+% ExtensionField(a:Field)
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 383 324 moveto
+235 324 lineto
+235 288 lineto
+383 288 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 383 324 moveto
+235 324 lineto
+235 288 lineto
+383 288 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+243 301 moveto
+(ExtensionField\(a:Field\))
+[8.64 6.96 3.84 6.24 6.96 5.52 3.84 6.96 6.96 7.44 3.84 6.24 3.84 6.96 4.56
6.24 3.84 7.44 3.84 6.24 3.84 6.96 4.56]
+xshow
+end grestore
+end grestore
+% FiniteAlgebraicExtensionField(a:Field)->ExtensionField(a:Field)
+newpath 270 360 moveto
+276 352 283 341 290 332 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 293 334 moveto
+296 324 lineto
+287 330 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 293 334 moveto
+296 324 lineto
+287 330 lineto
+closepath
+stroke
+end grestore
+% RetractableTo(Field)
+gsave 10 dict begin
+filled
+0.404 0.667 0.545 nodecolor
+0.404 0.667 0.545 nodecolor
+newpath 267 252 moveto
+135 252 lineto
+135 216 lineto
+267 216 lineto
+closepath
+fill
+0.404 0.667 0.545 nodecolor
+newpath 267 252 moveto
+135 252 lineto
+135 216 lineto
+267 216 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+143 229 moveto
+(RetractableTo\(Field\))
+[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 7.44 3.84
6.24 3.84 6.96 4.56]
+xshow
+end grestore
+end grestore
+% FiniteAlgebraicExtensionField(a:Field)->RetractableTo(Field)
+newpath 245 360 moveto
+239 350 231 336 226 324 curveto
+218 304 211 280 207 262 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 210 261 moveto
+205 252 lineto
+204 262 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 210 261 moveto
+205 252 lineto
+204 262 lineto
+closepath
+stroke
+end grestore
+% ExtensionField(a:Field)->RetractableTo(Field)
+newpath 282 288 moveto
+268 279 251 268 237 258 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 238 255 moveto
+228 252 lineto
+234 260 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 238 255 moveto
+228 252 lineto
+234 260 lineto
+closepath
+stroke
+end grestore
+% Field()
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 339 252 moveto
+285 252 lineto
+285 216 lineto
+339 216 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 339 252 moveto
+285 252 lineto
+285 216 lineto
+339 216 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+293 229 moveto
+(Field\(\))
+[7.44 3.84 6.24 3.84 6.96 4.56 4.56]
+xshow
+end grestore
+end grestore
+% ExtensionField(a:Field)->Field()
+newpath 310 288 moveto
+311 280 311 271 311 262 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 315 262 moveto
+311 252 lineto
+308 262 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 315 262 moveto
+311 252 lineto
+308 262 lineto
+closepath
+stroke
+end grestore
+% VectorSpace(a:Field)
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 523 252 moveto
+389 252 lineto
+389 216 lineto
+523 216 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 523 252 moveto
+389 252 lineto
+389 216 lineto
+523 216 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+396 229 moveto
+(VectorSpace\(a:Field\))
+[8.88 6.24 6.24 3.84 6.96 4.8 7.68 6.96 6.24 6.24 6.24 4.56 6.24 3.84 7.44
3.84 6.24 3.84 6.96 4.56]
+xshow
+end grestore
+end grestore
+% ExtensionField(a:Field)->VectorSpace(a:Field)
+newpath 346 288 moveto
+366 278 390 267 411 256 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 412 259 moveto
+420 252 lineto
+409 253 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 412 259 moveto
+420 252 lineto
+409 253 lineto
+closepath
+stroke
+end grestore
+% RetractableTo(a:Type)
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 140 180 moveto
+0 180 lineto
+0 144 lineto
+140 144 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 140 180 moveto
+0 180 lineto
+0 144 lineto
+140 144 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+7 157 moveto
+(RetractableTo\(a:Type\))
+[9.12 6 3.84 4.8 6.24 6.24 4.08 6.24 6.96 3.84 6.24 7.44 6.96 4.56 6.24 3.84
7.2 6.96 6.96 6.24 4.56]
+xshow
+end grestore
+end grestore
+% RetractableTo(Field)->RetractableTo(a:Type)
+newpath 168 216 moveto
+151 207 130 195 112 185 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 113 182 moveto
+103 180 lineto
+110 188 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 113 182 moveto
+103 180 lineto
+110 188 lineto
+closepath
+stroke
+end grestore
+% EuclideanDomain()
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 284 180 moveto
+158 180 lineto
+158 144 lineto
+284 144 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 284 180 moveto
+158 180 lineto
+158 144 lineto
+284 144 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+165 157 moveto
+(EuclideanDomain\(\))
+[8.64 6.96 6.24 3.84 3.84 6.96 6.24 6.24 6.96 10.08 6.96 10.8 6.24 3.84 6.96
4.56 4.56]
+xshow
+end grestore
+end grestore
+% Field()->EuclideanDomain()
+newpath 289 216 moveto
+278 207 264 196 252 186 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 254 183 moveto
+244 180 lineto
+250 189 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 254 183 moveto
+244 180 lineto
+250 189 lineto
+closepath
+stroke
+end grestore
+% UniqueFactorizationDomain()
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 486 108 moveto
+302 108 lineto
+302 72 lineto
+486 72 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 486 108 moveto
+302 108 lineto
+302 72 lineto
+486 72 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+309 85 moveto
+(UniqueFactorizationDomain\(\))
+[9.6 6.96 3.84 6.72 6.96 6.24 7.2 6.24 6.24 3.84 6.96 5.04 3.84 6.24 6.24 3.84
3.84 6.96 6.96 10.08 6.96 10.8 6.24 3.84 6.96 4.56 4.56]
+xshow
+end grestore
+end grestore
+% Field()->UniqueFactorizationDomain()
+newpath 313 216 moveto
+314 197 318 166 331 144 curveto
+338 133 348 123 357 114 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 359 117 moveto
+365 108 lineto
+355 111 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 359 117 moveto
+365 108 lineto
+355 111 lineto
+closepath
+stroke
+end grestore
+% DIVRING...
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 426 180 moveto
+340 180 lineto
+340 144 lineto
+426 144 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 426 180 moveto
+340 180 lineto
+340 144 lineto
+426 144 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+347 157 moveto
+(DIVRING...)
+[10.08 4.56 10.08 9.36 4.56 9.84 10.08 3.6 3.6 3.6]
+xshow
+end grestore
+end grestore
+% Field()->DIVRING...
+newpath 330 216 moveto
+339 207 349 197 358 188 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 361 190 moveto
+365 180 lineto
+356 185 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 361 190 moveto
+365 180 lineto
+356 185 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 532 180 moveto
+444 180 lineto
+444 144 lineto
+532 144 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 532 180 moveto
+444 180 lineto
+444 144 lineto
+532 144 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+452 157 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
+% VectorSpace(a:Field)->MODULE...
+newpath 464 216 moveto
+468 208 472 198 476 189 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 479 191 moveto
+480 180 lineto
+473 188 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 479 191 moveto
+480 180 lineto
+473 188 lineto
+closepath
+stroke
+end grestore
+% PrincipalIdealDomain()
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 284 108 moveto
+134 108 lineto
+134 72 lineto
+284 72 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 284 108 moveto
+134 108 lineto
+134 72 lineto
+284 72 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+142 85 moveto
+(PrincipalIdealDomain\(\))
+[7.68 5.04 3.84 6.96 6.24 3.84 6.96 6.24 3.84 4.56 6.96 6.24 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
+% EuclideanDomain()->PrincipalIdealDomain()
+newpath 218 144 moveto
+217 136 215 127 214 118 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 217 117 moveto
+212 108 lineto
+211 118 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 217 117 moveto
+212 108 lineto
+211 118 lineto
+closepath
+stroke
+end grestore
+% GCDDOM...
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 346 36 moveto
+256 36 lineto
+256 0 lineto
+346 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 346 36 moveto
+256 36 lineto
+256 0 lineto
+346 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+264 13 moveto
+(GCDDOM...)
+[10.08 9.36 10.08 10.08 10.08 12.48 3.6 3.6 3.6]
+xshow
+end grestore
+end grestore
+% UniqueFactorizationDomain()->GCDDOM...
+newpath 371 72 moveto
+360 63 345 52 332 42 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 334 39 moveto
+324 36 lineto
+330 45 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 334 39 moveto
+324 36 lineto
+330 45 lineto
+closepath
+stroke
+end grestore
+% PrincipalIdealDomain()->GCDDOM...
+newpath 232 72 moveto
+243 63 258 52 270 42 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 272 45 moveto
+278 36 lineto
+268 39 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 272 45 moveto
+278 36 lineto
+268 39 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 104 108 moveto
+36 108 lineto
+36 72 lineto
+104 72 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 104 108 moveto
+36 108 lineto
+36 72 lineto
+104 72 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+44 85 moveto
+(Category)
+[9.36 6.24 3.84 6.24 6.96 6.96 5.04 6.96]
+xshow
+end grestore
+end grestore
+% RetractableTo(a:Type)->Category
+newpath 70 144 moveto
+70 136 70 127 70 118 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 74 118 moveto
+70 108 lineto
+67 118 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 74 118 moveto
+70 108 lineto
+67 118 lineto
+closepath
+stroke
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v102finitefieldcategory.ps
b/books/ps/v102finitefieldcategory.ps
new file mode 100644
index 0000000..c96d9dd
--- /dev/null
+++ b/books/ps/v102finitefieldcategory.ps
@@ -0,0 +1,631 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 552 224
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+ dup dup findfont dup length dict begin
+ { 1 index /FID ne { def }{ pop pop } ifelse
+ } forall
+ /Encoding EncodingVector def
+ currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+ dup 1 exch div /InvScaleFactor exch def
+ dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def}
bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage { % i j npages
+ /npages exch def
+ /j exch def
+ /i exch def
+ /str 10 string def
+ npages 1 gt {
+ gsave
+ coordfont setfont
+ 0 0 moveto
+ (\() show i str cvs show (,) show j str cvs show (\))
show
+ grestore
+ } if
+} bind def
+
+/set_font {
+ findfont exch
+ scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext { % width adj text
+ /text exch def
+ /adj exch def
+ /width exch def
+ gsave
+ width 0 gt {
+ text stringwidth pop adj mul 0 rmoveto
+ } if
+ [] 0 setdash
+ text show
+ grestore
+} def
+
+/boxprim { % xcorner ycorner xsize ysize
+ 4 2 roll
+ moveto
+ 2 copy
+ exch 0 rlineto
+ 0 exch rlineto
+ pop neg 0 rlineto
+ closepath
+} bind def
+
+/ellipse_path {
+ /ry exch def
+ /rx exch def
+ /y exch def
+ /x exch def
+ matrix currentmatrix
+ newpath
+ x y translate
+ rx ry scale
+ 0 0 1 0 360 arc
+ setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+ [ % layer color sequence - darkest to lightest
+ [0 0 0]
+ [.2 .8 .8]
+ [.4 .8 .8]
+ [.6 .8 .8]
+ [.8 .8 .8]
+ ]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+ layercolorseq curlayer 1 sub layerlen mod get
+ aload pop sethsbcolor
+ /nodecolor {nopcolor} def
+ /edgecolor {nopcolor} def
+ /graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+ /myupper exch def
+ /mylower exch def
+ curlayer mylower lt
+ curlayer myupper gt
+ or
+ {invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+ userdict (<<) cvn ([) cvn load put
+ userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 552 224
+%%PageOrientation: Portrait
+gsave
+36 36 516 188 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 186 lineto
+514 186 lineto
+514 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 186 lineto
+514 186 lineto
+514 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% FiniteFieldCategory()
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 344 180 moveto
+206 180 lineto
+206 144 lineto
+344 144 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 344 180 moveto
+206 180 lineto
+206 144 lineto
+344 144 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+214 157 moveto
+(FiniteFieldCategory\(\))
+[7.44 3.84 6.96 3.84 3.84 6.24 7.44 3.84 6.24 3.84 6.96 9.36 6.24 3.84 6.24
6.96 6.96 5.04 6.96 4.56 4.56]
+xshow
+end grestore
+end grestore
+% FieldOfPrimeCharacteristic()
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 180 108 moveto
+0 108 lineto
+0 72 lineto
+180 72 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 180 108 moveto
+0 108 lineto
+0 72 lineto
+180 72 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+8 85 moveto
+(FieldOfPrimeCharacteristic\(\))
+[7.44 3.84 6.24 3.84 6.96 10.08 4.56 7.68 5.04 3.84 10.8 6.24 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 4.56 4.56]
+xshow
+end grestore
+end grestore
+% FiniteFieldCategory()->FieldOfPrimeCharacteristic()
+newpath 228 144 moveto
+203 134 172 122 145 112 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 147 109 moveto
+136 108 lineto
+144 115 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 147 109 moveto
+136 108 lineto
+144 115 lineto
+closepath
+stroke
+end grestore
+% Finite()
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 256 108 moveto
+198 108 lineto
+198 72 lineto
+256 72 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 256 108 moveto
+198 108 lineto
+198 72 lineto
+256 72 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+206 85 moveto
+(Finite\(\))
+[7.44 3.84 6.96 3.84 3.84 6.24 4.56 4.56]
+xshow
+end grestore
+end grestore
+% FiniteFieldCategory()->Finite()
+newpath 263 144 moveto
+258 136 251 126 245 116 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 248 114 moveto
+239 108 lineto
+242 118 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 248 114 moveto
+239 108 lineto
+242 118 lineto
+closepath
+stroke
+end grestore
+% StepThrough()
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 372 108 moveto
+274 108 lineto
+274 72 lineto
+372 72 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 372 108 moveto
+274 108 lineto
+274 72 lineto
+372 72 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+282 85 moveto
+(StepThrough\(\))
+[7.44 3.84 6.24 6.96 8.64 6.96 4.8 6.96 6.96 6.96 6.96 4.56 4.56]
+xshow
+end grestore
+end grestore
+% FiniteFieldCategory()->StepThrough()
+newpath 287 144 moveto
+292 136 299 126 305 116 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 308 118 moveto
+311 108 lineto
+302 114 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 308 118 moveto
+311 108 lineto
+302 114 lineto
+closepath
+stroke
+end grestore
+% DifferentialRing()
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 508 108 moveto
+390 108 lineto
+390 72 lineto
+508 72 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 508 108 moveto
+390 108 lineto
+390 72 lineto
+508 72 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+398 85 moveto
+(DifferentialRing\(\))
+[10.08 3.84 4.56 4.08 6.24 4.8 6.24 6.96 3.84 3.84 6.24 3.84 9.36 3.84 6.96
6.96 4.56 4.56]
+xshow
+end grestore
+end grestore
+% FiniteFieldCategory()->DifferentialRing()
+newpath 319 144 moveto
+342 134 371 122 397 112 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 398 115 moveto
+406 108 lineto
+395 109 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 398 115 moveto
+406 108 lineto
+395 109 lineto
+closepath
+stroke
+end grestore
+% CHARNZ...
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 97 36 moveto
+13 36 lineto
+13 0 lineto
+97 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 97 36 moveto
+13 36 lineto
+13 0 lineto
+97 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+20 13 moveto
+(CHARNZ...)
+[9.36 10.08 10.08 9.36 10.08 8.64 3.6 3.6 3.6]
+xshow
+end grestore
+end grestore
+% FieldOfPrimeCharacteristic()->CHARNZ...
+newpath 81 72 moveto
+77 64 73 54 68 45 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 71 44 moveto
+64 36 lineto
+65 47 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 71 44 moveto
+64 36 lineto
+65 47 lineto
+closepath
+stroke
+end grestore
+% FIELD...
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 181 36 moveto
+115 36 lineto
+115 0 lineto
+181 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 181 36 moveto
+115 36 lineto
+115 0 lineto
+181 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+122 13 moveto
+(FIELD...)
+[7.68 4.56 8.64 8.64 10.08 3.6 3.6 3.6]
+xshow
+end grestore
+end grestore
+% FieldOfPrimeCharacteristic()->FIELD...
+newpath 105 72 moveto
+112 63 120 53 128 44 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 131 46 moveto
+134 36 lineto
+125 42 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 131 46 moveto
+134 36 lineto
+125 42 lineto
+closepath
+stroke
+end grestore
+% SETCAT...
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 302 36 moveto
+224 36 lineto
+224 0 lineto
+302 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 302 36 moveto
+224 36 lineto
+224 0 lineto
+302 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+232 13 moveto
+(SETCAT...)
+[7.68 8.64 8.64 9.12 9.36 7.44 3.6 3.6 3.6]
+xshow
+end grestore
+end grestore
+% Finite()->SETCAT...
+newpath 236 72 moveto
+240 64 245 54 250 45 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 253 47 moveto
+254 36 lineto
+247 44 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 253 47 moveto
+254 36 lineto
+247 44 lineto
+closepath
+stroke
+end grestore
+% StepThrough()->SETCAT...
+newpath 308 72 moveto
+301 63 292 53 285 44 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 287 41 moveto
+278 36 lineto
+282 46 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 287 41 moveto
+278 36 lineto
+282 46 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 479 36 moveto
+419 36 lineto
+419 0 lineto
+479 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 479 36 moveto
+419 36 lineto
+419 0 lineto
+479 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+426 13 moveto
+(RING...)
+[9.36 4.56 9.84 10.08 3.6 3.6 3.6]
+xshow
+end grestore
+end grestore
+% DifferentialRing()->RING...
+newpath 449 72 moveto
+449 64 449 55 449 46 curveto
+stroke
+gsave 10 dict begin
+solid
+1 setlinewidth
+0.000 0.000 0.000 edgecolor
+newpath 453 46 moveto
+449 36 lineto
+446 46 lineto
+closepath
+fill
+0.000 0.000 0.000 edgecolor
+newpath 453 46 moveto
+449 36 lineto
+446 46 lineto
+closepath
+stroke
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v102setcategory.ps b/books/ps/v102setcategory.ps
index ba73fd5..2e4a72e 100644
--- a/books/ps/v102setcategory.ps
+++ b/books/ps/v102setcategory.ps
@@ -206,11 +206,6 @@ stroke
0.000 0.000 0.000 graphcolor
14.00 /Times-Roman set_font
% SetCategory()
-[ /Rect [ 58 216 152 252 ]
- /Border [ 0 0 0 ]
- /Action << /Subtype /URI /URI (books/bookvol10.2.pamphlet) >>
- /Subtype /Link
-/ANN pdfmark
gsave 10 dict begin
filled
0.537 0.247 0.902 nodecolor
@@ -237,11 +232,6 @@ xshow
end grestore
end grestore
% BasicType()
-[ /Rect [ 0 72 84 108 ]
- /Border [ 0 0 0 ]
- /Action << /Subtype /URI /URI (books/bookvol10.2.pamphlet) >>
- /Subtype /Link
-/ANN pdfmark
gsave 10 dict begin
filled
0.537 0.247 0.902 nodecolor
@@ -289,11 +279,6 @@ closepath
stroke
end grestore
% CoercibleTo(OutputForm)
-[ /Rect [ 82 144 246 180 ]
- /Border [ 0 0 0 ]
- /Action << /Subtype /URI /URI (books/bookvol10.2.pamphlet) >>
- /Subtype /Link
-/ANN pdfmark
gsave 10 dict begin
filled
0.404 0.667 0.545 nodecolor
@@ -340,11 +325,6 @@ closepath
stroke
end grestore
% Category
-[ /Rect [ 71 0 139 36 ]
- /Border [ 0 0 0 ]
- /Action << /Subtype /URI /URI (books/bookvol10.pamphlet) >>
- /Subtype /Link
-/ANN pdfmark
gsave 10 dict begin
filled
0.537 0.247 0.902 nodecolor
@@ -391,11 +371,6 @@ closepath
stroke
end grestore
% CoercibleTo(a:Type)
-[ /Rect [ 102 72 234 108 ]
- /Border [ 0 0 0 ]
- /Action << /Subtype /URI /URI (books/bookvol10.2.pamphlet) >>
- /Subtype /Link
-/ANN pdfmark
gsave 10 dict begin
filled
0.537 0.247 0.902 nodecolor
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Axiom-developer] 20081001.01.tpd.patch (bookvol10.2 add more categories),
daly <=