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} + +<>= +)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" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FFIELDC"]; +"FFIELDC" -> "FPC" +"FFIELDC" -> "FINITE" +"FFIELDC" -> "STEP" +"FFIELDC" -> "DIFRING" + +@ +<>= +"FiniteFieldCategory()" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FFIELDC"]; +"FiniteFieldCategory()" -> "FieldOfPrimeCharacteristic()" +"FiniteFieldCategory()" -> "Finite()" +"FiniteFieldCategory()" -> "StepThrough()" +"FiniteFieldCategory()" -> "DifferentialRing()" + +@ +<>= +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} + + +<>= +)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" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FAXF"]; +"FAXF" -> "XF" +"FAXF" -> "RETRACT" + +@ +<>= +"FiniteAlgebraicExtensionField(a:Field)" + [color=lightblue,href="bookvol10.2.pdf#nameddest=FAXF"]; +"FiniteAlgebraicExtensionField(a:Field)" -> "ExtensionField(a:Field)" +"FiniteAlgebraicExtensionField(a:Field)" -> "RetractableTo(a:Field)" + +@ +<>= +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. + +<>= + +(|/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{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. <> <> <> +<> <> <> <> <> <> +<> <> <> <> @@ -29805,11 +31546,13 @@ digraph dotabb { <> <> <> +<> <> <> <> <> <> +<> <> <> <> @@ -29928,11 +31671,13 @@ digraph 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